GNU Linux-libre 5.10.219-gnu1
[releases.git] / fs / nfs / nfs4client.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  */
6 #include <linux/module.h>
7 #include <linux/nfs_fs.h>
8 #include <linux/nfs_mount.h>
9 #include <linux/sunrpc/addr.h>
10 #include <linux/sunrpc/auth.h>
11 #include <linux/sunrpc/xprt.h>
12 #include <linux/sunrpc/bc_xprt.h>
13 #include <linux/sunrpc/rpc_pipe_fs.h>
14 #include "internal.h"
15 #include "callback.h"
16 #include "delegation.h"
17 #include "nfs4session.h"
18 #include "nfs4idmap.h"
19 #include "pnfs.h"
20 #include "netns.h"
21
22 #define NFSDBG_FACILITY         NFSDBG_CLIENT
23
24 /*
25  * Get a unique NFSv4.0 callback identifier which will be used
26  * by the V4.0 callback service to lookup the nfs_client struct
27  */
28 static int nfs_get_cb_ident_idr(struct nfs_client *clp, int minorversion)
29 {
30         int ret = 0;
31         struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
32
33         if (clp->rpc_ops->version != 4 || minorversion != 0)
34                 return ret;
35         idr_preload(GFP_KERNEL);
36         spin_lock(&nn->nfs_client_lock);
37         ret = idr_alloc(&nn->cb_ident_idr, clp, 1, 0, GFP_NOWAIT);
38         if (ret >= 0)
39                 clp->cl_cb_ident = ret;
40         spin_unlock(&nn->nfs_client_lock);
41         idr_preload_end();
42         return ret < 0 ? ret : 0;
43 }
44
45 #ifdef CONFIG_NFS_V4_1
46 /*
47  * Per auth flavor data server rpc clients
48  */
49 struct nfs4_ds_server {
50         struct list_head        list;   /* ds_clp->cl_ds_clients */
51         struct rpc_clnt         *rpc_clnt;
52 };
53
54 /**
55  * nfs4_find_ds_client - Common lookup case for DS I/O
56  * @ds_clp: pointer to the DS's nfs_client
57  * @flavor: rpc auth flavour to match
58  */
59 static struct nfs4_ds_server *
60 nfs4_find_ds_client(struct nfs_client *ds_clp, rpc_authflavor_t flavor)
61 {
62         struct nfs4_ds_server *dss;
63
64         rcu_read_lock();
65         list_for_each_entry_rcu(dss, &ds_clp->cl_ds_clients, list) {
66                 if (dss->rpc_clnt->cl_auth->au_flavor != flavor)
67                         continue;
68                 goto out;
69         }
70         dss = NULL;
71 out:
72         rcu_read_unlock();
73         return dss;
74 }
75
76 static struct nfs4_ds_server *
77 nfs4_add_ds_client(struct nfs_client *ds_clp, rpc_authflavor_t flavor,
78                            struct nfs4_ds_server *new)
79 {
80         struct nfs4_ds_server *dss;
81
82         spin_lock(&ds_clp->cl_lock);
83         list_for_each_entry(dss, &ds_clp->cl_ds_clients, list) {
84                 if (dss->rpc_clnt->cl_auth->au_flavor != flavor)
85                         continue;
86                 goto out;
87         }
88         if (new)
89                 list_add_rcu(&new->list, &ds_clp->cl_ds_clients);
90         dss = new;
91 out:
92         spin_unlock(&ds_clp->cl_lock); /* need some lock to protect list */
93         return dss;
94 }
95
96 static struct nfs4_ds_server *
97 nfs4_alloc_ds_server(struct nfs_client *ds_clp, rpc_authflavor_t flavor)
98 {
99         struct nfs4_ds_server *dss;
100
101         dss = kmalloc(sizeof(*dss), GFP_NOFS);
102         if (dss == NULL)
103                 return ERR_PTR(-ENOMEM);
104
105         dss->rpc_clnt = rpc_clone_client_set_auth(ds_clp->cl_rpcclient, flavor);
106         if (IS_ERR(dss->rpc_clnt)) {
107                 int err = PTR_ERR(dss->rpc_clnt);
108                 kfree (dss);
109                 return ERR_PTR(err);
110         }
111         INIT_LIST_HEAD(&dss->list);
112
113         return dss;
114 }
115
116 static void
117 nfs4_free_ds_server(struct nfs4_ds_server *dss)
118 {
119         rpc_release_client(dss->rpc_clnt);
120         kfree(dss);
121 }
122
123 /**
124  * nfs4_find_or_create_ds_client - Find or create a DS rpc client
125  * @ds_clp: pointer to the DS's nfs_client
126  * @inode: pointer to the inode
127  *
128  * Find or create a DS rpc client with th MDS server rpc client auth flavor
129  * in the nfs_client cl_ds_clients list.
130  */
131 struct rpc_clnt *
132 nfs4_find_or_create_ds_client(struct nfs_client *ds_clp, struct inode *inode)
133 {
134         struct nfs4_ds_server *dss, *new;
135         rpc_authflavor_t flavor = NFS_SERVER(inode)->client->cl_auth->au_flavor;
136
137         dss = nfs4_find_ds_client(ds_clp, flavor);
138         if (dss != NULL)
139                 goto out;
140         new = nfs4_alloc_ds_server(ds_clp, flavor);
141         if (IS_ERR(new))
142                 return ERR_CAST(new);
143         dss = nfs4_add_ds_client(ds_clp, flavor, new);
144         if (dss != new)
145                 nfs4_free_ds_server(new);
146 out:
147         return dss->rpc_clnt;
148 }
149 EXPORT_SYMBOL_GPL(nfs4_find_or_create_ds_client);
150
151 static void
152 nfs4_shutdown_ds_clients(struct nfs_client *clp)
153 {
154         struct nfs4_ds_server *dss;
155
156         while (!list_empty(&clp->cl_ds_clients)) {
157                 dss = list_entry(clp->cl_ds_clients.next,
158                                         struct nfs4_ds_server, list);
159                 list_del(&dss->list);
160                 rpc_shutdown_client(dss->rpc_clnt);
161                 kfree (dss);
162         }
163 }
164
165 static void
166 nfs4_cleanup_callback(struct nfs_client *clp)
167 {
168         struct nfs4_copy_state *cp_state;
169
170         while (!list_empty(&clp->pending_cb_stateids)) {
171                 cp_state = list_entry(clp->pending_cb_stateids.next,
172                                         struct nfs4_copy_state, copies);
173                 list_del(&cp_state->copies);
174                 kfree(cp_state);
175         }
176 }
177
178 void nfs41_shutdown_client(struct nfs_client *clp)
179 {
180         if (nfs4_has_session(clp)) {
181                 nfs4_cleanup_callback(clp);
182                 nfs4_shutdown_ds_clients(clp);
183                 nfs4_destroy_session(clp->cl_session);
184                 nfs4_destroy_clientid(clp);
185         }
186
187 }
188 #endif  /* CONFIG_NFS_V4_1 */
189
190 void nfs40_shutdown_client(struct nfs_client *clp)
191 {
192         if (clp->cl_slot_tbl) {
193                 nfs4_shutdown_slot_table(clp->cl_slot_tbl);
194                 kfree(clp->cl_slot_tbl);
195         }
196 }
197
198 struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init)
199 {
200         char buf[INET6_ADDRSTRLEN + 1];
201         const char *ip_addr = cl_init->ip_addr;
202         struct nfs_client *clp = nfs_alloc_client(cl_init);
203         int err;
204
205         if (IS_ERR(clp))
206                 return clp;
207
208         err = nfs_get_cb_ident_idr(clp, cl_init->minorversion);
209         if (err)
210                 goto error;
211
212         if (cl_init->minorversion > NFS4_MAX_MINOR_VERSION) {
213                 err = -EINVAL;
214                 goto error;
215         }
216
217         spin_lock_init(&clp->cl_lock);
218         INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
219         INIT_LIST_HEAD(&clp->cl_ds_clients);
220         rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
221         clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
222         clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];
223         clp->cl_mig_gen = 1;
224 #if IS_ENABLED(CONFIG_NFS_V4_1)
225         init_waitqueue_head(&clp->cl_lock_waitq);
226 #endif
227         INIT_LIST_HEAD(&clp->pending_cb_stateids);
228
229         if (cl_init->minorversion != 0)
230                 __set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags);
231         __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags);
232         __set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags);
233
234         /*
235          * Set up the connection to the server before we add add to the
236          * global list.
237          */
238         err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_GSS_KRB5I);
239         if (err == -EINVAL)
240                 err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX);
241         if (err < 0)
242                 goto error;
243
244         /* If no clientaddr= option was specified, find a usable cb address */
245         if (ip_addr == NULL) {
246                 struct sockaddr_storage cb_addr;
247                 struct sockaddr *sap = (struct sockaddr *)&cb_addr;
248
249                 err = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr));
250                 if (err < 0)
251                         goto error;
252                 err = rpc_ntop(sap, buf, sizeof(buf));
253                 if (err < 0)
254                         goto error;
255                 ip_addr = (const char *)buf;
256         }
257         strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
258
259         err = nfs_idmap_new(clp);
260         if (err < 0) {
261                 dprintk("%s: failed to create idmapper. Error = %d\n",
262                         __func__, err);
263                 goto error;
264         }
265         __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
266         return clp;
267
268 error:
269         nfs_free_client(clp);
270         return ERR_PTR(err);
271 }
272
273 /*
274  * Destroy the NFS4 callback service
275  */
276 static void nfs4_destroy_callback(struct nfs_client *clp)
277 {
278         if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
279                 nfs_callback_down(clp->cl_mvops->minor_version, clp->cl_net);
280 }
281
282 static void nfs4_shutdown_client(struct nfs_client *clp)
283 {
284         if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
285                 nfs4_kill_renewd(clp);
286         clp->cl_mvops->shutdown_client(clp);
287         nfs4_destroy_callback(clp);
288         if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
289                 nfs_idmap_delete(clp);
290
291         rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
292         kfree(clp->cl_serverowner);
293         kfree(clp->cl_serverscope);
294         kfree(clp->cl_implid);
295         kfree(clp->cl_owner_id);
296 }
297
298 void nfs4_free_client(struct nfs_client *clp)
299 {
300         nfs4_shutdown_client(clp);
301         nfs_free_client(clp);
302 }
303
304 /*
305  * Initialize the NFS4 callback service
306  */
307 static int nfs4_init_callback(struct nfs_client *clp)
308 {
309         struct rpc_xprt *xprt;
310         int error;
311
312         xprt = rcu_dereference_raw(clp->cl_rpcclient->cl_xprt);
313
314         if (nfs4_has_session(clp)) {
315                 error = xprt_setup_backchannel(xprt, NFS41_BC_MIN_CALLBACKS);
316                 if (error < 0)
317                         return error;
318         }
319
320         error = nfs_callback_up(clp->cl_mvops->minor_version, xprt);
321         if (error < 0) {
322                 dprintk("%s: failed to start callback. Error = %d\n",
323                         __func__, error);
324                 return error;
325         }
326         __set_bit(NFS_CS_CALLBACK, &clp->cl_res_state);
327
328         return 0;
329 }
330
331 /**
332  * nfs40_init_client - nfs_client initialization tasks for NFSv4.0
333  * @clp: nfs_client to initialize
334  *
335  * Returns zero on success, or a negative errno if some error occurred.
336  */
337 int nfs40_init_client(struct nfs_client *clp)
338 {
339         struct nfs4_slot_table *tbl;
340         int ret;
341
342         tbl = kzalloc(sizeof(*tbl), GFP_NOFS);
343         if (tbl == NULL)
344                 return -ENOMEM;
345
346         ret = nfs4_setup_slot_table(tbl, NFS4_MAX_SLOT_TABLE,
347                                         "NFSv4.0 transport Slot table");
348         if (ret) {
349                 nfs4_shutdown_slot_table(tbl);
350                 kfree(tbl);
351                 return ret;
352         }
353
354         clp->cl_slot_tbl = tbl;
355         return 0;
356 }
357
358 #if defined(CONFIG_NFS_V4_1)
359
360 /**
361  * nfs41_init_client - nfs_client initialization tasks for NFSv4.1+
362  * @clp: nfs_client to initialize
363  *
364  * Returns zero on success, or a negative errno if some error occurred.
365  */
366 int nfs41_init_client(struct nfs_client *clp)
367 {
368         struct nfs4_session *session = NULL;
369
370         /*
371          * Create the session and mark it expired.
372          * When a SEQUENCE operation encounters the expired session
373          * it will do session recovery to initialize it.
374          */
375         session = nfs4_alloc_session(clp);
376         if (!session)
377                 return -ENOMEM;
378
379         clp->cl_session = session;
380
381         /*
382          * The create session reply races with the server back
383          * channel probe. Mark the client NFS_CS_SESSION_INITING
384          * so that the client back channel can find the
385          * nfs_client struct
386          */
387         nfs_mark_client_ready(clp, NFS_CS_SESSION_INITING);
388         return 0;
389 }
390
391 #endif  /* CONFIG_NFS_V4_1 */
392
393 /*
394  * Initialize the minor version specific parts of an NFS4 client record
395  */
396 static int nfs4_init_client_minor_version(struct nfs_client *clp)
397 {
398         int ret;
399
400         ret = clp->cl_mvops->init_client(clp);
401         if (ret)
402                 return ret;
403         return nfs4_init_callback(clp);
404 }
405
406 /**
407  * nfs4_init_client - Initialise an NFS4 client record
408  *
409  * @clp: nfs_client to initialise
410  * @cl_init: pointer to nfs_client_initdata
411  *
412  * Returns pointer to an NFS client, or an ERR_PTR value.
413  */
414 struct nfs_client *nfs4_init_client(struct nfs_client *clp,
415                                     const struct nfs_client_initdata *cl_init)
416 {
417         struct nfs_client *old;
418         int error;
419
420         if (clp->cl_cons_state == NFS_CS_READY)
421                 /* the client is initialised already */
422                 return clp;
423
424         error = nfs4_init_client_minor_version(clp);
425         if (error < 0)
426                 goto error;
427
428         error = nfs4_discover_server_trunking(clp, &old);
429         if (error < 0)
430                 goto error;
431
432         if (clp != old) {
433                 clp->cl_preserve_clid = true;
434                 /*
435                  * Mark the client as having failed initialization so other
436                  * processes walking the nfs_client_list in nfs_match_client()
437                  * won't try to use it.
438                  */
439                 nfs_mark_client_ready(clp, -EPERM);
440         }
441         clear_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags);
442         nfs_put_client(clp);
443         return old;
444
445 error:
446         nfs_mark_client_ready(clp, error);
447         nfs_put_client(clp);
448         return ERR_PTR(error);
449 }
450
451 /*
452  * SETCLIENTID just did a callback update with the callback ident in
453  * "drop," but server trunking discovery claims "drop" and "keep" are
454  * actually the same server.  Swap the callback IDs so that "keep"
455  * will continue to use the callback ident the server now knows about,
456  * and so that "keep"'s original callback ident is destroyed when
457  * "drop" is freed.
458  */
459 static void nfs4_swap_callback_idents(struct nfs_client *keep,
460                                       struct nfs_client *drop)
461 {
462         struct nfs_net *nn = net_generic(keep->cl_net, nfs_net_id);
463         unsigned int save = keep->cl_cb_ident;
464
465         if (keep->cl_cb_ident == drop->cl_cb_ident)
466                 return;
467
468         dprintk("%s: keeping callback ident %u and dropping ident %u\n",
469                 __func__, keep->cl_cb_ident, drop->cl_cb_ident);
470
471         spin_lock(&nn->nfs_client_lock);
472
473         idr_replace(&nn->cb_ident_idr, keep, drop->cl_cb_ident);
474         keep->cl_cb_ident = drop->cl_cb_ident;
475
476         idr_replace(&nn->cb_ident_idr, drop, save);
477         drop->cl_cb_ident = save;
478
479         spin_unlock(&nn->nfs_client_lock);
480 }
481
482 static bool nfs4_match_client_owner_id(const struct nfs_client *clp1,
483                 const struct nfs_client *clp2)
484 {
485         if (clp1->cl_owner_id == NULL || clp2->cl_owner_id == NULL)
486                 return true;
487         return strcmp(clp1->cl_owner_id, clp2->cl_owner_id) == 0;
488 }
489
490 static bool nfs4_same_verifier(nfs4_verifier *v1, nfs4_verifier *v2)
491 {
492         return memcmp(v1->data, v2->data, sizeof(v1->data)) == 0;
493 }
494
495 static int nfs4_match_client(struct nfs_client  *pos,  struct nfs_client *new,
496                              struct nfs_client **prev, struct nfs_net *nn)
497 {
498         int status;
499
500         if (pos->rpc_ops != new->rpc_ops)
501                 return 1;
502
503         if (pos->cl_minorversion != new->cl_minorversion)
504                 return 1;
505
506         /* If "pos" isn't marked ready, we can't trust the
507          * remaining fields in "pos", especially the client
508          * ID and serverowner fields.  Wait for CREATE_SESSION
509          * to finish. */
510         if (pos->cl_cons_state > NFS_CS_READY) {
511                 refcount_inc(&pos->cl_count);
512                 spin_unlock(&nn->nfs_client_lock);
513
514                 nfs_put_client(*prev);
515                 *prev = pos;
516
517                 status = nfs_wait_client_init_complete(pos);
518                 spin_lock(&nn->nfs_client_lock);
519
520                 if (status < 0)
521                         return status;
522         }
523
524         if (pos->cl_cons_state != NFS_CS_READY)
525                 return 1;
526
527         if (pos->cl_clientid != new->cl_clientid)
528                 return 1;
529
530         /* NFSv4.1 always uses the uniform string, however someone
531          * might switch the uniquifier string on us.
532          */
533         if (!nfs4_match_client_owner_id(pos, new))
534                 return 1;
535
536         return 0;
537 }
538
539 /**
540  * nfs40_walk_client_list - Find server that recognizes a client ID
541  *
542  * @new: nfs_client with client ID to test
543  * @result: OUT: found nfs_client, or new
544  * @cred: credential to use for trunking test
545  *
546  * Returns zero, a negative errno, or a negative NFS4ERR status.
547  * If zero is returned, an nfs_client pointer is planted in "result."
548  *
549  * NB: nfs40_walk_client_list() relies on the new nfs_client being
550  *     the last nfs_client on the list.
551  */
552 int nfs40_walk_client_list(struct nfs_client *new,
553                            struct nfs_client **result,
554                            const struct cred *cred)
555 {
556         struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
557         struct nfs_client *pos, *prev = NULL;
558         struct nfs4_setclientid_res clid = {
559                 .clientid       = new->cl_clientid,
560                 .confirm        = new->cl_confirm,
561         };
562         int status = -NFS4ERR_STALE_CLIENTID;
563
564         spin_lock(&nn->nfs_client_lock);
565         list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) {
566
567                 if (pos == new)
568                         goto found;
569
570                 status = nfs4_match_client(pos, new, &prev, nn);
571                 if (status < 0)
572                         goto out_unlock;
573                 if (status != 0)
574                         continue;
575                 /*
576                  * We just sent a new SETCLIENTID, which should have
577                  * caused the server to return a new cl_confirm.  So if
578                  * cl_confirm is the same, then this is a different
579                  * server that just returned the same cl_confirm by
580                  * coincidence:
581                  */
582                 if ((new != pos) && nfs4_same_verifier(&pos->cl_confirm,
583                                                        &new->cl_confirm))
584                         continue;
585                 /*
586                  * But if the cl_confirm's are different, then the only
587                  * way that a SETCLIENTID_CONFIRM to pos can succeed is
588                  * if new and pos point to the same server:
589                  */
590 found:
591                 refcount_inc(&pos->cl_count);
592                 spin_unlock(&nn->nfs_client_lock);
593
594                 nfs_put_client(prev);
595                 prev = pos;
596
597                 status = nfs4_proc_setclientid_confirm(pos, &clid, cred);
598                 switch (status) {
599                 case -NFS4ERR_STALE_CLIENTID:
600                         break;
601                 case 0:
602                         nfs4_swap_callback_idents(pos, new);
603                         pos->cl_confirm = new->cl_confirm;
604                         nfs_mark_client_ready(pos, NFS_CS_READY);
605
606                         prev = NULL;
607                         *result = pos;
608                         goto out;
609                 case -ERESTARTSYS:
610                 case -ETIMEDOUT:
611                         /* The callback path may have been inadvertently
612                          * changed. Schedule recovery!
613                          */
614                         nfs4_schedule_path_down_recovery(pos);
615                 default:
616                         goto out;
617                 }
618
619                 spin_lock(&nn->nfs_client_lock);
620         }
621 out_unlock:
622         spin_unlock(&nn->nfs_client_lock);
623
624         /* No match found. The server lost our clientid */
625 out:
626         nfs_put_client(prev);
627         return status;
628 }
629
630 #ifdef CONFIG_NFS_V4_1
631 /*
632  * Returns true if the server major ids match
633  */
634 bool
635 nfs4_check_serverowner_major_id(struct nfs41_server_owner *o1,
636                                 struct nfs41_server_owner *o2)
637 {
638         if (o1->major_id_sz != o2->major_id_sz)
639                 return false;
640         return memcmp(o1->major_id, o2->major_id, o1->major_id_sz) == 0;
641 }
642
643 /*
644  * Returns true if the server scopes match
645  */
646 static bool
647 nfs4_check_server_scope(struct nfs41_server_scope *s1,
648                         struct nfs41_server_scope *s2)
649 {
650         if (s1->server_scope_sz != s2->server_scope_sz)
651                 return false;
652         return memcmp(s1->server_scope, s2->server_scope,
653                                         s1->server_scope_sz) == 0;
654 }
655
656 /**
657  * nfs4_detect_session_trunking - Checks for session trunking.
658  * @clp:    original mount nfs_client
659  * @res:    result structure from an exchange_id using the original mount
660  *          nfs_client with a new multi_addr transport
661  * @xprt:   pointer to the transport to add.
662  *
663  * Called after a successful EXCHANGE_ID on a multi-addr connection.
664  * Upon success, add the transport.
665  *
666  * Returns zero on success, otherwise -EINVAL
667  *
668  * Note: since the exchange_id for the new multi_addr transport uses the
669  * same nfs_client from the original mount, the cl_owner_id is reused,
670  * so eir_clientowner is the same.
671  */
672 int nfs4_detect_session_trunking(struct nfs_client *clp,
673                                  struct nfs41_exchange_id_res *res,
674                                  struct rpc_xprt *xprt)
675 {
676         /* Check eir_clientid */
677         if (clp->cl_clientid != res->clientid)
678                 goto out_err;
679
680         /* Check eir_server_owner so_major_id */
681         if (!nfs4_check_serverowner_major_id(clp->cl_serverowner,
682                                              res->server_owner))
683                 goto out_err;
684
685         /* Check eir_server_owner so_minor_id */
686         if (clp->cl_serverowner->minor_id != res->server_owner->minor_id)
687                 goto out_err;
688
689         /* Check eir_server_scope */
690         if (!nfs4_check_server_scope(clp->cl_serverscope, res->server_scope))
691                 goto out_err;
692
693         pr_info("NFS:  %s: Session trunking succeeded for %s\n",
694                 clp->cl_hostname,
695                 xprt->address_strings[RPC_DISPLAY_ADDR]);
696
697         return 0;
698 out_err:
699         pr_info("NFS:  %s: Session trunking failed for %s\n", clp->cl_hostname,
700                 xprt->address_strings[RPC_DISPLAY_ADDR]);
701
702         return -EINVAL;
703 }
704
705 /**
706  * nfs41_walk_client_list - Find nfs_client that matches a client/server owner
707  *
708  * @new: nfs_client with client ID to test
709  * @result: OUT: found nfs_client, or new
710  * @cred: credential to use for trunking test
711  *
712  * Returns zero, a negative errno, or a negative NFS4ERR status.
713  * If zero is returned, an nfs_client pointer is planted in "result."
714  *
715  * NB: nfs41_walk_client_list() relies on the new nfs_client being
716  *     the last nfs_client on the list.
717  */
718 int nfs41_walk_client_list(struct nfs_client *new,
719                            struct nfs_client **result,
720                            const struct cred *cred)
721 {
722         struct nfs_net *nn = net_generic(new->cl_net, nfs_net_id);
723         struct nfs_client *pos, *prev = NULL;
724         int status = -NFS4ERR_STALE_CLIENTID;
725
726         spin_lock(&nn->nfs_client_lock);
727         list_for_each_entry(pos, &nn->nfs_client_list, cl_share_link) {
728
729                 if (pos == new)
730                         goto found;
731
732                 status = nfs4_match_client(pos, new, &prev, nn);
733                 if (status < 0)
734                         goto out;
735                 if (status != 0)
736                         continue;
737
738                 /*
739                  * Note that session trunking is just a special subcase of
740                  * client id trunking. In either case, we want to fall back
741                  * to using the existing nfs_client.
742                  */
743                 if (!nfs4_check_serverowner_major_id(pos->cl_serverowner,
744                                                      new->cl_serverowner))
745                         continue;
746
747 found:
748                 refcount_inc(&pos->cl_count);
749                 *result = pos;
750                 status = 0;
751                 break;
752         }
753
754 out:
755         spin_unlock(&nn->nfs_client_lock);
756         nfs_put_client(prev);
757         return status;
758 }
759 #endif  /* CONFIG_NFS_V4_1 */
760
761 static void nfs4_destroy_server(struct nfs_server *server)
762 {
763         LIST_HEAD(freeme);
764
765         nfs_server_return_all_delegations(server);
766         unset_pnfs_layoutdriver(server);
767         nfs4_purge_state_owners(server, &freeme);
768         nfs4_free_state_owners(&freeme);
769 }
770
771 /*
772  * NFSv4.0 callback thread helper
773  *
774  * Find a client by callback identifier
775  */
776 struct nfs_client *
777 nfs4_find_client_ident(struct net *net, int cb_ident)
778 {
779         struct nfs_client *clp;
780         struct nfs_net *nn = net_generic(net, nfs_net_id);
781
782         spin_lock(&nn->nfs_client_lock);
783         clp = idr_find(&nn->cb_ident_idr, cb_ident);
784         if (clp)
785                 refcount_inc(&clp->cl_count);
786         spin_unlock(&nn->nfs_client_lock);
787         return clp;
788 }
789
790 #if defined(CONFIG_NFS_V4_1)
791 /* Common match routine for v4.0 and v4.1 callback services */
792 static bool nfs4_cb_match_client(const struct sockaddr *addr,
793                 struct nfs_client *clp, u32 minorversion)
794 {
795         struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
796
797         /* Don't match clients that failed to initialise */
798         if (!(clp->cl_cons_state == NFS_CS_READY ||
799             clp->cl_cons_state == NFS_CS_SESSION_INITING))
800                 return false;
801
802         smp_rmb();
803
804         /* Match the version and minorversion */
805         if (clp->rpc_ops->version != 4 ||
806             clp->cl_minorversion != minorversion)
807                 return false;
808
809         /* Match only the IP address, not the port number */
810         return rpc_cmp_addr(addr, clap);
811 }
812
813 /*
814  * NFSv4.1 callback thread helper
815  * For CB_COMPOUND calls, find a client by IP address, protocol version,
816  * minorversion, and sessionID
817  *
818  * Returns NULL if no such client
819  */
820 struct nfs_client *
821 nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
822                            struct nfs4_sessionid *sid, u32 minorversion)
823 {
824         struct nfs_client *clp;
825         struct nfs_net *nn = net_generic(net, nfs_net_id);
826
827         spin_lock(&nn->nfs_client_lock);
828         list_for_each_entry(clp, &nn->nfs_client_list, cl_share_link) {
829                 if (!nfs4_cb_match_client(addr, clp, minorversion))
830                         continue;
831
832                 if (!nfs4_has_session(clp))
833                         continue;
834
835                 /* Match sessionid*/
836                 if (memcmp(clp->cl_session->sess_id.data,
837                     sid->data, NFS4_MAX_SESSIONID_LEN) != 0)
838                         continue;
839
840                 refcount_inc(&clp->cl_count);
841                 spin_unlock(&nn->nfs_client_lock);
842                 return clp;
843         }
844         spin_unlock(&nn->nfs_client_lock);
845         return NULL;
846 }
847
848 #else /* CONFIG_NFS_V4_1 */
849
850 struct nfs_client *
851 nfs4_find_client_sessionid(struct net *net, const struct sockaddr *addr,
852                            struct nfs4_sessionid *sid, u32 minorversion)
853 {
854         return NULL;
855 }
856 #endif /* CONFIG_NFS_V4_1 */
857
858 /*
859  * Set up an NFS4 client
860  */
861 static int nfs4_set_client(struct nfs_server *server,
862                 const char *hostname,
863                 const struct sockaddr *addr,
864                 const size_t addrlen,
865                 const char *ip_addr,
866                 int proto, const struct rpc_timeout *timeparms,
867                 u32 minorversion, unsigned int nconnect,
868                 struct net *net)
869 {
870         struct nfs_client_initdata cl_init = {
871                 .hostname = hostname,
872                 .addr = addr,
873                 .addrlen = addrlen,
874                 .ip_addr = ip_addr,
875                 .nfs_mod = &nfs_v4,
876                 .proto = proto,
877                 .minorversion = minorversion,
878                 .net = net,
879                 .timeparms = timeparms,
880                 .cred = server->cred,
881         };
882         struct nfs_client *clp;
883
884         if (minorversion == 0)
885                 __set_bit(NFS_CS_REUSEPORT, &cl_init.init_flags);
886         if (proto == XPRT_TRANSPORT_TCP)
887                 cl_init.nconnect = nconnect;
888
889         if (server->flags & NFS_MOUNT_NORESVPORT)
890                 __set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
891         if (server->options & NFS_OPTION_MIGRATION)
892                 __set_bit(NFS_CS_MIGRATION, &cl_init.init_flags);
893         if (test_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status))
894                 __set_bit(NFS_CS_TSM_POSSIBLE, &cl_init.init_flags);
895         server->port = rpc_get_port(addr);
896
897         /* Allocate or find a client reference we can use */
898         clp = nfs_get_client(&cl_init);
899         if (IS_ERR(clp))
900                 return PTR_ERR(clp);
901
902         if (server->nfs_client == clp) {
903                 nfs_put_client(clp);
904                 return -ELOOP;
905         }
906
907         /*
908          * Query for the lease time on clientid setup or renewal
909          *
910          * Note that this will be set on nfs_clients that were created
911          * only for the DS role and did not set this bit, but now will
912          * serve a dual role.
913          */
914         set_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state);
915
916         server->nfs_client = clp;
917         return 0;
918 }
919
920 /*
921  * Set up a pNFS Data Server client.
922  *
923  * Return any existing nfs_client that matches server address,port,version
924  * and minorversion.
925  *
926  * For a new nfs_client, use a soft mount (default), a low retrans and a
927  * low timeout interval so that if a connection is lost, we retry through
928  * the MDS.
929  */
930 struct nfs_client *nfs4_set_ds_client(struct nfs_server *mds_srv,
931                 const struct sockaddr *ds_addr, int ds_addrlen,
932                 int ds_proto, unsigned int ds_timeo, unsigned int ds_retrans,
933                 u32 minor_version)
934 {
935         struct rpc_timeout ds_timeout;
936         struct nfs_client *mds_clp = mds_srv->nfs_client;
937         struct nfs_client_initdata cl_init = {
938                 .addr = ds_addr,
939                 .addrlen = ds_addrlen,
940                 .nodename = mds_clp->cl_rpcclient->cl_nodename,
941                 .ip_addr = mds_clp->cl_ipaddr,
942                 .nfs_mod = &nfs_v4,
943                 .proto = ds_proto,
944                 .minorversion = minor_version,
945                 .net = mds_clp->cl_net,
946                 .timeparms = &ds_timeout,
947                 .cred = mds_srv->cred,
948         };
949         char buf[INET6_ADDRSTRLEN + 1];
950
951         if (rpc_ntop(ds_addr, buf, sizeof(buf)) <= 0)
952                 return ERR_PTR(-EINVAL);
953         cl_init.hostname = buf;
954
955         if (mds_clp->cl_nconnect > 1 && ds_proto == XPRT_TRANSPORT_TCP)
956                 cl_init.nconnect = mds_clp->cl_nconnect;
957
958         if (mds_srv->flags & NFS_MOUNT_NORESVPORT)
959                 __set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
960
961         /*
962          * Set an authflavor equual to the MDS value. Use the MDS nfs_client
963          * cl_ipaddr so as to use the same EXCHANGE_ID co_ownerid as the MDS
964          * (section 13.1 RFC 5661).
965          */
966         nfs_init_timeout_values(&ds_timeout, ds_proto, ds_timeo, ds_retrans);
967         return nfs_get_client(&cl_init);
968 }
969 EXPORT_SYMBOL_GPL(nfs4_set_ds_client);
970
971 /*
972  * Session has been established, and the client marked ready.
973  * Limit the mount rsize, wsize and dtsize using negotiated fore
974  * channel attributes.
975  */
976 static void nfs4_session_limit_rwsize(struct nfs_server *server)
977 {
978 #ifdef CONFIG_NFS_V4_1
979         struct nfs4_session *sess;
980         u32 server_resp_sz;
981         u32 server_rqst_sz;
982
983         if (!nfs4_has_session(server->nfs_client))
984                 return;
985         sess = server->nfs_client->cl_session;
986         server_resp_sz = sess->fc_attrs.max_resp_sz - nfs41_maxread_overhead;
987         server_rqst_sz = sess->fc_attrs.max_rqst_sz - nfs41_maxwrite_overhead;
988
989         if (server->dtsize > server_resp_sz)
990                 server->dtsize = server_resp_sz;
991         if (server->rsize > server_resp_sz)
992                 server->rsize = server_resp_sz;
993         if (server->wsize > server_rqst_sz)
994                 server->wsize = server_rqst_sz;
995 #endif /* CONFIG_NFS_V4_1 */
996 }
997
998 /*
999  * Limit xattr sizes using the channel attributes.
1000  */
1001 static void nfs4_session_limit_xasize(struct nfs_server *server)
1002 {
1003 #ifdef CONFIG_NFS_V4_2
1004         struct nfs4_session *sess;
1005         u32 server_gxa_sz;
1006         u32 server_sxa_sz;
1007         u32 server_lxa_sz;
1008
1009         if (!nfs4_has_session(server->nfs_client))
1010                 return;
1011
1012         sess = server->nfs_client->cl_session;
1013
1014         server_gxa_sz = sess->fc_attrs.max_resp_sz - nfs42_maxgetxattr_overhead;
1015         server_sxa_sz = sess->fc_attrs.max_rqst_sz - nfs42_maxsetxattr_overhead;
1016         server_lxa_sz = sess->fc_attrs.max_resp_sz -
1017             nfs42_maxlistxattrs_overhead;
1018
1019         if (server->gxasize > server_gxa_sz)
1020                 server->gxasize = server_gxa_sz;
1021         if (server->sxasize > server_sxa_sz)
1022                 server->sxasize = server_sxa_sz;
1023         if (server->lxasize > server_lxa_sz)
1024                 server->lxasize = server_lxa_sz;
1025 #endif
1026 }
1027
1028 static int nfs4_server_common_setup(struct nfs_server *server,
1029                 struct nfs_fh *mntfh, bool auth_probe)
1030 {
1031         struct nfs_fattr *fattr;
1032         int error;
1033
1034         /* data servers support only a subset of NFSv4.1 */
1035         if (is_ds_only_client(server->nfs_client))
1036                 return -EPROTONOSUPPORT;
1037
1038         fattr = nfs_alloc_fattr();
1039         if (fattr == NULL)
1040                 return -ENOMEM;
1041
1042         /* We must ensure the session is initialised first */
1043         error = nfs4_init_session(server->nfs_client);
1044         if (error < 0)
1045                 goto out;
1046
1047         /* Set the basic capabilities */
1048         server->caps |= server->nfs_client->cl_mvops->init_caps;
1049         if (server->flags & NFS_MOUNT_NORDIRPLUS)
1050                         server->caps &= ~NFS_CAP_READDIRPLUS;
1051         if (server->nfs_client->cl_proto == XPRT_TRANSPORT_RDMA)
1052                 server->caps &= ~NFS_CAP_READ_PLUS;
1053         /*
1054          * Don't use NFS uid/gid mapping if we're using AUTH_SYS or lower
1055          * authentication.
1056          */
1057         if (nfs4_disable_idmapping &&
1058                         server->client->cl_auth->au_flavor == RPC_AUTH_UNIX)
1059                 server->caps |= NFS_CAP_UIDGID_NOMAP;
1060
1061
1062         /* Probe the root fh to retrieve its FSID and filehandle */
1063         error = nfs4_get_rootfh(server, mntfh, auth_probe);
1064         if (error < 0)
1065                 goto out;
1066
1067         dprintk("Server FSID: %llx:%llx\n",
1068                         (unsigned long long) server->fsid.major,
1069                         (unsigned long long) server->fsid.minor);
1070         nfs_display_fhandle(mntfh, "Pseudo-fs root FH");
1071
1072         error = nfs_probe_fsinfo(server, mntfh, fattr);
1073         if (error < 0)
1074                 goto out;
1075
1076         nfs4_session_limit_rwsize(server);
1077         nfs4_session_limit_xasize(server);
1078
1079         if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
1080                 server->namelen = NFS4_MAXNAMLEN;
1081
1082         nfs_server_insert_lists(server);
1083         server->mount_time = jiffies;
1084         server->destroy = nfs4_destroy_server;
1085 out:
1086         nfs_free_fattr(fattr);
1087         return error;
1088 }
1089
1090 /*
1091  * Create a version 4 volume record
1092  */
1093 static int nfs4_init_server(struct nfs_server *server, struct fs_context *fc)
1094 {
1095         struct nfs_fs_context *ctx = nfs_fc2context(fc);
1096         struct rpc_timeout timeparms;
1097         int error;
1098
1099         nfs_init_timeout_values(&timeparms, ctx->nfs_server.protocol,
1100                                 ctx->timeo, ctx->retrans);
1101
1102         /* Initialise the client representation from the mount data */
1103         server->flags = ctx->flags;
1104         server->options = ctx->options;
1105         server->auth_info = ctx->auth_info;
1106
1107         /* Use the first specified auth flavor. If this flavor isn't
1108          * allowed by the server, use the SECINFO path to try the
1109          * other specified flavors */
1110         if (ctx->auth_info.flavor_len >= 1)
1111                 ctx->selected_flavor = ctx->auth_info.flavors[0];
1112         else
1113                 ctx->selected_flavor = RPC_AUTH_UNIX;
1114
1115         /* Get a client record */
1116         error = nfs4_set_client(server,
1117                                 ctx->nfs_server.hostname,
1118                                 &ctx->nfs_server.address,
1119                                 ctx->nfs_server.addrlen,
1120                                 ctx->client_address,
1121                                 ctx->nfs_server.protocol,
1122                                 &timeparms,
1123                                 ctx->minorversion,
1124                                 ctx->nfs_server.nconnect,
1125                                 fc->net_ns);
1126         if (error < 0)
1127                 return error;
1128
1129         if (ctx->rsize)
1130                 server->rsize = nfs_block_size(ctx->rsize, NULL);
1131         if (ctx->wsize)
1132                 server->wsize = nfs_block_size(ctx->wsize, NULL);
1133
1134         server->acregmin = ctx->acregmin * HZ;
1135         server->acregmax = ctx->acregmax * HZ;
1136         server->acdirmin = ctx->acdirmin * HZ;
1137         server->acdirmax = ctx->acdirmax * HZ;
1138         server->port     = ctx->nfs_server.port;
1139
1140         return nfs_init_server_rpcclient(server, &timeparms,
1141                                          ctx->selected_flavor);
1142 }
1143
1144 /*
1145  * Create a version 4 volume record
1146  * - keyed on server and FSID
1147  */
1148 struct nfs_server *nfs4_create_server(struct fs_context *fc)
1149 {
1150         struct nfs_fs_context *ctx = nfs_fc2context(fc);
1151         struct nfs_server *server;
1152         bool auth_probe;
1153         int error;
1154
1155         server = nfs_alloc_server();
1156         if (!server)
1157                 return ERR_PTR(-ENOMEM);
1158
1159         server->cred = get_cred(current_cred());
1160
1161         auth_probe = ctx->auth_info.flavor_len < 1;
1162
1163         /* set up the general RPC client */
1164         error = nfs4_init_server(server, fc);
1165         if (error < 0)
1166                 goto error;
1167
1168         error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);
1169         if (error < 0)
1170                 goto error;
1171
1172         return server;
1173
1174 error:
1175         nfs_free_server(server);
1176         return ERR_PTR(error);
1177 }
1178
1179 /*
1180  * Create an NFS4 referral server record
1181  */
1182 struct nfs_server *nfs4_create_referral_server(struct fs_context *fc)
1183 {
1184         struct nfs_fs_context *ctx = nfs_fc2context(fc);
1185         struct nfs_client *parent_client;
1186         struct nfs_server *server, *parent_server;
1187         bool auth_probe;
1188         int error;
1189
1190         server = nfs_alloc_server();
1191         if (!server)
1192                 return ERR_PTR(-ENOMEM);
1193
1194         parent_server = NFS_SB(ctx->clone_data.sb);
1195         parent_client = parent_server->nfs_client;
1196
1197         server->cred = get_cred(parent_server->cred);
1198
1199         /* Initialise the client representation from the parent server */
1200         nfs_server_copy_userdata(server, parent_server);
1201
1202         /* Get a client representation */
1203 #if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA)
1204         rpc_set_port(&ctx->nfs_server.address, NFS_RDMA_PORT);
1205         error = nfs4_set_client(server,
1206                                 ctx->nfs_server.hostname,
1207                                 &ctx->nfs_server.address,
1208                                 ctx->nfs_server.addrlen,
1209                                 parent_client->cl_ipaddr,
1210                                 XPRT_TRANSPORT_RDMA,
1211                                 parent_server->client->cl_timeout,
1212                                 parent_client->cl_mvops->minor_version,
1213                                 parent_client->cl_nconnect,
1214                                 parent_client->cl_net);
1215         if (!error)
1216                 goto init_server;
1217 #endif  /* IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA) */
1218
1219         rpc_set_port(&ctx->nfs_server.address, NFS_PORT);
1220         error = nfs4_set_client(server,
1221                                 ctx->nfs_server.hostname,
1222                                 &ctx->nfs_server.address,
1223                                 ctx->nfs_server.addrlen,
1224                                 parent_client->cl_ipaddr,
1225                                 XPRT_TRANSPORT_TCP,
1226                                 parent_server->client->cl_timeout,
1227                                 parent_client->cl_mvops->minor_version,
1228                                 parent_client->cl_nconnect,
1229                                 parent_client->cl_net);
1230         if (error < 0)
1231                 goto error;
1232
1233 #if IS_ENABLED(CONFIG_SUNRPC_XPRT_RDMA)
1234 init_server:
1235 #endif
1236         error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout,
1237                                           ctx->selected_flavor);
1238         if (error < 0)
1239                 goto error;
1240
1241         auth_probe = parent_server->auth_info.flavor_len < 1;
1242
1243         error = nfs4_server_common_setup(server, ctx->mntfh, auth_probe);
1244         if (error < 0)
1245                 goto error;
1246
1247         return server;
1248
1249 error:
1250         nfs_free_server(server);
1251         return ERR_PTR(error);
1252 }
1253
1254 /*
1255  * Grab the destination's particulars, including lease expiry time.
1256  *
1257  * Returns zero if probe succeeded and retrieved FSID matches the FSID
1258  * we have cached.
1259  */
1260 static int nfs_probe_destination(struct nfs_server *server)
1261 {
1262         struct inode *inode = d_inode(server->super->s_root);
1263         struct nfs_fattr *fattr;
1264         int error;
1265
1266         fattr = nfs_alloc_fattr();
1267         if (fattr == NULL)
1268                 return -ENOMEM;
1269
1270         /* Sanity: the probe won't work if the destination server
1271          * does not recognize the migrated FH. */
1272         error = nfs_probe_fsinfo(server, NFS_FH(inode), fattr);
1273
1274         nfs_free_fattr(fattr);
1275         return error;
1276 }
1277
1278 /**
1279  * nfs4_update_server - Move an nfs_server to a different nfs_client
1280  *
1281  * @server: represents FSID to be moved
1282  * @hostname: new end-point's hostname
1283  * @sap: new end-point's socket address
1284  * @salen: size of "sap"
1285  * @net: net namespace
1286  *
1287  * The nfs_server must be quiescent before this function is invoked.
1288  * Either its session is drained (NFSv4.1+), or its transport is
1289  * plugged and drained (NFSv4.0).
1290  *
1291  * Returns zero on success, or a negative errno value.
1292  */
1293 int nfs4_update_server(struct nfs_server *server, const char *hostname,
1294                        struct sockaddr *sap, size_t salen, struct net *net)
1295 {
1296         struct nfs_client *clp = server->nfs_client;
1297         struct rpc_clnt *clnt = server->client;
1298         struct xprt_create xargs = {
1299                 .ident          = clp->cl_proto,
1300                 .net            = net,
1301                 .dstaddr        = sap,
1302                 .addrlen        = salen,
1303                 .servername     = hostname,
1304         };
1305         char buf[INET6_ADDRSTRLEN + 1];
1306         struct sockaddr_storage address;
1307         struct sockaddr *localaddr = (struct sockaddr *)&address;
1308         int error;
1309
1310         error = rpc_switch_client_transport(clnt, &xargs, clnt->cl_timeout);
1311         if (error != 0)
1312                 return error;
1313
1314         error = rpc_localaddr(clnt, localaddr, sizeof(address));
1315         if (error != 0)
1316                 return error;
1317
1318         if (rpc_ntop(localaddr, buf, sizeof(buf)) == 0)
1319                 return -EAFNOSUPPORT;
1320
1321         nfs_server_remove_lists(server);
1322         set_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);
1323         error = nfs4_set_client(server, hostname, sap, salen, buf,
1324                                 clp->cl_proto, clnt->cl_timeout,
1325                                 clp->cl_minorversion,
1326                                 clp->cl_nconnect, net);
1327         clear_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);
1328         if (error != 0) {
1329                 nfs_server_insert_lists(server);
1330                 return error;
1331         }
1332         nfs_put_client(clp);
1333
1334         if (server->nfs_client->cl_hostname == NULL) {
1335                 server->nfs_client->cl_hostname = kstrdup(hostname, GFP_KERNEL);
1336                 if (server->nfs_client->cl_hostname == NULL)
1337                         return -ENOMEM;
1338         }
1339         nfs_server_insert_lists(server);
1340
1341         return nfs_probe_destination(server);
1342 }