2 * linux/net/sunrpc/svc.c
4 * High-level RPC service routines
6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
8 * Multiple threads pools and NUMAisation
9 * Copyright (c) 2006 Silicon Graphics, Inc.
10 * by Greg Banks <gnb@melbourne.sgi.com>
13 #include <linux/linkage.h>
14 #include <linux/sched.h>
15 #include <linux/errno.h>
16 #include <linux/net.h>
19 #include <linux/interrupt.h>
20 #include <linux/module.h>
21 #include <linux/kthread.h>
22 #include <linux/slab.h>
24 #include <linux/sunrpc/types.h>
25 #include <linux/sunrpc/xdr.h>
26 #include <linux/sunrpc/stats.h>
27 #include <linux/sunrpc/svcsock.h>
28 #include <linux/sunrpc/clnt.h>
29 #include <linux/sunrpc/bc_xprt.h>
31 #define RPCDBG_FACILITY RPCDBG_SVCDSP
33 static void svc_unregister(const struct svc_serv
*serv
);
35 #define svc_serv_is_pooled(serv) ((serv)->sv_function)
38 * Mode for mapping cpus to pools.
41 SVC_POOL_AUTO
= -1, /* choose one of the others */
42 SVC_POOL_GLOBAL
, /* no mapping, just a single global pool
43 * (legacy & UP mode) */
44 SVC_POOL_PERCPU
, /* one pool per cpu */
45 SVC_POOL_PERNODE
/* one pool per numa node */
47 #define SVC_POOL_DEFAULT SVC_POOL_GLOBAL
50 * Structure for mapping cpus to pools and vice versa.
51 * Setup once during sunrpc initialisation.
53 static struct svc_pool_map
{
54 int count
; /* How many svc_servs use us */
55 int mode
; /* Note: int not enum to avoid
56 * warnings about "enumeration value
57 * not handled in switch" */
59 unsigned int *pool_to
; /* maps pool id to cpu or node */
60 unsigned int *to_pool
; /* maps cpu or node to pool id */
63 .mode
= SVC_POOL_DEFAULT
65 static DEFINE_MUTEX(svc_pool_map_mutex
);/* protects svc_pool_map.count only */
68 param_set_pool_mode(const char *val
, struct kernel_param
*kp
)
70 int *ip
= (int *)kp
->arg
;
71 struct svc_pool_map
*m
= &svc_pool_map
;
74 mutex_lock(&svc_pool_map_mutex
);
81 if (!strncmp(val
, "auto", 4))
83 else if (!strncmp(val
, "global", 6))
84 *ip
= SVC_POOL_GLOBAL
;
85 else if (!strncmp(val
, "percpu", 6))
86 *ip
= SVC_POOL_PERCPU
;
87 else if (!strncmp(val
, "pernode", 7))
88 *ip
= SVC_POOL_PERNODE
;
93 mutex_unlock(&svc_pool_map_mutex
);
98 param_get_pool_mode(char *buf
, struct kernel_param
*kp
)
100 int *ip
= (int *)kp
->arg
;
105 return strlcpy(buf
, "auto", 20);
106 case SVC_POOL_GLOBAL
:
107 return strlcpy(buf
, "global", 20);
108 case SVC_POOL_PERCPU
:
109 return strlcpy(buf
, "percpu", 20);
110 case SVC_POOL_PERNODE
:
111 return strlcpy(buf
, "pernode", 20);
113 return sprintf(buf
, "%d", *ip
);
117 module_param_call(pool_mode
, param_set_pool_mode
, param_get_pool_mode
,
118 &svc_pool_map
.mode
, 0644);
121 * Detect best pool mapping mode heuristically,
122 * according to the machine's topology.
125 svc_pool_map_choose_mode(void)
129 if (nr_online_nodes
> 1) {
131 * Actually have multiple NUMA nodes,
132 * so split pools on NUMA node boundaries
134 return SVC_POOL_PERNODE
;
137 node
= first_online_node
;
138 if (nr_cpus_node(node
) > 2) {
140 * Non-trivial SMP, or CONFIG_NUMA on
141 * non-NUMA hardware, e.g. with a generic
142 * x86_64 kernel on Xeons. In this case we
143 * want to divide the pools on cpu boundaries.
145 return SVC_POOL_PERCPU
;
148 /* default: one global pool */
149 return SVC_POOL_GLOBAL
;
153 * Allocate the to_pool[] and pool_to[] arrays.
154 * Returns 0 on success or an errno.
157 svc_pool_map_alloc_arrays(struct svc_pool_map
*m
, unsigned int maxpools
)
159 m
->to_pool
= kcalloc(maxpools
, sizeof(unsigned int), GFP_KERNEL
);
162 m
->pool_to
= kcalloc(maxpools
, sizeof(unsigned int), GFP_KERNEL
);
176 * Initialise the pool map for SVC_POOL_PERCPU mode.
177 * Returns number of pools or <0 on error.
180 svc_pool_map_init_percpu(struct svc_pool_map
*m
)
182 unsigned int maxpools
= nr_cpu_ids
;
183 unsigned int pidx
= 0;
187 err
= svc_pool_map_alloc_arrays(m
, maxpools
);
191 for_each_online_cpu(cpu
) {
192 BUG_ON(pidx
> maxpools
);
193 m
->to_pool
[cpu
] = pidx
;
194 m
->pool_to
[pidx
] = cpu
;
197 /* cpus brought online later all get mapped to pool0, sorry */
204 * Initialise the pool map for SVC_POOL_PERNODE mode.
205 * Returns number of pools or <0 on error.
208 svc_pool_map_init_pernode(struct svc_pool_map
*m
)
210 unsigned int maxpools
= nr_node_ids
;
211 unsigned int pidx
= 0;
215 err
= svc_pool_map_alloc_arrays(m
, maxpools
);
219 for_each_node_with_cpus(node
) {
220 /* some architectures (e.g. SN2) have cpuless nodes */
221 BUG_ON(pidx
> maxpools
);
222 m
->to_pool
[node
] = pidx
;
223 m
->pool_to
[pidx
] = node
;
226 /* nodes brought online later all get mapped to pool0, sorry */
233 * Add a reference to the global map of cpus to pools (and
234 * vice versa). Initialise the map if we're the first user.
235 * Returns the number of pools.
238 svc_pool_map_get(void)
240 struct svc_pool_map
*m
= &svc_pool_map
;
243 mutex_lock(&svc_pool_map_mutex
);
246 mutex_unlock(&svc_pool_map_mutex
);
250 if (m
->mode
== SVC_POOL_AUTO
)
251 m
->mode
= svc_pool_map_choose_mode();
254 case SVC_POOL_PERCPU
:
255 npools
= svc_pool_map_init_percpu(m
);
257 case SVC_POOL_PERNODE
:
258 npools
= svc_pool_map_init_pernode(m
);
263 /* default, or memory allocation failure */
265 m
->mode
= SVC_POOL_GLOBAL
;
269 mutex_unlock(&svc_pool_map_mutex
);
275 * Drop a reference to the global map of cpus to pools.
276 * When the last reference is dropped, the map data is
277 * freed; this allows the sysadmin to change the pool
278 * mode using the pool_mode module option without
279 * rebooting or re-loading sunrpc.ko.
282 svc_pool_map_put(void)
284 struct svc_pool_map
*m
= &svc_pool_map
;
286 mutex_lock(&svc_pool_map_mutex
);
289 m
->mode
= SVC_POOL_DEFAULT
;
297 mutex_unlock(&svc_pool_map_mutex
);
302 * Set the given thread's cpus_allowed mask so that it
303 * will only run on cpus in the given pool.
306 svc_pool_map_set_cpumask(struct task_struct
*task
, unsigned int pidx
)
308 struct svc_pool_map
*m
= &svc_pool_map
;
309 unsigned int node
= m
->pool_to
[pidx
];
312 * The caller checks for sv_nrpools > 1, which
313 * implies that we've been initialized.
315 BUG_ON(m
->count
== 0);
318 case SVC_POOL_PERCPU
:
320 set_cpus_allowed_ptr(task
, cpumask_of(node
));
323 case SVC_POOL_PERNODE
:
325 set_cpus_allowed_ptr(task
, cpumask_of_node(node
));
332 * Use the mapping mode to choose a pool for a given CPU.
333 * Used when enqueueing an incoming RPC. Always returns
334 * a non-NULL pool pointer.
337 svc_pool_for_cpu(struct svc_serv
*serv
, int cpu
)
339 struct svc_pool_map
*m
= &svc_pool_map
;
340 unsigned int pidx
= 0;
343 * An uninitialised map happens in a pure client when
344 * lockd is brought up, so silently treat it the
345 * same as SVC_POOL_GLOBAL.
347 if (svc_serv_is_pooled(serv
)) {
349 case SVC_POOL_PERCPU
:
350 pidx
= m
->to_pool
[cpu
];
352 case SVC_POOL_PERNODE
:
353 pidx
= m
->to_pool
[cpu_to_node(cpu
)];
357 return &serv
->sv_pools
[pidx
% serv
->sv_nrpools
];
362 * Create an RPC service
364 static struct svc_serv
*
365 __svc_create(struct svc_program
*prog
, unsigned int bufsize
, int npools
,
366 void (*shutdown
)(struct svc_serv
*serv
))
368 struct svc_serv
*serv
;
370 unsigned int xdrsize
;
373 if (!(serv
= kzalloc(sizeof(*serv
), GFP_KERNEL
)))
375 serv
->sv_name
= prog
->pg_name
;
376 serv
->sv_program
= prog
;
377 serv
->sv_nrthreads
= 1;
378 serv
->sv_stats
= prog
->pg_stats
;
379 if (bufsize
> RPCSVC_MAXPAYLOAD
)
380 bufsize
= RPCSVC_MAXPAYLOAD
;
381 serv
->sv_max_payload
= bufsize
? bufsize
: 4096;
382 serv
->sv_max_mesg
= roundup(serv
->sv_max_payload
+ PAGE_SIZE
, PAGE_SIZE
);
383 serv
->sv_shutdown
= shutdown
;
386 prog
->pg_lovers
= prog
->pg_nvers
-1;
387 for (vers
=0; vers
<prog
->pg_nvers
; vers
++)
388 if (prog
->pg_vers
[vers
]) {
389 prog
->pg_hivers
= vers
;
390 if (prog
->pg_lovers
> vers
)
391 prog
->pg_lovers
= vers
;
392 if (prog
->pg_vers
[vers
]->vs_xdrsize
> xdrsize
)
393 xdrsize
= prog
->pg_vers
[vers
]->vs_xdrsize
;
395 prog
= prog
->pg_next
;
397 serv
->sv_xdrsize
= xdrsize
;
398 INIT_LIST_HEAD(&serv
->sv_tempsocks
);
399 INIT_LIST_HEAD(&serv
->sv_permsocks
);
400 init_timer(&serv
->sv_temptimer
);
401 spin_lock_init(&serv
->sv_lock
);
403 serv
->sv_nrpools
= npools
;
405 kcalloc(serv
->sv_nrpools
, sizeof(struct svc_pool
),
407 if (!serv
->sv_pools
) {
412 for (i
= 0; i
< serv
->sv_nrpools
; i
++) {
413 struct svc_pool
*pool
= &serv
->sv_pools
[i
];
415 dprintk("svc: initialising pool %u for %s\n",
419 INIT_LIST_HEAD(&pool
->sp_threads
);
420 INIT_LIST_HEAD(&pool
->sp_sockets
);
421 INIT_LIST_HEAD(&pool
->sp_all_threads
);
422 spin_lock_init(&pool
->sp_lock
);
425 /* Remove any stale portmap registrations */
426 svc_unregister(serv
);
432 svc_create(struct svc_program
*prog
, unsigned int bufsize
,
433 void (*shutdown
)(struct svc_serv
*serv
))
435 return __svc_create(prog
, bufsize
, /*npools*/1, shutdown
);
437 EXPORT_SYMBOL_GPL(svc_create
);
440 svc_create_pooled(struct svc_program
*prog
, unsigned int bufsize
,
441 void (*shutdown
)(struct svc_serv
*serv
),
442 svc_thread_fn func
, struct module
*mod
)
444 struct svc_serv
*serv
;
445 unsigned int npools
= svc_pool_map_get();
447 serv
= __svc_create(prog
, bufsize
, npools
, shutdown
);
450 serv
->sv_function
= func
;
451 serv
->sv_module
= mod
;
456 EXPORT_SYMBOL_GPL(svc_create_pooled
);
459 * Destroy an RPC service. Should be called with appropriate locking to
460 * protect the sv_nrthreads, sv_permsocks and sv_tempsocks.
463 svc_destroy(struct svc_serv
*serv
)
465 dprintk("svc: svc_destroy(%s, %d)\n",
466 serv
->sv_program
->pg_name
,
469 if (serv
->sv_nrthreads
) {
470 if (--(serv
->sv_nrthreads
) != 0) {
471 svc_sock_update_bufs(serv
);
475 printk("svc_destroy: no threads for serv=%p!\n", serv
);
477 del_timer_sync(&serv
->sv_temptimer
);
479 svc_close_all(&serv
->sv_tempsocks
);
481 if (serv
->sv_shutdown
)
482 serv
->sv_shutdown(serv
);
484 svc_close_all(&serv
->sv_permsocks
);
486 BUG_ON(!list_empty(&serv
->sv_permsocks
));
487 BUG_ON(!list_empty(&serv
->sv_tempsocks
));
489 cache_clean_deferred(serv
);
491 if (svc_serv_is_pooled(serv
))
494 svc_unregister(serv
);
495 kfree(serv
->sv_pools
);
498 EXPORT_SYMBOL_GPL(svc_destroy
);
501 * Allocate an RPC server's buffer space.
502 * We allocate pages and place them in rq_argpages.
505 svc_init_buffer(struct svc_rqst
*rqstp
, unsigned int size
)
507 unsigned int pages
, arghi
;
509 /* bc_xprt uses fore channel allocated buffers */
510 if (svc_is_backchannel(rqstp
))
513 pages
= size
/ PAGE_SIZE
+ 1; /* extra page as we hold both request and reply.
514 * We assume one is at most one page
517 BUG_ON(pages
> RPCSVC_MAXPAGES
);
519 struct page
*p
= alloc_page(GFP_KERNEL
);
522 rqstp
->rq_pages
[arghi
++] = p
;
529 * Release an RPC server buffer
532 svc_release_buffer(struct svc_rqst
*rqstp
)
536 for (i
= 0; i
< ARRAY_SIZE(rqstp
->rq_pages
); i
++)
537 if (rqstp
->rq_pages
[i
])
538 put_page(rqstp
->rq_pages
[i
]);
542 svc_prepare_thread(struct svc_serv
*serv
, struct svc_pool
*pool
)
544 struct svc_rqst
*rqstp
;
546 rqstp
= kzalloc(sizeof(*rqstp
), GFP_KERNEL
);
550 init_waitqueue_head(&rqstp
->rq_wait
);
552 serv
->sv_nrthreads
++;
553 spin_lock_bh(&pool
->sp_lock
);
554 pool
->sp_nrthreads
++;
555 list_add(&rqstp
->rq_all
, &pool
->sp_all_threads
);
556 spin_unlock_bh(&pool
->sp_lock
);
557 rqstp
->rq_server
= serv
;
558 rqstp
->rq_pool
= pool
;
560 rqstp
->rq_argp
= kmalloc(serv
->sv_xdrsize
, GFP_KERNEL
);
564 rqstp
->rq_resp
= kmalloc(serv
->sv_xdrsize
, GFP_KERNEL
);
568 if (!svc_init_buffer(rqstp
, serv
->sv_max_mesg
))
573 svc_exit_thread(rqstp
);
575 return ERR_PTR(-ENOMEM
);
577 EXPORT_SYMBOL_GPL(svc_prepare_thread
);
580 * Choose a pool in which to create a new thread, for svc_set_num_threads
582 static inline struct svc_pool
*
583 choose_pool(struct svc_serv
*serv
, struct svc_pool
*pool
, unsigned int *state
)
588 return &serv
->sv_pools
[(*state
)++ % serv
->sv_nrpools
];
592 * Choose a thread to kill, for svc_set_num_threads
594 static inline struct task_struct
*
595 choose_victim(struct svc_serv
*serv
, struct svc_pool
*pool
, unsigned int *state
)
598 struct task_struct
*task
= NULL
;
601 spin_lock_bh(&pool
->sp_lock
);
603 /* choose a pool in round-robin fashion */
604 for (i
= 0; i
< serv
->sv_nrpools
; i
++) {
605 pool
= &serv
->sv_pools
[--(*state
) % serv
->sv_nrpools
];
606 spin_lock_bh(&pool
->sp_lock
);
607 if (!list_empty(&pool
->sp_all_threads
))
609 spin_unlock_bh(&pool
->sp_lock
);
615 if (!list_empty(&pool
->sp_all_threads
)) {
616 struct svc_rqst
*rqstp
;
619 * Remove from the pool->sp_all_threads list
620 * so we don't try to kill it again.
622 rqstp
= list_entry(pool
->sp_all_threads
.next
, struct svc_rqst
, rq_all
);
623 list_del_init(&rqstp
->rq_all
);
624 task
= rqstp
->rq_task
;
626 spin_unlock_bh(&pool
->sp_lock
);
632 * Create or destroy enough new threads to make the number
633 * of threads the given number. If `pool' is non-NULL, applies
634 * only to threads in that pool, otherwise round-robins between
635 * all pools. Must be called with a svc_get() reference and
636 * the BKL or another lock to protect access to svc_serv fields.
638 * Destroying threads relies on the service threads filling in
639 * rqstp->rq_task, which only the nfs ones do. Assumes the serv
640 * has been created using svc_create_pooled().
642 * Based on code that used to be in nfsd_svc() but tweaked
646 svc_set_num_threads(struct svc_serv
*serv
, struct svc_pool
*pool
, int nrservs
)
648 struct svc_rqst
*rqstp
;
649 struct task_struct
*task
;
650 struct svc_pool
*chosen_pool
;
652 unsigned int state
= serv
->sv_nrthreads
-1;
655 /* The -1 assumes caller has done a svc_get() */
656 nrservs
-= (serv
->sv_nrthreads
-1);
658 spin_lock_bh(&pool
->sp_lock
);
659 nrservs
-= pool
->sp_nrthreads
;
660 spin_unlock_bh(&pool
->sp_lock
);
663 /* create new threads */
664 while (nrservs
> 0) {
666 chosen_pool
= choose_pool(serv
, pool
, &state
);
668 rqstp
= svc_prepare_thread(serv
, chosen_pool
);
670 error
= PTR_ERR(rqstp
);
674 __module_get(serv
->sv_module
);
675 task
= kthread_create(serv
->sv_function
, rqstp
, serv
->sv_name
);
677 error
= PTR_ERR(task
);
678 module_put(serv
->sv_module
);
679 svc_exit_thread(rqstp
);
683 rqstp
->rq_task
= task
;
684 if (serv
->sv_nrpools
> 1)
685 svc_pool_map_set_cpumask(task
, chosen_pool
->sp_id
);
687 svc_sock_update_bufs(serv
);
688 wake_up_process(task
);
690 /* destroy old threads */
691 while (nrservs
< 0 &&
692 (task
= choose_victim(serv
, pool
, &state
)) != NULL
) {
693 send_sig(SIGINT
, task
, 1);
699 EXPORT_SYMBOL_GPL(svc_set_num_threads
);
702 * Called from a server thread as it's exiting. Caller must hold the BKL or
703 * the "service mutex", whichever is appropriate for the service.
706 svc_exit_thread(struct svc_rqst
*rqstp
)
708 struct svc_serv
*serv
= rqstp
->rq_server
;
709 struct svc_pool
*pool
= rqstp
->rq_pool
;
711 svc_release_buffer(rqstp
);
712 kfree(rqstp
->rq_resp
);
713 kfree(rqstp
->rq_argp
);
714 kfree(rqstp
->rq_auth_data
);
716 spin_lock_bh(&pool
->sp_lock
);
717 pool
->sp_nrthreads
--;
718 list_del(&rqstp
->rq_all
);
719 spin_unlock_bh(&pool
->sp_lock
);
723 /* Release the server */
727 EXPORT_SYMBOL_GPL(svc_exit_thread
);
730 * Register an "inet" protocol family netid with the local
731 * rpcbind daemon via an rpcbind v4 SET request.
733 * No netconfig infrastructure is available in the kernel, so
734 * we map IP_ protocol numbers to netids by hand.
736 * Returns zero on success; a negative errno value is returned
737 * if any error occurs.
739 static int __svc_rpcb_register4(const u32 program
, const u32 version
,
740 const unsigned short protocol
,
741 const unsigned short port
)
743 const struct sockaddr_in sin
= {
744 .sin_family
= AF_INET
,
745 .sin_addr
.s_addr
= htonl(INADDR_ANY
),
746 .sin_port
= htons(port
),
753 netid
= RPCBIND_NETID_UDP
;
756 netid
= RPCBIND_NETID_TCP
;
762 error
= rpcb_v4_register(program
, version
,
763 (const struct sockaddr
*)&sin
, netid
);
766 * User space didn't support rpcbind v4, so retry this
767 * registration request with the legacy rpcbind v2 protocol.
769 if (error
== -EPROTONOSUPPORT
)
770 error
= rpcb_register(program
, version
, protocol
, port
);
775 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
777 * Register an "inet6" protocol family netid with the local
778 * rpcbind daemon via an rpcbind v4 SET request.
780 * No netconfig infrastructure is available in the kernel, so
781 * we map IP_ protocol numbers to netids by hand.
783 * Returns zero on success; a negative errno value is returned
784 * if any error occurs.
786 static int __svc_rpcb_register6(const u32 program
, const u32 version
,
787 const unsigned short protocol
,
788 const unsigned short port
)
790 const struct sockaddr_in6 sin6
= {
791 .sin6_family
= AF_INET6
,
792 .sin6_addr
= IN6ADDR_ANY_INIT
,
793 .sin6_port
= htons(port
),
800 netid
= RPCBIND_NETID_UDP6
;
803 netid
= RPCBIND_NETID_TCP6
;
809 error
= rpcb_v4_register(program
, version
,
810 (const struct sockaddr
*)&sin6
, netid
);
813 * User space didn't support rpcbind version 4, so we won't
814 * use a PF_INET6 listener.
816 if (error
== -EPROTONOSUPPORT
)
817 error
= -EAFNOSUPPORT
;
821 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
824 * Register a kernel RPC service via rpcbind version 4.
826 * Returns zero on success; a negative errno value is returned
827 * if any error occurs.
829 static int __svc_register(const char *progname
,
830 const u32 program
, const u32 version
,
832 const unsigned short protocol
,
833 const unsigned short port
)
835 int error
= -EAFNOSUPPORT
;
839 error
= __svc_rpcb_register4(program
, version
,
842 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
844 error
= __svc_rpcb_register6(program
, version
,
846 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
850 printk(KERN_WARNING
"svc: failed to register %sv%u RPC "
851 "service (errno %d).\n", progname
, version
, -error
);
856 * svc_register - register an RPC service with the local portmapper
857 * @serv: svc_serv struct for the service to register
858 * @family: protocol family of service's listener socket
859 * @proto: transport protocol number to advertise
860 * @port: port to advertise
862 * Service is registered for any address in the passed-in protocol family
864 int svc_register(const struct svc_serv
*serv
, const int family
,
865 const unsigned short proto
, const unsigned short port
)
867 struct svc_program
*progp
;
871 BUG_ON(proto
== 0 && port
== 0);
873 for (progp
= serv
->sv_program
; progp
; progp
= progp
->pg_next
) {
874 for (i
= 0; i
< progp
->pg_nvers
; i
++) {
875 if (progp
->pg_vers
[i
] == NULL
)
878 dprintk("svc: svc_register(%sv%d, %s, %u, %u)%s\n",
881 proto
== IPPROTO_UDP
? "udp" : "tcp",
884 progp
->pg_vers
[i
]->vs_hidden
?
885 " (but not telling portmap)" : "");
887 if (progp
->pg_vers
[i
]->vs_hidden
)
890 error
= __svc_register(progp
->pg_name
, progp
->pg_prog
,
891 i
, family
, proto
, port
);
901 * If user space is running rpcbind, it should take the v4 UNSET
902 * and clear everything for this [program, version]. If user space
903 * is running portmap, it will reject the v4 UNSET, but won't have
904 * any "inet6" entries anyway. So a PMAP_UNSET should be sufficient
905 * in this case to clear all existing entries for [program, version].
907 static void __svc_unregister(const u32 program
, const u32 version
,
908 const char *progname
)
912 error
= rpcb_v4_register(program
, version
, NULL
, "");
915 * User space didn't support rpcbind v4, so retry this
916 * request with the legacy rpcbind v2 protocol.
918 if (error
== -EPROTONOSUPPORT
)
919 error
= rpcb_register(program
, version
, 0, 0);
921 dprintk("svc: %s(%sv%u), error %d\n",
922 __func__
, progname
, version
, error
);
926 * All netids, bind addresses and ports registered for [program, version]
927 * are removed from the local rpcbind database (if the service is not
928 * hidden) to make way for a new instance of the service.
930 * The result of unregistration is reported via dprintk for those who want
931 * verification of the result, but is otherwise not important.
933 static void svc_unregister(const struct svc_serv
*serv
)
935 struct svc_program
*progp
;
939 clear_thread_flag(TIF_SIGPENDING
);
941 for (progp
= serv
->sv_program
; progp
; progp
= progp
->pg_next
) {
942 for (i
= 0; i
< progp
->pg_nvers
; i
++) {
943 if (progp
->pg_vers
[i
] == NULL
)
945 if (progp
->pg_vers
[i
]->vs_hidden
)
948 dprintk("svc: attempting to unregister %sv%u\n",
950 __svc_unregister(progp
->pg_prog
, i
, progp
->pg_name
);
954 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
956 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
960 * Printk the given error with the address of the client that caused it.
963 __attribute__ ((format (printf
, 2, 3)))
964 svc_printk(struct svc_rqst
*rqstp
, const char *fmt
, ...)
968 char buf
[RPC_MAX_ADDRBUFLEN
];
970 if (!net_ratelimit())
973 printk(KERN_WARNING
"svc: %s: ",
974 svc_print_addr(rqstp
, buf
, sizeof(buf
)));
977 r
= vprintk(fmt
, args
);
984 * Common routine for processing the RPC request.
987 svc_process_common(struct svc_rqst
*rqstp
, struct kvec
*argv
, struct kvec
*resv
)
989 struct svc_program
*progp
;
990 struct svc_version
*versp
= NULL
; /* compiler food */
991 struct svc_procedure
*procp
= NULL
;
992 struct svc_serv
*serv
= rqstp
->rq_server
;
995 u32 prog
, vers
, proc
;
996 __be32 auth_stat
, rpc_stat
;
1000 rpc_stat
= rpc_success
;
1002 if (argv
->iov_len
< 6*4)
1005 /* Will be turned off only in gss privacy case: */
1006 rqstp
->rq_splice_ok
= 1;
1007 /* Will be turned off only when NFSv4 Sessions are used */
1008 rqstp
->rq_usedeferral
= 1;
1009 rqstp
->rq_dropme
= false;
1011 /* Setup reply header */
1012 rqstp
->rq_xprt
->xpt_ops
->xpo_prep_reply_hdr(rqstp
);
1014 svc_putu32(resv
, rqstp
->rq_xid
);
1016 vers
= svc_getnl(argv
);
1018 /* First words of reply: */
1019 svc_putnl(resv
, 1); /* REPLY */
1021 if (vers
!= 2) /* RPC version number */
1024 /* Save position in case we later decide to reject: */
1025 reply_statp
= resv
->iov_base
+ resv
->iov_len
;
1027 svc_putnl(resv
, 0); /* ACCEPT */
1029 rqstp
->rq_prog
= prog
= svc_getnl(argv
); /* program number */
1030 rqstp
->rq_vers
= vers
= svc_getnl(argv
); /* version number */
1031 rqstp
->rq_proc
= proc
= svc_getnl(argv
); /* procedure number */
1033 progp
= serv
->sv_program
;
1035 for (progp
= serv
->sv_program
; progp
; progp
= progp
->pg_next
)
1036 if (prog
== progp
->pg_prog
)
1040 * Decode auth data, and add verifier to reply buffer.
1041 * We do this before anything else in order to get a decent
1044 auth_res
= svc_authenticate(rqstp
, &auth_stat
);
1045 /* Also give the program a chance to reject this call: */
1046 if (auth_res
== SVC_OK
&& progp
) {
1047 auth_stat
= rpc_autherr_badcred
;
1048 auth_res
= progp
->pg_authenticate(rqstp
);
1056 rpc_stat
= rpc_system_err
;
1061 if (test_bit(XPT_TEMP
, &rqstp
->rq_xprt
->xpt_flags
))
1062 svc_close_xprt(rqstp
->rq_xprt
);
1072 if (vers
>= progp
->pg_nvers
||
1073 !(versp
= progp
->pg_vers
[vers
]))
1076 procp
= versp
->vs_proc
+ proc
;
1077 if (proc
>= versp
->vs_nproc
|| !procp
->pc_func
)
1079 rqstp
->rq_procinfo
= procp
;
1081 /* Syntactic check complete */
1082 serv
->sv_stats
->rpccnt
++;
1084 /* Build the reply header. */
1085 statp
= resv
->iov_base
+resv
->iov_len
;
1086 svc_putnl(resv
, RPC_SUCCESS
);
1088 /* Bump per-procedure stats counter */
1091 /* Initialize storage for argp and resp */
1092 memset(rqstp
->rq_argp
, 0, procp
->pc_argsize
);
1093 memset(rqstp
->rq_resp
, 0, procp
->pc_ressize
);
1095 /* un-reserve some of the out-queue now that we have a
1096 * better idea of reply size
1098 if (procp
->pc_xdrressize
)
1099 svc_reserve_auth(rqstp
, procp
->pc_xdrressize
<<2);
1101 /* Call the function that processes the request. */
1102 if (!versp
->vs_dispatch
) {
1103 /* Decode arguments */
1104 xdr
= procp
->pc_decode
;
1105 if (xdr
&& !xdr(rqstp
, argv
->iov_base
, rqstp
->rq_argp
))
1108 *statp
= procp
->pc_func(rqstp
, rqstp
->rq_argp
, rqstp
->rq_resp
);
1111 if (rqstp
->rq_dropme
) {
1112 if (procp
->pc_release
)
1113 procp
->pc_release(rqstp
, NULL
, rqstp
->rq_resp
);
1116 if (*statp
== rpc_success
&&
1117 (xdr
= procp
->pc_encode
) &&
1118 !xdr(rqstp
, resv
->iov_base
+resv
->iov_len
, rqstp
->rq_resp
)) {
1119 dprintk("svc: failed to encode reply\n");
1120 /* serv->sv_stats->rpcsystemerr++; */
1121 *statp
= rpc_system_err
;
1124 dprintk("svc: calling dispatcher\n");
1125 if (!versp
->vs_dispatch(rqstp
, statp
)) {
1126 /* Release reply info */
1127 if (procp
->pc_release
)
1128 procp
->pc_release(rqstp
, NULL
, rqstp
->rq_resp
);
1133 /* Check RPC status result */
1134 if (*statp
!= rpc_success
)
1135 resv
->iov_len
= ((void*)statp
) - resv
->iov_base
+ 4;
1137 /* Release reply info */
1138 if (procp
->pc_release
)
1139 procp
->pc_release(rqstp
, NULL
, rqstp
->rq_resp
);
1141 if (procp
->pc_encode
== NULL
)
1145 if (svc_authorise(rqstp
))
1147 return 1; /* Caller can now send it */
1150 svc_authorise(rqstp
); /* doesn't hurt to call this twice */
1151 dprintk("svc: svc_process dropit\n");
1155 svc_printk(rqstp
, "short len %Zd, dropping request\n",
1158 goto dropit
; /* drop request */
1161 serv
->sv_stats
->rpcbadfmt
++;
1162 svc_putnl(resv
, 1); /* REJECT */
1163 svc_putnl(resv
, 0); /* RPC_MISMATCH */
1164 svc_putnl(resv
, 2); /* Only RPCv2 supported */
1169 dprintk("svc: authentication failed (%d)\n", ntohl(auth_stat
));
1170 serv
->sv_stats
->rpcbadauth
++;
1171 /* Restore write pointer to location of accept status: */
1172 xdr_ressize_check(rqstp
, reply_statp
);
1173 svc_putnl(resv
, 1); /* REJECT */
1174 svc_putnl(resv
, 1); /* AUTH_ERROR */
1175 svc_putnl(resv
, ntohl(auth_stat
)); /* status */
1179 dprintk("svc: unknown program %d\n", prog
);
1180 serv
->sv_stats
->rpcbadfmt
++;
1181 svc_putnl(resv
, RPC_PROG_UNAVAIL
);
1185 svc_printk(rqstp
, "unknown version (%d for prog %d, %s)\n",
1186 vers
, prog
, progp
->pg_name
);
1188 serv
->sv_stats
->rpcbadfmt
++;
1189 svc_putnl(resv
, RPC_PROG_MISMATCH
);
1190 svc_putnl(resv
, progp
->pg_lovers
);
1191 svc_putnl(resv
, progp
->pg_hivers
);
1195 svc_printk(rqstp
, "unknown procedure (%d)\n", proc
);
1197 serv
->sv_stats
->rpcbadfmt
++;
1198 svc_putnl(resv
, RPC_PROC_UNAVAIL
);
1202 svc_printk(rqstp
, "failed to decode args\n");
1204 rpc_stat
= rpc_garbage_args
;
1206 serv
->sv_stats
->rpcbadfmt
++;
1207 svc_putnl(resv
, ntohl(rpc_stat
));
1210 EXPORT_SYMBOL_GPL(svc_process
);
1213 * Process the RPC request.
1216 svc_process(struct svc_rqst
*rqstp
)
1218 struct kvec
*argv
= &rqstp
->rq_arg
.head
[0];
1219 struct kvec
*resv
= &rqstp
->rq_res
.head
[0];
1220 struct svc_serv
*serv
= rqstp
->rq_server
;
1224 * Setup response xdr_buf.
1225 * Initially it has just one page
1227 rqstp
->rq_resused
= 1;
1228 resv
->iov_base
= page_address(rqstp
->rq_respages
[0]);
1230 rqstp
->rq_res
.pages
= rqstp
->rq_respages
+ 1;
1231 rqstp
->rq_res
.len
= 0;
1232 rqstp
->rq_res
.page_base
= 0;
1233 rqstp
->rq_res
.page_len
= 0;
1234 rqstp
->rq_res
.buflen
= PAGE_SIZE
;
1235 rqstp
->rq_res
.tail
[0].iov_base
= NULL
;
1236 rqstp
->rq_res
.tail
[0].iov_len
= 0;
1238 rqstp
->rq_xid
= svc_getu32(argv
);
1240 dir
= svc_getnl(argv
);
1242 /* direction != CALL */
1243 svc_printk(rqstp
, "bad direction %d, dropping request\n", dir
);
1244 serv
->sv_stats
->rpcbadfmt
++;
1249 /* Returns 1 for send, 0 for drop */
1250 if (svc_process_common(rqstp
, argv
, resv
))
1251 return svc_send(rqstp
);
1258 #if defined(CONFIG_NFS_V4_1)
1260 * Process a backchannel RPC request that arrived over an existing
1261 * outbound connection
1264 bc_svc_process(struct svc_serv
*serv
, struct rpc_rqst
*req
,
1265 struct svc_rqst
*rqstp
)
1267 struct kvec
*argv
= &rqstp
->rq_arg
.head
[0];
1268 struct kvec
*resv
= &rqstp
->rq_res
.head
[0];
1270 /* Build the svc_rqst used by the common processing routine */
1271 rqstp
->rq_xprt
= serv
->sv_bc_xprt
;
1272 rqstp
->rq_xid
= req
->rq_xid
;
1273 rqstp
->rq_prot
= req
->rq_xprt
->prot
;
1274 rqstp
->rq_server
= serv
;
1276 rqstp
->rq_addrlen
= sizeof(req
->rq_xprt
->addr
);
1277 memcpy(&rqstp
->rq_addr
, &req
->rq_xprt
->addr
, rqstp
->rq_addrlen
);
1278 memcpy(&rqstp
->rq_arg
, &req
->rq_rcv_buf
, sizeof(rqstp
->rq_arg
));
1279 memcpy(&rqstp
->rq_res
, &req
->rq_snd_buf
, sizeof(rqstp
->rq_res
));
1281 /* reset result send buffer "put" position */
1284 if (rqstp
->rq_prot
!= IPPROTO_TCP
) {
1285 printk(KERN_ERR
"No support for Non-TCP transports!\n");
1290 * Skip the next two words because they've already been
1291 * processed in the trasport
1293 svc_getu32(argv
); /* XID */
1294 svc_getnl(argv
); /* CALLDIR */
1296 /* Returns 1 for send, 0 for drop */
1297 if (svc_process_common(rqstp
, argv
, resv
)) {
1298 memcpy(&req
->rq_snd_buf
, &rqstp
->rq_res
,
1299 sizeof(req
->rq_snd_buf
));
1300 return bc_send(req
);
1302 /* Nothing to do to drop request */
1306 EXPORT_SYMBOL(bc_svc_process
);
1307 #endif /* CONFIG_NFS_V4_1 */
1310 * Return (transport-specific) limit on the rpc payload.
1312 u32
svc_max_payload(const struct svc_rqst
*rqstp
)
1314 u32 max
= rqstp
->rq_xprt
->xpt_class
->xcl_max_payload
;
1316 if (rqstp
->rq_server
->sv_max_payload
< max
)
1317 max
= rqstp
->rq_server
->sv_max_payload
;
1320 EXPORT_SYMBOL_GPL(svc_max_payload
);