411f332de0b316b2ae33bda6e9385a498bd7fabd
[~shefty/rdma-dev.git] / net / sunrpc / rpcb_clnt.c
1 /*
2  * In-kernel rpcbind client supporting versions 2, 3, and 4 of the rpcbind
3  * protocol
4  *
5  * Based on RFC 1833: "Binding Protocols for ONC RPC Version 2" and
6  * RFC 3530: "Network File System (NFS) version 4 Protocol"
7  *
8  * Original: Gilles Quillard, Bull Open Source, 2005 <gilles.quillard@bull.net>
9  * Updated: Chuck Lever, Oracle Corporation, 2007 <chuck.lever@oracle.com>
10  *
11  * Descended from net/sunrpc/pmap_clnt.c,
12  *  Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
13  */
14
15 #include <linux/module.h>
16
17 #include <linux/types.h>
18 #include <linux/socket.h>
19 #include <linux/un.h>
20 #include <linux/in.h>
21 #include <linux/in6.h>
22 #include <linux/kernel.h>
23 #include <linux/errno.h>
24 #include <linux/mutex.h>
25 #include <linux/slab.h>
26 #include <linux/nsproxy.h>
27 #include <net/ipv6.h>
28
29 #include <linux/sunrpc/clnt.h>
30 #include <linux/sunrpc/sched.h>
31 #include <linux/sunrpc/xprtsock.h>
32
33 #include "netns.h"
34
35 #ifdef RPC_DEBUG
36 # define RPCDBG_FACILITY        RPCDBG_BIND
37 #endif
38
39 #define RPCBIND_SOCK_PATHNAME   "/var/run/rpcbind.sock"
40
41 #define RPCBIND_PROGRAM         (100000u)
42 #define RPCBIND_PORT            (111u)
43
44 #define RPCBVERS_2              (2u)
45 #define RPCBVERS_3              (3u)
46 #define RPCBVERS_4              (4u)
47
48 enum {
49         RPCBPROC_NULL,
50         RPCBPROC_SET,
51         RPCBPROC_UNSET,
52         RPCBPROC_GETPORT,
53         RPCBPROC_GETADDR = 3,           /* alias for GETPORT */
54         RPCBPROC_DUMP,
55         RPCBPROC_CALLIT,
56         RPCBPROC_BCAST = 5,             /* alias for CALLIT */
57         RPCBPROC_GETTIME,
58         RPCBPROC_UADDR2TADDR,
59         RPCBPROC_TADDR2UADDR,
60         RPCBPROC_GETVERSADDR,
61         RPCBPROC_INDIRECT,
62         RPCBPROC_GETADDRLIST,
63         RPCBPROC_GETSTAT,
64 };
65
66 /*
67  * r_owner
68  *
69  * The "owner" is allowed to unset a service in the rpcbind database.
70  *
71  * For AF_LOCAL SET/UNSET requests, rpcbind treats this string as a
72  * UID which it maps to a local user name via a password lookup.
73  * In all other cases it is ignored.
74  *
75  * For SET/UNSET requests, user space provides a value, even for
76  * network requests, and GETADDR uses an empty string.  We follow
77  * those precedents here.
78  */
79 #define RPCB_OWNER_STRING       "0"
80 #define RPCB_MAXOWNERLEN        sizeof(RPCB_OWNER_STRING)
81
82 /*
83  * XDR data type sizes
84  */
85 #define RPCB_program_sz         (1)
86 #define RPCB_version_sz         (1)
87 #define RPCB_protocol_sz        (1)
88 #define RPCB_port_sz            (1)
89 #define RPCB_boolean_sz         (1)
90
91 #define RPCB_netid_sz           (1 + XDR_QUADLEN(RPCBIND_MAXNETIDLEN))
92 #define RPCB_addr_sz            (1 + XDR_QUADLEN(RPCBIND_MAXUADDRLEN))
93 #define RPCB_ownerstring_sz     (1 + XDR_QUADLEN(RPCB_MAXOWNERLEN))
94
95 /*
96  * XDR argument and result sizes
97  */
98 #define RPCB_mappingargs_sz     (RPCB_program_sz + RPCB_version_sz + \
99                                 RPCB_protocol_sz + RPCB_port_sz)
100 #define RPCB_getaddrargs_sz     (RPCB_program_sz + RPCB_version_sz + \
101                                 RPCB_netid_sz + RPCB_addr_sz + \
102                                 RPCB_ownerstring_sz)
103
104 #define RPCB_getportres_sz      RPCB_port_sz
105 #define RPCB_setres_sz          RPCB_boolean_sz
106
107 /*
108  * Note that RFC 1833 does not put any size restrictions on the
109  * address string returned by the remote rpcbind database.
110  */
111 #define RPCB_getaddrres_sz      RPCB_addr_sz
112
113 static void                     rpcb_getport_done(struct rpc_task *, void *);
114 static void                     rpcb_map_release(void *data);
115 static const struct rpc_program rpcb_program;
116
117 struct rpcbind_args {
118         struct rpc_xprt *       r_xprt;
119
120         u32                     r_prog;
121         u32                     r_vers;
122         u32                     r_prot;
123         unsigned short          r_port;
124         const char *            r_netid;
125         const char *            r_addr;
126         const char *            r_owner;
127
128         int                     r_status;
129 };
130
131 static struct rpc_procinfo rpcb_procedures2[];
132 static struct rpc_procinfo rpcb_procedures3[];
133 static struct rpc_procinfo rpcb_procedures4[];
134
135 struct rpcb_info {
136         u32                     rpc_vers;
137         struct rpc_procinfo *   rpc_proc;
138 };
139
140 static const struct rpcb_info rpcb_next_version[];
141 static const struct rpcb_info rpcb_next_version6[];
142
143 static const struct rpc_call_ops rpcb_getport_ops = {
144         .rpc_call_done          = rpcb_getport_done,
145         .rpc_release            = rpcb_map_release,
146 };
147
148 static void rpcb_wake_rpcbind_waiters(struct rpc_xprt *xprt, int status)
149 {
150         xprt_clear_binding(xprt);
151         rpc_wake_up_status(&xprt->binding, status);
152 }
153
154 static void rpcb_map_release(void *data)
155 {
156         struct rpcbind_args *map = data;
157
158         rpcb_wake_rpcbind_waiters(map->r_xprt, map->r_status);
159         xprt_put(map->r_xprt);
160         kfree(map->r_addr);
161         kfree(map);
162 }
163
164 static int rpcb_get_local(struct net *net)
165 {
166         int cnt;
167         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
168
169         spin_lock(&sn->rpcb_clnt_lock);
170         if (sn->rpcb_users)
171                 sn->rpcb_users++;
172         cnt = sn->rpcb_users;
173         spin_unlock(&sn->rpcb_clnt_lock);
174
175         return cnt;
176 }
177
178 void rpcb_put_local(struct net *net)
179 {
180         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
181         struct rpc_clnt *clnt = sn->rpcb_local_clnt;
182         struct rpc_clnt *clnt4 = sn->rpcb_local_clnt4;
183         int shutdown = 0;
184
185         spin_lock(&sn->rpcb_clnt_lock);
186         if (sn->rpcb_users) {
187                 if (--sn->rpcb_users == 0) {
188                         sn->rpcb_local_clnt = NULL;
189                         sn->rpcb_local_clnt4 = NULL;
190                 }
191                 shutdown = !sn->rpcb_users;
192         }
193         spin_unlock(&sn->rpcb_clnt_lock);
194
195         if (shutdown) {
196                 /*
197                  * cleanup_rpcb_clnt - remove xprtsock's sysctls, unregister
198                  */
199                 if (clnt4)
200                         rpc_shutdown_client(clnt4);
201                 if (clnt)
202                         rpc_shutdown_client(clnt);
203         }
204 }
205
206 static void rpcb_set_local(struct net *net, struct rpc_clnt *clnt,
207                         struct rpc_clnt *clnt4)
208 {
209         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
210
211         /* Protected by rpcb_create_local_mutex */
212         sn->rpcb_local_clnt = clnt;
213         sn->rpcb_local_clnt4 = clnt4;
214         smp_wmb(); 
215         sn->rpcb_users = 1;
216         dprintk("RPC:       created new rpcb local clients (rpcb_local_clnt: "
217                         "%p, rpcb_local_clnt4: %p) for net %p%s\n",
218                         sn->rpcb_local_clnt, sn->rpcb_local_clnt4,
219                         net, (net == &init_net) ? " (init_net)" : "");
220 }
221
222 /*
223  * Returns zero on success, otherwise a negative errno value
224  * is returned.
225  */
226 static int rpcb_create_local_unix(struct net *net)
227 {
228         static const struct sockaddr_un rpcb_localaddr_rpcbind = {
229                 .sun_family             = AF_LOCAL,
230                 .sun_path               = RPCBIND_SOCK_PATHNAME,
231         };
232         struct rpc_create_args args = {
233                 .net            = net,
234                 .protocol       = XPRT_TRANSPORT_LOCAL,
235                 .address        = (struct sockaddr *)&rpcb_localaddr_rpcbind,
236                 .addrsize       = sizeof(rpcb_localaddr_rpcbind),
237                 .servername     = "localhost",
238                 .program        = &rpcb_program,
239                 .version        = RPCBVERS_2,
240                 .authflavor     = RPC_AUTH_NULL,
241         };
242         struct rpc_clnt *clnt, *clnt4;
243         int result = 0;
244
245         /*
246          * Because we requested an RPC PING at transport creation time,
247          * this works only if the user space portmapper is rpcbind, and
248          * it's listening on AF_LOCAL on the named socket.
249          */
250         clnt = rpc_create(&args);
251         if (IS_ERR(clnt)) {
252                 dprintk("RPC:       failed to create AF_LOCAL rpcbind "
253                                 "client (errno %ld).\n", PTR_ERR(clnt));
254                 result = PTR_ERR(clnt);
255                 goto out;
256         }
257
258         clnt4 = rpc_bind_new_program(clnt, &rpcb_program, RPCBVERS_4);
259         if (IS_ERR(clnt4)) {
260                 dprintk("RPC:       failed to bind second program to "
261                                 "rpcbind v4 client (errno %ld).\n",
262                                 PTR_ERR(clnt4));
263                 clnt4 = NULL;
264         }
265
266         rpcb_set_local(net, clnt, clnt4);
267
268 out:
269         return result;
270 }
271
272 /*
273  * Returns zero on success, otherwise a negative errno value
274  * is returned.
275  */
276 static int rpcb_create_local_net(struct net *net)
277 {
278         static const struct sockaddr_in rpcb_inaddr_loopback = {
279                 .sin_family             = AF_INET,
280                 .sin_addr.s_addr        = htonl(INADDR_LOOPBACK),
281                 .sin_port               = htons(RPCBIND_PORT),
282         };
283         struct rpc_create_args args = {
284                 .net            = net,
285                 .protocol       = XPRT_TRANSPORT_TCP,
286                 .address        = (struct sockaddr *)&rpcb_inaddr_loopback,
287                 .addrsize       = sizeof(rpcb_inaddr_loopback),
288                 .servername     = "localhost",
289                 .program        = &rpcb_program,
290                 .version        = RPCBVERS_2,
291                 .authflavor     = RPC_AUTH_UNIX,
292                 .flags          = RPC_CLNT_CREATE_NOPING,
293         };
294         struct rpc_clnt *clnt, *clnt4;
295         int result = 0;
296
297         clnt = rpc_create(&args);
298         if (IS_ERR(clnt)) {
299                 dprintk("RPC:       failed to create local rpcbind "
300                                 "client (errno %ld).\n", PTR_ERR(clnt));
301                 result = PTR_ERR(clnt);
302                 goto out;
303         }
304
305         /*
306          * This results in an RPC ping.  On systems running portmapper,
307          * the v4 ping will fail.  Proceed anyway, but disallow rpcb
308          * v4 upcalls.
309          */
310         clnt4 = rpc_bind_new_program(clnt, &rpcb_program, RPCBVERS_4);
311         if (IS_ERR(clnt4)) {
312                 dprintk("RPC:       failed to bind second program to "
313                                 "rpcbind v4 client (errno %ld).\n",
314                                 PTR_ERR(clnt4));
315                 clnt4 = NULL;
316         }
317
318         rpcb_set_local(net, clnt, clnt4);
319
320 out:
321         return result;
322 }
323
324 /*
325  * Returns zero on success, otherwise a negative errno value
326  * is returned.
327  */
328 int rpcb_create_local(struct net *net)
329 {
330         static DEFINE_MUTEX(rpcb_create_local_mutex);
331         int result = 0;
332
333         if (rpcb_get_local(net))
334                 return result;
335
336         mutex_lock(&rpcb_create_local_mutex);
337         if (rpcb_get_local(net))
338                 goto out;
339
340         if (rpcb_create_local_unix(net) != 0)
341                 result = rpcb_create_local_net(net);
342
343 out:
344         mutex_unlock(&rpcb_create_local_mutex);
345         return result;
346 }
347
348 static struct rpc_clnt *rpcb_create(struct net *net, const char *hostname,
349                                     struct sockaddr *srvaddr, size_t salen,
350                                     int proto, u32 version)
351 {
352         struct rpc_create_args args = {
353                 .net            = net,
354                 .protocol       = proto,
355                 .address        = srvaddr,
356                 .addrsize       = salen,
357                 .servername     = hostname,
358                 .program        = &rpcb_program,
359                 .version        = version,
360                 .authflavor     = RPC_AUTH_UNIX,
361                 .flags          = (RPC_CLNT_CREATE_NOPING |
362                                         RPC_CLNT_CREATE_NONPRIVPORT),
363         };
364
365         switch (srvaddr->sa_family) {
366         case AF_INET:
367                 ((struct sockaddr_in *)srvaddr)->sin_port = htons(RPCBIND_PORT);
368                 break;
369         case AF_INET6:
370                 ((struct sockaddr_in6 *)srvaddr)->sin6_port = htons(RPCBIND_PORT);
371                 break;
372         default:
373                 return ERR_PTR(-EAFNOSUPPORT);
374         }
375
376         return rpc_create(&args);
377 }
378
379 static int rpcb_register_call(struct rpc_clnt *clnt, struct rpc_message *msg)
380 {
381         int result, error = 0;
382
383         msg->rpc_resp = &result;
384
385         error = rpc_call_sync(clnt, msg, RPC_TASK_SOFTCONN);
386         if (error < 0) {
387                 dprintk("RPC:       failed to contact local rpcbind "
388                                 "server (errno %d).\n", -error);
389                 return error;
390         }
391
392         if (!result)
393                 return -EACCES;
394         return 0;
395 }
396
397 /**
398  * rpcb_register - set or unset a port registration with the local rpcbind svc
399  * @net: target network namespace
400  * @prog: RPC program number to bind
401  * @vers: RPC version number to bind
402  * @prot: transport protocol to register
403  * @port: port value to register
404  *
405  * Returns zero if the registration request was dispatched successfully
406  * and the rpcbind daemon returned success.  Otherwise, returns an errno
407  * value that reflects the nature of the error (request could not be
408  * dispatched, timed out, or rpcbind returned an error).
409  *
410  * RPC services invoke this function to advertise their contact
411  * information via the system's rpcbind daemon.  RPC services
412  * invoke this function once for each [program, version, transport]
413  * tuple they wish to advertise.
414  *
415  * Callers may also unregister RPC services that are no longer
416  * available by setting the passed-in port to zero.  This removes
417  * all registered transports for [program, version] from the local
418  * rpcbind database.
419  *
420  * This function uses rpcbind protocol version 2 to contact the
421  * local rpcbind daemon.
422  *
423  * Registration works over both AF_INET and AF_INET6, and services
424  * registered via this function are advertised as available for any
425  * address.  If the local rpcbind daemon is listening on AF_INET6,
426  * services registered via this function will be advertised on
427  * IN6ADDR_ANY (ie available for all AF_INET and AF_INET6
428  * addresses).
429  */
430 int rpcb_register(struct net *net, u32 prog, u32 vers, int prot, unsigned short port)
431 {
432         struct rpcbind_args map = {
433                 .r_prog         = prog,
434                 .r_vers         = vers,
435                 .r_prot         = prot,
436                 .r_port         = port,
437         };
438         struct rpc_message msg = {
439                 .rpc_argp       = &map,
440         };
441         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
442
443         dprintk("RPC:       %sregistering (%u, %u, %d, %u) with local "
444                         "rpcbind\n", (port ? "" : "un"),
445                         prog, vers, prot, port);
446
447         msg.rpc_proc = &rpcb_procedures2[RPCBPROC_UNSET];
448         if (port)
449                 msg.rpc_proc = &rpcb_procedures2[RPCBPROC_SET];
450
451         return rpcb_register_call(sn->rpcb_local_clnt, &msg);
452 }
453
454 /*
455  * Fill in AF_INET family-specific arguments to register
456  */
457 static int rpcb_register_inet4(struct sunrpc_net *sn,
458                                const struct sockaddr *sap,
459                                struct rpc_message *msg)
460 {
461         const struct sockaddr_in *sin = (const struct sockaddr_in *)sap;
462         struct rpcbind_args *map = msg->rpc_argp;
463         unsigned short port = ntohs(sin->sin_port);
464         int result;
465
466         map->r_addr = rpc_sockaddr2uaddr(sap, GFP_KERNEL);
467
468         dprintk("RPC:       %sregistering [%u, %u, %s, '%s'] with "
469                 "local rpcbind\n", (port ? "" : "un"),
470                         map->r_prog, map->r_vers,
471                         map->r_addr, map->r_netid);
472
473         msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
474         if (port)
475                 msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET];
476
477         result = rpcb_register_call(sn->rpcb_local_clnt4, msg);
478         kfree(map->r_addr);
479         return result;
480 }
481
482 /*
483  * Fill in AF_INET6 family-specific arguments to register
484  */
485 static int rpcb_register_inet6(struct sunrpc_net *sn,
486                                const struct sockaddr *sap,
487                                struct rpc_message *msg)
488 {
489         const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sap;
490         struct rpcbind_args *map = msg->rpc_argp;
491         unsigned short port = ntohs(sin6->sin6_port);
492         int result;
493
494         map->r_addr = rpc_sockaddr2uaddr(sap, GFP_KERNEL);
495
496         dprintk("RPC:       %sregistering [%u, %u, %s, '%s'] with "
497                 "local rpcbind\n", (port ? "" : "un"),
498                         map->r_prog, map->r_vers,
499                         map->r_addr, map->r_netid);
500
501         msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
502         if (port)
503                 msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET];
504
505         result = rpcb_register_call(sn->rpcb_local_clnt4, msg);
506         kfree(map->r_addr);
507         return result;
508 }
509
510 static int rpcb_unregister_all_protofamilies(struct sunrpc_net *sn,
511                                              struct rpc_message *msg)
512 {
513         struct rpcbind_args *map = msg->rpc_argp;
514
515         dprintk("RPC:       unregistering [%u, %u, '%s'] with "
516                 "local rpcbind\n",
517                         map->r_prog, map->r_vers, map->r_netid);
518
519         map->r_addr = "";
520         msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
521
522         return rpcb_register_call(sn->rpcb_local_clnt4, msg);
523 }
524
525 /**
526  * rpcb_v4_register - set or unset a port registration with the local rpcbind
527  * @net: target network namespace
528  * @program: RPC program number of service to (un)register
529  * @version: RPC version number of service to (un)register
530  * @address: address family, IP address, and port to (un)register
531  * @netid: netid of transport protocol to (un)register
532  *
533  * Returns zero if the registration request was dispatched successfully
534  * and the rpcbind daemon returned success.  Otherwise, returns an errno
535  * value that reflects the nature of the error (request could not be
536  * dispatched, timed out, or rpcbind returned an error).
537  *
538  * RPC services invoke this function to advertise their contact
539  * information via the system's rpcbind daemon.  RPC services
540  * invoke this function once for each [program, version, address,
541  * netid] tuple they wish to advertise.
542  *
543  * Callers may also unregister RPC services that are registered at a
544  * specific address by setting the port number in @address to zero.
545  * They may unregister all registered protocol families at once for
546  * a service by passing a NULL @address argument.  If @netid is ""
547  * then all netids for [program, version, address] are unregistered.
548  *
549  * This function uses rpcbind protocol version 4 to contact the
550  * local rpcbind daemon.  The local rpcbind daemon must support
551  * version 4 of the rpcbind protocol in order for these functions
552  * to register a service successfully.
553  *
554  * Supported netids include "udp" and "tcp" for UDP and TCP over
555  * IPv4, and "udp6" and "tcp6" for UDP and TCP over IPv6,
556  * respectively.
557  *
558  * The contents of @address determine the address family and the
559  * port to be registered.  The usual practice is to pass INADDR_ANY
560  * as the raw address, but specifying a non-zero address is also
561  * supported by this API if the caller wishes to advertise an RPC
562  * service on a specific network interface.
563  *
564  * Note that passing in INADDR_ANY does not create the same service
565  * registration as IN6ADDR_ANY.  The former advertises an RPC
566  * service on any IPv4 address, but not on IPv6.  The latter
567  * advertises the service on all IPv4 and IPv6 addresses.
568  */
569 int rpcb_v4_register(struct net *net, const u32 program, const u32 version,
570                      const struct sockaddr *address, const char *netid)
571 {
572         struct rpcbind_args map = {
573                 .r_prog         = program,
574                 .r_vers         = version,
575                 .r_netid        = netid,
576                 .r_owner        = RPCB_OWNER_STRING,
577         };
578         struct rpc_message msg = {
579                 .rpc_argp       = &map,
580         };
581         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
582
583         if (sn->rpcb_local_clnt4 == NULL)
584                 return -EPROTONOSUPPORT;
585
586         if (address == NULL)
587                 return rpcb_unregister_all_protofamilies(sn, &msg);
588
589         switch (address->sa_family) {
590         case AF_INET:
591                 return rpcb_register_inet4(sn, address, &msg);
592         case AF_INET6:
593                 return rpcb_register_inet6(sn, address, &msg);
594         }
595
596         return -EAFNOSUPPORT;
597 }
598
599 static struct rpc_task *rpcb_call_async(struct rpc_clnt *rpcb_clnt, struct rpcbind_args *map, struct rpc_procinfo *proc)
600 {
601         struct rpc_message msg = {
602                 .rpc_proc = proc,
603                 .rpc_argp = map,
604                 .rpc_resp = map,
605         };
606         struct rpc_task_setup task_setup_data = {
607                 .rpc_client = rpcb_clnt,
608                 .rpc_message = &msg,
609                 .callback_ops = &rpcb_getport_ops,
610                 .callback_data = map,
611                 .flags = RPC_TASK_ASYNC | RPC_TASK_SOFTCONN,
612         };
613
614         return rpc_run_task(&task_setup_data);
615 }
616
617 /*
618  * In the case where rpc clients have been cloned, we want to make
619  * sure that we use the program number/version etc of the actual
620  * owner of the xprt. To do so, we walk back up the tree of parents
621  * to find whoever created the transport and/or whoever has the
622  * autobind flag set.
623  */
624 static struct rpc_clnt *rpcb_find_transport_owner(struct rpc_clnt *clnt)
625 {
626         struct rpc_clnt *parent = clnt->cl_parent;
627         struct rpc_xprt *xprt = rcu_dereference(clnt->cl_xprt);
628
629         while (parent != clnt) {
630                 if (rcu_dereference(parent->cl_xprt) != xprt)
631                         break;
632                 if (clnt->cl_autobind)
633                         break;
634                 clnt = parent;
635                 parent = parent->cl_parent;
636         }
637         return clnt;
638 }
639
640 /**
641  * rpcb_getport_async - obtain the port for a given RPC service on a given host
642  * @task: task that is waiting for portmapper request
643  *
644  * This one can be called for an ongoing RPC request, and can be used in
645  * an async (rpciod) context.
646  */
647 void rpcb_getport_async(struct rpc_task *task)
648 {
649         struct rpc_clnt *clnt;
650         struct rpc_procinfo *proc;
651         u32 bind_version;
652         struct rpc_xprt *xprt;
653         struct rpc_clnt *rpcb_clnt;
654         struct rpcbind_args *map;
655         struct rpc_task *child;
656         struct sockaddr_storage addr;
657         struct sockaddr *sap = (struct sockaddr *)&addr;
658         size_t salen;
659         int status;
660
661         rcu_read_lock();
662         do {
663                 clnt = rpcb_find_transport_owner(task->tk_client);
664                 xprt = xprt_get(rcu_dereference(clnt->cl_xprt));
665         } while (xprt == NULL);
666         rcu_read_unlock();
667
668         dprintk("RPC: %5u %s(%s, %u, %u, %d)\n",
669                 task->tk_pid, __func__,
670                 xprt->servername, clnt->cl_prog, clnt->cl_vers, xprt->prot);
671
672         /* Put self on the wait queue to ensure we get notified if
673          * some other task is already attempting to bind the port */
674         rpc_sleep_on(&xprt->binding, task, NULL);
675
676         if (xprt_test_and_set_binding(xprt)) {
677                 dprintk("RPC: %5u %s: waiting for another binder\n",
678                         task->tk_pid, __func__);
679                 xprt_put(xprt);
680                 return;
681         }
682
683         /* Someone else may have bound if we slept */
684         if (xprt_bound(xprt)) {
685                 status = 0;
686                 dprintk("RPC: %5u %s: already bound\n",
687                         task->tk_pid, __func__);
688                 goto bailout_nofree;
689         }
690
691         /* Parent transport's destination address */
692         salen = rpc_peeraddr(clnt, sap, sizeof(addr));
693
694         /* Don't ever use rpcbind v2 for AF_INET6 requests */
695         switch (sap->sa_family) {
696         case AF_INET:
697                 proc = rpcb_next_version[xprt->bind_index].rpc_proc;
698                 bind_version = rpcb_next_version[xprt->bind_index].rpc_vers;
699                 break;
700         case AF_INET6:
701                 proc = rpcb_next_version6[xprt->bind_index].rpc_proc;
702                 bind_version = rpcb_next_version6[xprt->bind_index].rpc_vers;
703                 break;
704         default:
705                 status = -EAFNOSUPPORT;
706                 dprintk("RPC: %5u %s: bad address family\n",
707                                 task->tk_pid, __func__);
708                 goto bailout_nofree;
709         }
710         if (proc == NULL) {
711                 xprt->bind_index = 0;
712                 status = -EPFNOSUPPORT;
713                 dprintk("RPC: %5u %s: no more getport versions available\n",
714                         task->tk_pid, __func__);
715                 goto bailout_nofree;
716         }
717
718         dprintk("RPC: %5u %s: trying rpcbind version %u\n",
719                 task->tk_pid, __func__, bind_version);
720
721         rpcb_clnt = rpcb_create(xprt->xprt_net, xprt->servername, sap, salen,
722                                 xprt->prot, bind_version);
723         if (IS_ERR(rpcb_clnt)) {
724                 status = PTR_ERR(rpcb_clnt);
725                 dprintk("RPC: %5u %s: rpcb_create failed, error %ld\n",
726                         task->tk_pid, __func__, PTR_ERR(rpcb_clnt));
727                 goto bailout_nofree;
728         }
729
730         map = kzalloc(sizeof(struct rpcbind_args), GFP_ATOMIC);
731         if (!map) {
732                 status = -ENOMEM;
733                 dprintk("RPC: %5u %s: no memory available\n",
734                         task->tk_pid, __func__);
735                 goto bailout_release_client;
736         }
737         map->r_prog = clnt->cl_prog;
738         map->r_vers = clnt->cl_vers;
739         map->r_prot = xprt->prot;
740         map->r_port = 0;
741         map->r_xprt = xprt;
742         map->r_status = -EIO;
743
744         switch (bind_version) {
745         case RPCBVERS_4:
746         case RPCBVERS_3:
747                 map->r_netid = xprt->address_strings[RPC_DISPLAY_NETID];
748                 map->r_addr = rpc_sockaddr2uaddr(sap, GFP_ATOMIC);
749                 map->r_owner = "";
750                 break;
751         case RPCBVERS_2:
752                 map->r_addr = NULL;
753                 break;
754         default:
755                 BUG();
756         }
757
758         child = rpcb_call_async(rpcb_clnt, map, proc);
759         rpc_release_client(rpcb_clnt);
760         if (IS_ERR(child)) {
761                 /* rpcb_map_release() has freed the arguments */
762                 dprintk("RPC: %5u %s: rpc_run_task failed\n",
763                         task->tk_pid, __func__);
764                 return;
765         }
766
767         xprt->stat.bind_count++;
768         rpc_put_task(child);
769         return;
770
771 bailout_release_client:
772         rpc_release_client(rpcb_clnt);
773 bailout_nofree:
774         rpcb_wake_rpcbind_waiters(xprt, status);
775         task->tk_status = status;
776         xprt_put(xprt);
777 }
778 EXPORT_SYMBOL_GPL(rpcb_getport_async);
779
780 /*
781  * Rpcbind child task calls this callback via tk_exit.
782  */
783 static void rpcb_getport_done(struct rpc_task *child, void *data)
784 {
785         struct rpcbind_args *map = data;
786         struct rpc_xprt *xprt = map->r_xprt;
787         int status = child->tk_status;
788
789         /* Garbage reply: retry with a lesser rpcbind version */
790         if (status == -EIO)
791                 status = -EPROTONOSUPPORT;
792
793         /* rpcbind server doesn't support this rpcbind protocol version */
794         if (status == -EPROTONOSUPPORT)
795                 xprt->bind_index++;
796
797         if (status < 0) {
798                 /* rpcbind server not available on remote host? */
799                 xprt->ops->set_port(xprt, 0);
800         } else if (map->r_port == 0) {
801                 /* Requested RPC service wasn't registered on remote host */
802                 xprt->ops->set_port(xprt, 0);
803                 status = -EACCES;
804         } else {
805                 /* Succeeded */
806                 xprt->ops->set_port(xprt, map->r_port);
807                 xprt_set_bound(xprt);
808                 status = 0;
809         }
810
811         dprintk("RPC: %5u rpcb_getport_done(status %d, port %u)\n",
812                         child->tk_pid, status, map->r_port);
813
814         map->r_status = status;
815 }
816
817 /*
818  * XDR functions for rpcbind
819  */
820
821 static void rpcb_enc_mapping(struct rpc_rqst *req, struct xdr_stream *xdr,
822                              const struct rpcbind_args *rpcb)
823 {
824         __be32 *p;
825
826         dprintk("RPC: %5u encoding PMAP_%s call (%u, %u, %d, %u)\n",
827                         req->rq_task->tk_pid,
828                         req->rq_task->tk_msg.rpc_proc->p_name,
829                         rpcb->r_prog, rpcb->r_vers, rpcb->r_prot, rpcb->r_port);
830
831         p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2);
832         *p++ = cpu_to_be32(rpcb->r_prog);
833         *p++ = cpu_to_be32(rpcb->r_vers);
834         *p++ = cpu_to_be32(rpcb->r_prot);
835         *p   = cpu_to_be32(rpcb->r_port);
836 }
837
838 static int rpcb_dec_getport(struct rpc_rqst *req, struct xdr_stream *xdr,
839                             struct rpcbind_args *rpcb)
840 {
841         unsigned long port;
842         __be32 *p;
843
844         rpcb->r_port = 0;
845
846         p = xdr_inline_decode(xdr, 4);
847         if (unlikely(p == NULL))
848                 return -EIO;
849
850         port = be32_to_cpup(p);
851         dprintk("RPC: %5u PMAP_%s result: %lu\n", req->rq_task->tk_pid,
852                         req->rq_task->tk_msg.rpc_proc->p_name, port);
853         if (unlikely(port > USHRT_MAX))
854                 return -EIO;
855
856         rpcb->r_port = port;
857         return 0;
858 }
859
860 static int rpcb_dec_set(struct rpc_rqst *req, struct xdr_stream *xdr,
861                         unsigned int *boolp)
862 {
863         __be32 *p;
864
865         p = xdr_inline_decode(xdr, 4);
866         if (unlikely(p == NULL))
867                 return -EIO;
868
869         *boolp = 0;
870         if (*p != xdr_zero)
871                 *boolp = 1;
872
873         dprintk("RPC: %5u RPCB_%s call %s\n",
874                         req->rq_task->tk_pid,
875                         req->rq_task->tk_msg.rpc_proc->p_name,
876                         (*boolp ? "succeeded" : "failed"));
877         return 0;
878 }
879
880 static void encode_rpcb_string(struct xdr_stream *xdr, const char *string,
881                                const u32 maxstrlen)
882 {
883         __be32 *p;
884         u32 len;
885
886         len = strlen(string);
887         WARN_ON_ONCE(len > maxstrlen);
888         if (len > maxstrlen)
889                 /* truncate and hope for the best */
890                 len = maxstrlen;
891         p = xdr_reserve_space(xdr, 4 + len);
892         xdr_encode_opaque(p, string, len);
893 }
894
895 static void rpcb_enc_getaddr(struct rpc_rqst *req, struct xdr_stream *xdr,
896                              const struct rpcbind_args *rpcb)
897 {
898         __be32 *p;
899
900         dprintk("RPC: %5u encoding RPCB_%s call (%u, %u, '%s', '%s')\n",
901                         req->rq_task->tk_pid,
902                         req->rq_task->tk_msg.rpc_proc->p_name,
903                         rpcb->r_prog, rpcb->r_vers,
904                         rpcb->r_netid, rpcb->r_addr);
905
906         p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2);
907         *p++ = cpu_to_be32(rpcb->r_prog);
908         *p = cpu_to_be32(rpcb->r_vers);
909
910         encode_rpcb_string(xdr, rpcb->r_netid, RPCBIND_MAXNETIDLEN);
911         encode_rpcb_string(xdr, rpcb->r_addr, RPCBIND_MAXUADDRLEN);
912         encode_rpcb_string(xdr, rpcb->r_owner, RPCB_MAXOWNERLEN);
913 }
914
915 static int rpcb_dec_getaddr(struct rpc_rqst *req, struct xdr_stream *xdr,
916                             struct rpcbind_args *rpcb)
917 {
918         struct sockaddr_storage address;
919         struct sockaddr *sap = (struct sockaddr *)&address;
920         __be32 *p;
921         u32 len;
922
923         rpcb->r_port = 0;
924
925         p = xdr_inline_decode(xdr, 4);
926         if (unlikely(p == NULL))
927                 goto out_fail;
928         len = be32_to_cpup(p);
929
930         /*
931          * If the returned universal address is a null string,
932          * the requested RPC service was not registered.
933          */
934         if (len == 0) {
935                 dprintk("RPC: %5u RPCB reply: program not registered\n",
936                                 req->rq_task->tk_pid);
937                 return 0;
938         }
939
940         if (unlikely(len > RPCBIND_MAXUADDRLEN))
941                 goto out_fail;
942
943         p = xdr_inline_decode(xdr, len);
944         if (unlikely(p == NULL))
945                 goto out_fail;
946         dprintk("RPC: %5u RPCB_%s reply: %s\n", req->rq_task->tk_pid,
947                         req->rq_task->tk_msg.rpc_proc->p_name, (char *)p);
948
949         if (rpc_uaddr2sockaddr(req->rq_xprt->xprt_net, (char *)p, len,
950                                 sap, sizeof(address)) == 0)
951                 goto out_fail;
952         rpcb->r_port = rpc_get_port(sap);
953
954         return 0;
955
956 out_fail:
957         dprintk("RPC: %5u malformed RPCB_%s reply\n",
958                         req->rq_task->tk_pid,
959                         req->rq_task->tk_msg.rpc_proc->p_name);
960         return -EIO;
961 }
962
963 /*
964  * Not all rpcbind procedures described in RFC 1833 are implemented
965  * since the Linux kernel RPC code requires only these.
966  */
967
968 static struct rpc_procinfo rpcb_procedures2[] = {
969         [RPCBPROC_SET] = {
970                 .p_proc         = RPCBPROC_SET,
971                 .p_encode       = (kxdreproc_t)rpcb_enc_mapping,
972                 .p_decode       = (kxdrdproc_t)rpcb_dec_set,
973                 .p_arglen       = RPCB_mappingargs_sz,
974                 .p_replen       = RPCB_setres_sz,
975                 .p_statidx      = RPCBPROC_SET,
976                 .p_timer        = 0,
977                 .p_name         = "SET",
978         },
979         [RPCBPROC_UNSET] = {
980                 .p_proc         = RPCBPROC_UNSET,
981                 .p_encode       = (kxdreproc_t)rpcb_enc_mapping,
982                 .p_decode       = (kxdrdproc_t)rpcb_dec_set,
983                 .p_arglen       = RPCB_mappingargs_sz,
984                 .p_replen       = RPCB_setres_sz,
985                 .p_statidx      = RPCBPROC_UNSET,
986                 .p_timer        = 0,
987                 .p_name         = "UNSET",
988         },
989         [RPCBPROC_GETPORT] = {
990                 .p_proc         = RPCBPROC_GETPORT,
991                 .p_encode       = (kxdreproc_t)rpcb_enc_mapping,
992                 .p_decode       = (kxdrdproc_t)rpcb_dec_getport,
993                 .p_arglen       = RPCB_mappingargs_sz,
994                 .p_replen       = RPCB_getportres_sz,
995                 .p_statidx      = RPCBPROC_GETPORT,
996                 .p_timer        = 0,
997                 .p_name         = "GETPORT",
998         },
999 };
1000
1001 static struct rpc_procinfo rpcb_procedures3[] = {
1002         [RPCBPROC_SET] = {
1003                 .p_proc         = RPCBPROC_SET,
1004                 .p_encode       = (kxdreproc_t)rpcb_enc_getaddr,
1005                 .p_decode       = (kxdrdproc_t)rpcb_dec_set,
1006                 .p_arglen       = RPCB_getaddrargs_sz,
1007                 .p_replen       = RPCB_setres_sz,
1008                 .p_statidx      = RPCBPROC_SET,
1009                 .p_timer        = 0,
1010                 .p_name         = "SET",
1011         },
1012         [RPCBPROC_UNSET] = {
1013                 .p_proc         = RPCBPROC_UNSET,
1014                 .p_encode       = (kxdreproc_t)rpcb_enc_getaddr,
1015                 .p_decode       = (kxdrdproc_t)rpcb_dec_set,
1016                 .p_arglen       = RPCB_getaddrargs_sz,
1017                 .p_replen       = RPCB_setres_sz,
1018                 .p_statidx      = RPCBPROC_UNSET,
1019                 .p_timer        = 0,
1020                 .p_name         = "UNSET",
1021         },
1022         [RPCBPROC_GETADDR] = {
1023                 .p_proc         = RPCBPROC_GETADDR,
1024                 .p_encode       = (kxdreproc_t)rpcb_enc_getaddr,
1025                 .p_decode       = (kxdrdproc_t)rpcb_dec_getaddr,
1026                 .p_arglen       = RPCB_getaddrargs_sz,
1027                 .p_replen       = RPCB_getaddrres_sz,
1028                 .p_statidx      = RPCBPROC_GETADDR,
1029                 .p_timer        = 0,
1030                 .p_name         = "GETADDR",
1031         },
1032 };
1033
1034 static struct rpc_procinfo rpcb_procedures4[] = {
1035         [RPCBPROC_SET] = {
1036                 .p_proc         = RPCBPROC_SET,
1037                 .p_encode       = (kxdreproc_t)rpcb_enc_getaddr,
1038                 .p_decode       = (kxdrdproc_t)rpcb_dec_set,
1039                 .p_arglen       = RPCB_getaddrargs_sz,
1040                 .p_replen       = RPCB_setres_sz,
1041                 .p_statidx      = RPCBPROC_SET,
1042                 .p_timer        = 0,
1043                 .p_name         = "SET",
1044         },
1045         [RPCBPROC_UNSET] = {
1046                 .p_proc         = RPCBPROC_UNSET,
1047                 .p_encode       = (kxdreproc_t)rpcb_enc_getaddr,
1048                 .p_decode       = (kxdrdproc_t)rpcb_dec_set,
1049                 .p_arglen       = RPCB_getaddrargs_sz,
1050                 .p_replen       = RPCB_setres_sz,
1051                 .p_statidx      = RPCBPROC_UNSET,
1052                 .p_timer        = 0,
1053                 .p_name         = "UNSET",
1054         },
1055         [RPCBPROC_GETADDR] = {
1056                 .p_proc         = RPCBPROC_GETADDR,
1057                 .p_encode       = (kxdreproc_t)rpcb_enc_getaddr,
1058                 .p_decode       = (kxdrdproc_t)rpcb_dec_getaddr,
1059                 .p_arglen       = RPCB_getaddrargs_sz,
1060                 .p_replen       = RPCB_getaddrres_sz,
1061                 .p_statidx      = RPCBPROC_GETADDR,
1062                 .p_timer        = 0,
1063                 .p_name         = "GETADDR",
1064         },
1065 };
1066
1067 static const struct rpcb_info rpcb_next_version[] = {
1068         {
1069                 .rpc_vers       = RPCBVERS_2,
1070                 .rpc_proc       = &rpcb_procedures2[RPCBPROC_GETPORT],
1071         },
1072         {
1073                 .rpc_proc       = NULL,
1074         },
1075 };
1076
1077 static const struct rpcb_info rpcb_next_version6[] = {
1078         {
1079                 .rpc_vers       = RPCBVERS_4,
1080                 .rpc_proc       = &rpcb_procedures4[RPCBPROC_GETADDR],
1081         },
1082         {
1083                 .rpc_vers       = RPCBVERS_3,
1084                 .rpc_proc       = &rpcb_procedures3[RPCBPROC_GETADDR],
1085         },
1086         {
1087                 .rpc_proc       = NULL,
1088         },
1089 };
1090
1091 static const struct rpc_version rpcb_version2 = {
1092         .number         = RPCBVERS_2,
1093         .nrprocs        = ARRAY_SIZE(rpcb_procedures2),
1094         .procs          = rpcb_procedures2
1095 };
1096
1097 static const struct rpc_version rpcb_version3 = {
1098         .number         = RPCBVERS_3,
1099         .nrprocs        = ARRAY_SIZE(rpcb_procedures3),
1100         .procs          = rpcb_procedures3
1101 };
1102
1103 static const struct rpc_version rpcb_version4 = {
1104         .number         = RPCBVERS_4,
1105         .nrprocs        = ARRAY_SIZE(rpcb_procedures4),
1106         .procs          = rpcb_procedures4
1107 };
1108
1109 static const struct rpc_version *rpcb_version[] = {
1110         NULL,
1111         NULL,
1112         &rpcb_version2,
1113         &rpcb_version3,
1114         &rpcb_version4
1115 };
1116
1117 static struct rpc_stat rpcb_stats;
1118
1119 static const struct rpc_program rpcb_program = {
1120         .name           = "rpcbind",
1121         .number         = RPCBIND_PROGRAM,
1122         .nrvers         = ARRAY_SIZE(rpcb_version),
1123         .version        = rpcb_version,
1124         .stats          = &rpcb_stats,
1125 };