blob: 91eaef1844c8f09ba77d350786a346919df05725 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/net/sunrpc/svc.c
3 *
4 * High-level RPC service routines
5 *
6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
Greg Banksbfd24162006-10-02 02:18:01 -07007 *
8 * Multiple threads pools and NUMAisation
9 * Copyright (c) 2006 Silicon Graphics, Inc.
10 * by Greg Banks <gnb@melbourne.sgi.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 */
12
13#include <linux/linkage.h>
14#include <linux/sched.h>
15#include <linux/errno.h>
16#include <linux/net.h>
17#include <linux/in.h>
18#include <linux/mm.h>
Greg Banksa7455442006-10-02 02:17:59 -070019#include <linux/interrupt.h>
20#include <linux/module.h>
Jeff Layton9867d762008-06-10 08:40:38 -040021#include <linux/kthread.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090022#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
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>
Ricardo Labiaga4d6bbb62009-04-01 09:23:07 -040029#include <linux/sunrpc/bc_xprt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Jeff Layton860a0d92014-10-28 14:24:12 -040031#include <trace/events/sunrpc.h>
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#define RPCDBG_FACILITY RPCDBG_SVCDSP
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +040035static void svc_unregister(const struct svc_serv *serv, struct net *net);
Chuck Lever7252d572008-08-18 19:34:08 -040036
Greg Banks42a7fc42007-03-06 01:42:23 -080037#define svc_serv_is_pooled(serv) ((serv)->sv_function)
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039/*
Greg Banksbfd24162006-10-02 02:18:01 -070040 * Mode for mapping cpus to pools.
41 */
42enum {
Greg Banks42a7fc42007-03-06 01:42:23 -080043 SVC_POOL_AUTO = -1, /* choose one of the others */
Greg Banksbfd24162006-10-02 02:18:01 -070044 SVC_POOL_GLOBAL, /* no mapping, just a single global pool
45 * (legacy & UP mode) */
46 SVC_POOL_PERCPU, /* one pool per cpu */
47 SVC_POOL_PERNODE /* one pool per numa node */
48};
Greg Banks42a7fc42007-03-06 01:42:23 -080049#define SVC_POOL_DEFAULT SVC_POOL_GLOBAL
Greg Banksbfd24162006-10-02 02:18:01 -070050
51/*
52 * Structure for mapping cpus to pools and vice versa.
53 * Setup once during sunrpc initialisation.
54 */
55static struct svc_pool_map {
Greg Banks42a7fc42007-03-06 01:42:23 -080056 int count; /* How many svc_servs use us */
Greg Banksbfd24162006-10-02 02:18:01 -070057 int mode; /* Note: int not enum to avoid
58 * warnings about "enumeration value
59 * not handled in switch" */
60 unsigned int npools;
61 unsigned int *pool_to; /* maps pool id to cpu or node */
62 unsigned int *to_pool; /* maps cpu or node to pool id */
63} svc_pool_map = {
Greg Banks42a7fc42007-03-06 01:42:23 -080064 .count = 0,
65 .mode = SVC_POOL_DEFAULT
Greg Banksbfd24162006-10-02 02:18:01 -070066};
Greg Banks42a7fc42007-03-06 01:42:23 -080067static DEFINE_MUTEX(svc_pool_map_mutex);/* protects svc_pool_map.count only */
Greg Banksbfd24162006-10-02 02:18:01 -070068
Greg Banks42a7fc42007-03-06 01:42:23 -080069static int
70param_set_pool_mode(const char *val, struct kernel_param *kp)
71{
72 int *ip = (int *)kp->arg;
73 struct svc_pool_map *m = &svc_pool_map;
74 int err;
75
76 mutex_lock(&svc_pool_map_mutex);
77
78 err = -EBUSY;
79 if (m->count)
80 goto out;
81
82 err = 0;
83 if (!strncmp(val, "auto", 4))
84 *ip = SVC_POOL_AUTO;
85 else if (!strncmp(val, "global", 6))
86 *ip = SVC_POOL_GLOBAL;
87 else if (!strncmp(val, "percpu", 6))
88 *ip = SVC_POOL_PERCPU;
89 else if (!strncmp(val, "pernode", 7))
90 *ip = SVC_POOL_PERNODE;
91 else
92 err = -EINVAL;
93
94out:
95 mutex_unlock(&svc_pool_map_mutex);
96 return err;
97}
98
99static int
100param_get_pool_mode(char *buf, struct kernel_param *kp)
101{
102 int *ip = (int *)kp->arg;
103
104 switch (*ip)
105 {
106 case SVC_POOL_AUTO:
107 return strlcpy(buf, "auto", 20);
108 case SVC_POOL_GLOBAL:
109 return strlcpy(buf, "global", 20);
110 case SVC_POOL_PERCPU:
111 return strlcpy(buf, "percpu", 20);
112 case SVC_POOL_PERNODE:
113 return strlcpy(buf, "pernode", 20);
114 default:
115 return sprintf(buf, "%d", *ip);
116 }
117}
118
119module_param_call(pool_mode, param_set_pool_mode, param_get_pool_mode,
120 &svc_pool_map.mode, 0644);
Greg Banksbfd24162006-10-02 02:18:01 -0700121
122/*
123 * Detect best pool mapping mode heuristically,
124 * according to the machine's topology.
125 */
126static int
127svc_pool_map_choose_mode(void)
128{
129 unsigned int node;
130
Christoph Lameter62bc62a2009-06-16 15:32:15 -0700131 if (nr_online_nodes > 1) {
Greg Banksbfd24162006-10-02 02:18:01 -0700132 /*
133 * Actually have multiple NUMA nodes,
134 * so split pools on NUMA node boundaries
135 */
136 return SVC_POOL_PERNODE;
137 }
138
H Hartley Sweeten72c33682010-03-05 13:42:43 -0800139 node = first_online_node;
Greg Banksbfd24162006-10-02 02:18:01 -0700140 if (nr_cpus_node(node) > 2) {
141 /*
142 * Non-trivial SMP, or CONFIG_NUMA on
143 * non-NUMA hardware, e.g. with a generic
144 * x86_64 kernel on Xeons. In this case we
145 * want to divide the pools on cpu boundaries.
146 */
147 return SVC_POOL_PERCPU;
148 }
149
150 /* default: one global pool */
151 return SVC_POOL_GLOBAL;
152}
153
154/*
155 * Allocate the to_pool[] and pool_to[] arrays.
156 * Returns 0 on success or an errno.
157 */
158static int
159svc_pool_map_alloc_arrays(struct svc_pool_map *m, unsigned int maxpools)
160{
161 m->to_pool = kcalloc(maxpools, sizeof(unsigned int), GFP_KERNEL);
162 if (!m->to_pool)
163 goto fail;
164 m->pool_to = kcalloc(maxpools, sizeof(unsigned int), GFP_KERNEL);
165 if (!m->pool_to)
166 goto fail_free;
167
168 return 0;
169
170fail_free:
171 kfree(m->to_pool);
J. Bruce Fields61c85042011-12-22 18:22:49 -0700172 m->to_pool = NULL;
Greg Banksbfd24162006-10-02 02:18:01 -0700173fail:
174 return -ENOMEM;
175}
176
177/*
178 * Initialise the pool map for SVC_POOL_PERCPU mode.
179 * Returns number of pools or <0 on error.
180 */
181static int
182svc_pool_map_init_percpu(struct svc_pool_map *m)
183{
Christoph Lameter53b8a312007-02-20 13:57:51 -0800184 unsigned int maxpools = nr_cpu_ids;
Greg Banksbfd24162006-10-02 02:18:01 -0700185 unsigned int pidx = 0;
186 unsigned int cpu;
187 int err;
188
189 err = svc_pool_map_alloc_arrays(m, maxpools);
190 if (err)
191 return err;
192
193 for_each_online_cpu(cpu) {
Dan Carpentereb631922014-10-29 11:44:16 +0300194 BUG_ON(pidx >= maxpools);
Greg Banksbfd24162006-10-02 02:18:01 -0700195 m->to_pool[cpu] = pidx;
196 m->pool_to[pidx] = cpu;
197 pidx++;
198 }
199 /* cpus brought online later all get mapped to pool0, sorry */
200
201 return pidx;
202};
203
204
205/*
206 * Initialise the pool map for SVC_POOL_PERNODE mode.
207 * Returns number of pools or <0 on error.
208 */
209static int
210svc_pool_map_init_pernode(struct svc_pool_map *m)
211{
Christoph Lameter74c7aa82007-02-20 13:57:51 -0800212 unsigned int maxpools = nr_node_ids;
Greg Banksbfd24162006-10-02 02:18:01 -0700213 unsigned int pidx = 0;
214 unsigned int node;
215 int err;
216
217 err = svc_pool_map_alloc_arrays(m, maxpools);
218 if (err)
219 return err;
220
221 for_each_node_with_cpus(node) {
222 /* some architectures (e.g. SN2) have cpuless nodes */
223 BUG_ON(pidx > maxpools);
224 m->to_pool[node] = pidx;
225 m->pool_to[pidx] = node;
226 pidx++;
227 }
228 /* nodes brought online later all get mapped to pool0, sorry */
229
230 return pidx;
231}
232
233
234/*
Greg Banks42a7fc42007-03-06 01:42:23 -0800235 * Add a reference to the global map of cpus to pools (and
236 * vice versa). Initialise the map if we're the first user.
237 * Returns the number of pools.
Greg Banksbfd24162006-10-02 02:18:01 -0700238 */
239static unsigned int
Greg Banks42a7fc42007-03-06 01:42:23 -0800240svc_pool_map_get(void)
Greg Banksbfd24162006-10-02 02:18:01 -0700241{
242 struct svc_pool_map *m = &svc_pool_map;
243 int npools = -1;
244
Greg Banks42a7fc42007-03-06 01:42:23 -0800245 mutex_lock(&svc_pool_map_mutex);
Greg Banksbfd24162006-10-02 02:18:01 -0700246
Greg Banks42a7fc42007-03-06 01:42:23 -0800247 if (m->count++) {
248 mutex_unlock(&svc_pool_map_mutex);
249 return m->npools;
250 }
251
252 if (m->mode == SVC_POOL_AUTO)
253 m->mode = svc_pool_map_choose_mode();
Greg Banksbfd24162006-10-02 02:18:01 -0700254
255 switch (m->mode) {
256 case SVC_POOL_PERCPU:
257 npools = svc_pool_map_init_percpu(m);
258 break;
259 case SVC_POOL_PERNODE:
260 npools = svc_pool_map_init_pernode(m);
261 break;
262 }
263
264 if (npools < 0) {
265 /* default, or memory allocation failure */
266 npools = 1;
267 m->mode = SVC_POOL_GLOBAL;
268 }
269 m->npools = npools;
270
Greg Banks42a7fc42007-03-06 01:42:23 -0800271 mutex_unlock(&svc_pool_map_mutex);
Greg Banksbfd24162006-10-02 02:18:01 -0700272 return m->npools;
273}
274
Greg Banks42a7fc42007-03-06 01:42:23 -0800275
276/*
277 * Drop a reference to the global map of cpus to pools.
278 * When the last reference is dropped, the map data is
279 * freed; this allows the sysadmin to change the pool
280 * mode using the pool_mode module option without
281 * rebooting or re-loading sunrpc.ko.
282 */
283static void
284svc_pool_map_put(void)
285{
286 struct svc_pool_map *m = &svc_pool_map;
287
288 mutex_lock(&svc_pool_map_mutex);
289
290 if (!--m->count) {
Greg Banks42a7fc42007-03-06 01:42:23 -0800291 kfree(m->to_pool);
J. Bruce Fields61c85042011-12-22 18:22:49 -0700292 m->to_pool = NULL;
Greg Banks42a7fc42007-03-06 01:42:23 -0800293 kfree(m->pool_to);
J. Bruce Fields61c85042011-12-22 18:22:49 -0700294 m->pool_to = NULL;
Greg Banks42a7fc42007-03-06 01:42:23 -0800295 m->npools = 0;
296 }
297
298 mutex_unlock(&svc_pool_map_mutex);
299}
300
301
Eric Dumazet11fd1652011-07-28 20:04:09 +0200302static int svc_pool_map_get_node(unsigned int pidx)
303{
304 const struct svc_pool_map *m = &svc_pool_map;
305
306 if (m->count) {
307 if (m->mode == SVC_POOL_PERCPU)
308 return cpu_to_node(m->pool_to[pidx]);
309 if (m->mode == SVC_POOL_PERNODE)
310 return m->pool_to[pidx];
311 }
312 return NUMA_NO_NODE;
313}
Greg Banksbfd24162006-10-02 02:18:01 -0700314/*
Jeff Layton9867d762008-06-10 08:40:38 -0400315 * Set the given thread's cpus_allowed mask so that it
Greg Banksbfd24162006-10-02 02:18:01 -0700316 * will only run on cpus in the given pool.
Greg Banksbfd24162006-10-02 02:18:01 -0700317 */
Jeff Layton9867d762008-06-10 08:40:38 -0400318static inline void
319svc_pool_map_set_cpumask(struct task_struct *task, unsigned int pidx)
Greg Banksbfd24162006-10-02 02:18:01 -0700320{
321 struct svc_pool_map *m = &svc_pool_map;
Jeff Layton9867d762008-06-10 08:40:38 -0400322 unsigned int node = m->pool_to[pidx];
Greg Banksbfd24162006-10-02 02:18:01 -0700323
324 /*
325 * The caller checks for sv_nrpools > 1, which
Greg Banks42a7fc42007-03-06 01:42:23 -0800326 * implies that we've been initialized.
Greg Banksbfd24162006-10-02 02:18:01 -0700327 */
Weston Andros Adamson1bd58aa2012-10-23 10:43:38 -0400328 WARN_ON_ONCE(m->count == 0);
329 if (m->count == 0)
330 return;
Greg Banksbfd24162006-10-02 02:18:01 -0700331
Jeff Layton9867d762008-06-10 08:40:38 -0400332 switch (m->mode) {
Greg Banksbfd24162006-10-02 02:18:01 -0700333 case SVC_POOL_PERCPU:
Mike Travisc5f59f02008-04-04 18:11:10 -0700334 {
Rusty Russellaa85ea52009-03-30 22:05:15 -0600335 set_cpus_allowed_ptr(task, cpumask_of(node));
Jeff Layton9867d762008-06-10 08:40:38 -0400336 break;
Mike Travisc5f59f02008-04-04 18:11:10 -0700337 }
Greg Banksbfd24162006-10-02 02:18:01 -0700338 case SVC_POOL_PERNODE:
Mike Travisc5f59f02008-04-04 18:11:10 -0700339 {
Rusty Russella70f7302009-03-13 14:49:46 +1030340 set_cpus_allowed_ptr(task, cpumask_of_node(node));
Jeff Layton9867d762008-06-10 08:40:38 -0400341 break;
Greg Banksbfd24162006-10-02 02:18:01 -0700342 }
Mike Travisc5f59f02008-04-04 18:11:10 -0700343 }
Greg Banksbfd24162006-10-02 02:18:01 -0700344}
345
346/*
347 * Use the mapping mode to choose a pool for a given CPU.
348 * Used when enqueueing an incoming RPC. Always returns
349 * a non-NULL pool pointer.
350 */
351struct svc_pool *
352svc_pool_for_cpu(struct svc_serv *serv, int cpu)
353{
354 struct svc_pool_map *m = &svc_pool_map;
355 unsigned int pidx = 0;
356
357 /*
Greg Banks42a7fc42007-03-06 01:42:23 -0800358 * An uninitialised map happens in a pure client when
Greg Banksbfd24162006-10-02 02:18:01 -0700359 * lockd is brought up, so silently treat it the
360 * same as SVC_POOL_GLOBAL.
361 */
Greg Banks42a7fc42007-03-06 01:42:23 -0800362 if (svc_serv_is_pooled(serv)) {
363 switch (m->mode) {
364 case SVC_POOL_PERCPU:
365 pidx = m->to_pool[cpu];
366 break;
367 case SVC_POOL_PERNODE:
368 pidx = m->to_pool[cpu_to_node(cpu)];
369 break;
370 }
Greg Banksbfd24162006-10-02 02:18:01 -0700371 }
372 return &serv->sv_pools[pidx % serv->sv_nrpools];
373}
374
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400375int svc_rpcb_setup(struct svc_serv *serv, struct net *net)
Stanislav Kinsburskyd9908562011-10-25 14:16:58 +0300376{
377 int err;
378
Stanislav Kinsburskybee42f682012-01-13 14:02:56 +0400379 err = rpcb_create_local(net);
Stanislav Kinsburskyd9908562011-10-25 14:16:58 +0300380 if (err)
381 return err;
382
383 /* Remove any stale portmap registrations */
Stanislav Kinsburskybee42f682012-01-13 14:02:56 +0400384 svc_unregister(serv, net);
Stanislav Kinsburskyd9908562011-10-25 14:16:58 +0300385 return 0;
386}
Stanislav Kinsburskybb2224d2012-01-31 15:08:05 +0400387EXPORT_SYMBOL_GPL(svc_rpcb_setup);
Stanislav Kinsburskyd9908562011-10-25 14:16:58 +0300388
Stanislav Kinsbursky5ecebb72012-01-13 14:03:04 +0400389void svc_rpcb_cleanup(struct svc_serv *serv, struct net *net)
Stanislav Kinsburskyd9908562011-10-25 14:16:58 +0300390{
Stanislav Kinsbursky5ecebb72012-01-13 14:03:04 +0400391 svc_unregister(serv, net);
392 rpcb_put_local(net);
Stanislav Kinsburskyd9908562011-10-25 14:16:58 +0300393}
Stanislav Kinsbursky16d05872011-10-25 14:17:28 +0300394EXPORT_SYMBOL_GPL(svc_rpcb_cleanup);
Stanislav Kinsburskyd9908562011-10-25 14:16:58 +0300395
396static int svc_uses_rpcbind(struct svc_serv *serv)
397{
398 struct svc_program *progp;
399 unsigned int i;
400
401 for (progp = serv->sv_program; progp; progp = progp->pg_next) {
402 for (i = 0; i < progp->pg_nvers; i++) {
403 if (progp->pg_vers[i] == NULL)
404 continue;
405 if (progp->pg_vers[i]->vs_hidden == 0)
406 return 1;
407 }
408 }
409
410 return 0;
411}
Greg Banksbfd24162006-10-02 02:18:01 -0700412
Stanislav Kinsbursky9793f7c2012-05-02 16:08:38 +0400413int svc_bind(struct svc_serv *serv, struct net *net)
414{
415 if (!svc_uses_rpcbind(serv))
416 return 0;
417 return svc_rpcb_setup(serv, net);
418}
419EXPORT_SYMBOL_GPL(svc_bind);
420
Greg Banksbfd24162006-10-02 02:18:01 -0700421/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 * Create an RPC service
423 */
Greg Banksa7455442006-10-02 02:17:59 -0700424static struct svc_serv *
425__svc_create(struct svc_program *prog, unsigned int bufsize, int npools,
Stanislav Kinsbursky5ecebb72012-01-13 14:03:04 +0400426 void (*shutdown)(struct svc_serv *serv, struct net *net))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427{
428 struct svc_serv *serv;
Chuck Leverea339d42007-10-26 13:32:56 -0400429 unsigned int vers;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 unsigned int xdrsize;
Greg Banks3262c812006-10-02 02:17:58 -0700431 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700433 if (!(serv = kzalloc(sizeof(*serv), GFP_KERNEL)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 return NULL;
Andreas Gruenbacher9ba02632005-06-22 17:16:24 +0000435 serv->sv_name = prog->pg_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 serv->sv_program = prog;
437 serv->sv_nrthreads = 1;
438 serv->sv_stats = prog->pg_stats;
NeilBrownc6b0a9f2006-10-06 00:44:05 -0700439 if (bufsize > RPCSVC_MAXPAYLOAD)
440 bufsize = RPCSVC_MAXPAYLOAD;
441 serv->sv_max_payload = bufsize? bufsize : 4096;
442 serv->sv_max_mesg = roundup(serv->sv_max_payload + PAGE_SIZE, PAGE_SIZE);
NeilBrownbc591cc2006-10-02 02:17:44 -0700443 serv->sv_shutdown = shutdown;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 xdrsize = 0;
Andreas Gruenbacher9ba02632005-06-22 17:16:24 +0000445 while (prog) {
446 prog->pg_lovers = prog->pg_nvers-1;
447 for (vers=0; vers<prog->pg_nvers ; vers++)
448 if (prog->pg_vers[vers]) {
449 prog->pg_hivers = vers;
450 if (prog->pg_lovers > vers)
451 prog->pg_lovers = vers;
452 if (prog->pg_vers[vers]->vs_xdrsize > xdrsize)
453 xdrsize = prog->pg_vers[vers]->vs_xdrsize;
454 }
455 prog = prog->pg_next;
456 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 serv->sv_xdrsize = xdrsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 INIT_LIST_HEAD(&serv->sv_tempsocks);
459 INIT_LIST_HEAD(&serv->sv_permsocks);
Greg Banks36bdfc82006-10-02 02:17:54 -0700460 init_timer(&serv->sv_temptimer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 spin_lock_init(&serv->sv_lock);
462
Greg Banksa7455442006-10-02 02:17:59 -0700463 serv->sv_nrpools = npools;
Greg Banks3262c812006-10-02 02:17:58 -0700464 serv->sv_pools =
Robert P. J. Daycd861282006-12-13 00:34:52 -0800465 kcalloc(serv->sv_nrpools, sizeof(struct svc_pool),
Greg Banks3262c812006-10-02 02:17:58 -0700466 GFP_KERNEL);
467 if (!serv->sv_pools) {
468 kfree(serv);
469 return NULL;
470 }
471
472 for (i = 0; i < serv->sv_nrpools; i++) {
473 struct svc_pool *pool = &serv->sv_pools[i];
474
Chuck Lever46121cf2007-01-31 12:14:08 -0500475 dprintk("svc: initialising pool %u for %s\n",
Greg Banks3262c812006-10-02 02:17:58 -0700476 i, serv->sv_name);
477
478 pool->sp_id = i;
Greg Banks3262c812006-10-02 02:17:58 -0700479 INIT_LIST_HEAD(&pool->sp_sockets);
Greg Banksa7455442006-10-02 02:17:59 -0700480 INIT_LIST_HEAD(&pool->sp_all_threads);
Greg Banks3262c812006-10-02 02:17:58 -0700481 spin_lock_init(&pool->sp_lock);
482 }
483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 return serv;
485}
486
Greg Banksa7455442006-10-02 02:17:59 -0700487struct svc_serv *
488svc_create(struct svc_program *prog, unsigned int bufsize,
Stanislav Kinsbursky5ecebb72012-01-13 14:03:04 +0400489 void (*shutdown)(struct svc_serv *serv, struct net *net))
Greg Banksa7455442006-10-02 02:17:59 -0700490{
Chuck Lever49a90722009-03-18 20:46:29 -0400491 return __svc_create(prog, bufsize, /*npools*/1, shutdown);
Greg Banksa7455442006-10-02 02:17:59 -0700492}
Trond Myklebust24c37672008-12-23 16:30:12 -0500493EXPORT_SYMBOL_GPL(svc_create);
Greg Banksa7455442006-10-02 02:17:59 -0700494
495struct svc_serv *
496svc_create_pooled(struct svc_program *prog, unsigned int bufsize,
Stanislav Kinsbursky5ecebb72012-01-13 14:03:04 +0400497 void (*shutdown)(struct svc_serv *serv, struct net *net),
Jeff Laytona75c5d02008-06-10 08:40:39 -0400498 svc_thread_fn func, struct module *mod)
Greg Banksa7455442006-10-02 02:17:59 -0700499{
500 struct svc_serv *serv;
Greg Banks42a7fc42007-03-06 01:42:23 -0800501 unsigned int npools = svc_pool_map_get();
Greg Banksa7455442006-10-02 02:17:59 -0700502
Chuck Lever49a90722009-03-18 20:46:29 -0400503 serv = __svc_create(prog, bufsize, npools, shutdown);
Jeff Layton067f96e2014-11-19 07:51:13 -0500504 if (!serv)
505 goto out_err;
Greg Banksa7455442006-10-02 02:17:59 -0700506
Jeff Layton067f96e2014-11-19 07:51:13 -0500507 serv->sv_function = func;
508 serv->sv_module = mod;
Greg Banksa7455442006-10-02 02:17:59 -0700509 return serv;
Jeff Layton067f96e2014-11-19 07:51:13 -0500510out_err:
511 svc_pool_map_put();
512 return NULL;
Greg Banksa7455442006-10-02 02:17:59 -0700513}
Trond Myklebust24c37672008-12-23 16:30:12 -0500514EXPORT_SYMBOL_GPL(svc_create_pooled);
Greg Banksa7455442006-10-02 02:17:59 -0700515
Stanislav Kinsbursky074d0f62012-01-31 14:09:25 +0400516void svc_shutdown_net(struct svc_serv *serv, struct net *net)
517{
Stanislav Kinsbursky074d0f62012-01-31 14:09:25 +0400518 svc_close_net(serv, net);
519
520 if (serv->sv_shutdown)
521 serv->sv_shutdown(serv, net);
522}
523EXPORT_SYMBOL_GPL(svc_shutdown_net);
524
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525/*
Neil Brownbedbdd82008-06-10 08:40:35 -0400526 * Destroy an RPC service. Should be called with appropriate locking to
527 * protect the sv_nrthreads, sv_permsocks and sv_tempsocks.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 */
529void
530svc_destroy(struct svc_serv *serv)
531{
Chuck Lever46121cf2007-01-31 12:14:08 -0500532 dprintk("svc: svc_destroy(%s, %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 serv->sv_program->pg_name,
534 serv->sv_nrthreads);
535
536 if (serv->sv_nrthreads) {
537 if (--(serv->sv_nrthreads) != 0) {
538 svc_sock_update_bufs(serv);
539 return;
540 }
541 } else
542 printk("svc_destroy: no threads for serv=%p!\n", serv);
543
Greg Banks36bdfc82006-10-02 02:17:54 -0700544 del_timer_sync(&serv->sv_temptimer);
Stanislav Kinsbursky074d0f62012-01-31 14:09:25 +0400545
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +0400546 /*
547 * The last user is gone and thus all sockets have to be destroyed to
548 * the point. Check this.
549 */
550 BUG_ON(!list_empty(&serv->sv_permsocks));
551 BUG_ON(!list_empty(&serv->sv_tempsocks));
NeilBrowncda1fd42007-03-06 01:42:22 -0800552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 cache_clean_deferred(serv);
554
Greg Banks42a7fc42007-03-06 01:42:23 -0800555 if (svc_serv_is_pooled(serv))
556 svc_pool_map_put();
557
Greg Banks3262c812006-10-02 02:17:58 -0700558 kfree(serv->sv_pools);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 kfree(serv);
560}
Trond Myklebust24c37672008-12-23 16:30:12 -0500561EXPORT_SYMBOL_GPL(svc_destroy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
563/*
564 * Allocate an RPC server's buffer space.
565 * We allocate pages and place them in rq_argpages.
566 */
567static int
Eric Dumazet11fd1652011-07-28 20:04:09 +0200568svc_init_buffer(struct svc_rqst *rqstp, unsigned int size, int node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Chuck Lever0dc220f2008-04-14 12:27:52 -0400570 unsigned int pages, arghi;
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800571
Andy Adamsonba176862010-01-26 21:24:04 -0500572 /* bc_xprt uses fore channel allocated buffers */
573 if (svc_is_backchannel(rqstp))
574 return 1;
575
NeilBrownc6b0a9f2006-10-06 00:44:05 -0700576 pages = size / PAGE_SIZE + 1; /* extra page as we hold both request and reply.
577 * We assume one is at most one page
578 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 arghi = 0;
Weston Andros Adamsonb25cd052012-10-23 10:43:41 -0400580 WARN_ON_ONCE(pages > RPCSVC_MAXPAGES);
581 if (pages > RPCSVC_MAXPAGES)
582 pages = RPCSVC_MAXPAGES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 while (pages) {
Eric Dumazet11fd1652011-07-28 20:04:09 +0200584 struct page *p = alloc_pages_node(node, GFP_KERNEL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 if (!p)
586 break;
NeilBrown44524352006-10-04 02:15:46 -0700587 rqstp->rq_pages[arghi++] = p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 pages--;
589 }
Chuck Lever0dc220f2008-04-14 12:27:52 -0400590 return pages == 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591}
592
593/*
594 * Release an RPC server buffer
595 */
596static void
597svc_release_buffer(struct svc_rqst *rqstp)
598{
Chuck Lever50c8bb12008-04-14 12:27:45 -0400599 unsigned int i;
600
601 for (i = 0; i < ARRAY_SIZE(rqstp->rq_pages); i++)
NeilBrown44524352006-10-04 02:15:46 -0700602 if (rqstp->rq_pages[i])
603 put_page(rqstp->rq_pages[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604}
605
Jeff Layton0113ab32008-01-29 10:30:54 -0500606struct svc_rqst *
Eric Dumazet11fd1652011-07-28 20:04:09 +0200607svc_prepare_thread(struct svc_serv *serv, struct svc_pool *pool, int node)
Jeff Layton0113ab32008-01-29 10:30:54 -0500608{
609 struct svc_rqst *rqstp;
610
Eric Dumazet11fd1652011-07-28 20:04:09 +0200611 rqstp = kzalloc_node(sizeof(*rqstp), GFP_KERNEL, node);
Jeff Layton0113ab32008-01-29 10:30:54 -0500612 if (!rqstp)
613 goto out_enomem;
614
Jeff Layton0113ab32008-01-29 10:30:54 -0500615 serv->sv_nrthreads++;
Jeff Laytonb1691bc2014-11-21 14:19:30 -0500616 __set_bit(RQ_BUSY, &rqstp->rq_flags);
617 spin_lock_init(&rqstp->rq_lock);
618 rqstp->rq_server = serv;
619 rqstp->rq_pool = pool;
Jeff Layton0113ab32008-01-29 10:30:54 -0500620 spin_lock_bh(&pool->sp_lock);
621 pool->sp_nrthreads++;
Jeff Layton81244382014-11-21 14:19:28 -0500622 list_add_rcu(&rqstp->rq_all, &pool->sp_all_threads);
Jeff Layton0113ab32008-01-29 10:30:54 -0500623 spin_unlock_bh(&pool->sp_lock);
Jeff Layton0113ab32008-01-29 10:30:54 -0500624
Eric Dumazet11fd1652011-07-28 20:04:09 +0200625 rqstp->rq_argp = kmalloc_node(serv->sv_xdrsize, GFP_KERNEL, node);
Jeff Layton0113ab32008-01-29 10:30:54 -0500626 if (!rqstp->rq_argp)
627 goto out_thread;
628
Eric Dumazet11fd1652011-07-28 20:04:09 +0200629 rqstp->rq_resp = kmalloc_node(serv->sv_xdrsize, GFP_KERNEL, node);
Jeff Layton0113ab32008-01-29 10:30:54 -0500630 if (!rqstp->rq_resp)
631 goto out_thread;
632
Eric Dumazet11fd1652011-07-28 20:04:09 +0200633 if (!svc_init_buffer(rqstp, serv->sv_max_mesg, node))
Jeff Layton0113ab32008-01-29 10:30:54 -0500634 goto out_thread;
635
636 return rqstp;
637out_thread:
638 svc_exit_thread(rqstp);
639out_enomem:
640 return ERR_PTR(-ENOMEM);
641}
Trond Myklebust24c37672008-12-23 16:30:12 -0500642EXPORT_SYMBOL_GPL(svc_prepare_thread);
Jeff Layton0113ab32008-01-29 10:30:54 -0500643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644/*
Greg Banksa7455442006-10-02 02:17:59 -0700645 * Choose a pool in which to create a new thread, for svc_set_num_threads
646 */
647static inline struct svc_pool *
648choose_pool(struct svc_serv *serv, struct svc_pool *pool, unsigned int *state)
649{
650 if (pool != NULL)
651 return pool;
652
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800653 return &serv->sv_pools[(*state)++ % serv->sv_nrpools];
Greg Banksa7455442006-10-02 02:17:59 -0700654}
655
656/*
657 * Choose a thread to kill, for svc_set_num_threads
658 */
659static inline struct task_struct *
660choose_victim(struct svc_serv *serv, struct svc_pool *pool, unsigned int *state)
661{
662 unsigned int i;
663 struct task_struct *task = NULL;
664
665 if (pool != NULL) {
666 spin_lock_bh(&pool->sp_lock);
667 } else {
668 /* choose a pool in round-robin fashion */
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800669 for (i = 0; i < serv->sv_nrpools; i++) {
670 pool = &serv->sv_pools[--(*state) % serv->sv_nrpools];
Greg Banksa7455442006-10-02 02:17:59 -0700671 spin_lock_bh(&pool->sp_lock);
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800672 if (!list_empty(&pool->sp_all_threads))
673 goto found_pool;
Greg Banksa7455442006-10-02 02:17:59 -0700674 spin_unlock_bh(&pool->sp_lock);
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800675 }
Greg Banksa7455442006-10-02 02:17:59 -0700676 return NULL;
677 }
678
679found_pool:
680 if (!list_empty(&pool->sp_all_threads)) {
681 struct svc_rqst *rqstp;
682
683 /*
684 * Remove from the pool->sp_all_threads list
685 * so we don't try to kill it again.
686 */
687 rqstp = list_entry(pool->sp_all_threads.next, struct svc_rqst, rq_all);
Jeff Layton81244382014-11-21 14:19:28 -0500688 set_bit(RQ_VICTIM, &rqstp->rq_flags);
689 list_del_rcu(&rqstp->rq_all);
Greg Banksa7455442006-10-02 02:17:59 -0700690 task = rqstp->rq_task;
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800691 }
Greg Banksa7455442006-10-02 02:17:59 -0700692 spin_unlock_bh(&pool->sp_lock);
693
694 return task;
695}
696
697/*
698 * Create or destroy enough new threads to make the number
699 * of threads the given number. If `pool' is non-NULL, applies
700 * only to threads in that pool, otherwise round-robins between
J. Bruce Fields94cf3172011-12-01 17:51:21 -0500701 * all pools. Caller must ensure that mutual exclusion between this and
702 * server startup or shutdown.
Greg Banksa7455442006-10-02 02:17:59 -0700703 *
704 * Destroying threads relies on the service threads filling in
705 * rqstp->rq_task, which only the nfs ones do. Assumes the serv
706 * has been created using svc_create_pooled().
707 *
708 * Based on code that used to be in nfsd_svc() but tweaked
709 * to be pool-aware.
710 */
711int
712svc_set_num_threads(struct svc_serv *serv, struct svc_pool *pool, int nrservs)
713{
Jeff Layton9867d762008-06-10 08:40:38 -0400714 struct svc_rqst *rqstp;
715 struct task_struct *task;
716 struct svc_pool *chosen_pool;
Greg Banksa7455442006-10-02 02:17:59 -0700717 int error = 0;
718 unsigned int state = serv->sv_nrthreads-1;
Eric Dumazet11fd1652011-07-28 20:04:09 +0200719 int node;
Greg Banksa7455442006-10-02 02:17:59 -0700720
721 if (pool == NULL) {
722 /* The -1 assumes caller has done a svc_get() */
723 nrservs -= (serv->sv_nrthreads-1);
724 } else {
725 spin_lock_bh(&pool->sp_lock);
726 nrservs -= pool->sp_nrthreads;
727 spin_unlock_bh(&pool->sp_lock);
728 }
729
730 /* create new threads */
731 while (nrservs > 0) {
732 nrservs--;
Jeff Layton9867d762008-06-10 08:40:38 -0400733 chosen_pool = choose_pool(serv, pool, &state);
734
Eric Dumazet11fd1652011-07-28 20:04:09 +0200735 node = svc_pool_map_get_node(chosen_pool->sp_id);
736 rqstp = svc_prepare_thread(serv, chosen_pool, node);
Jeff Layton9867d762008-06-10 08:40:38 -0400737 if (IS_ERR(rqstp)) {
738 error = PTR_ERR(rqstp);
Greg Banksa7455442006-10-02 02:17:59 -0700739 break;
740 }
Jeff Layton9867d762008-06-10 08:40:38 -0400741
742 __module_get(serv->sv_module);
Eric Dumazet11fd1652011-07-28 20:04:09 +0200743 task = kthread_create_on_node(serv->sv_function, rqstp,
Kees Cookf1701682013-07-03 15:04:58 -0700744 node, "%s", serv->sv_name);
Jeff Layton9867d762008-06-10 08:40:38 -0400745 if (IS_ERR(task)) {
746 error = PTR_ERR(task);
747 module_put(serv->sv_module);
748 svc_exit_thread(rqstp);
749 break;
750 }
751
752 rqstp->rq_task = task;
753 if (serv->sv_nrpools > 1)
754 svc_pool_map_set_cpumask(task, chosen_pool->sp_id);
755
756 svc_sock_update_bufs(serv);
757 wake_up_process(task);
Greg Banksa7455442006-10-02 02:17:59 -0700758 }
759 /* destroy old threads */
760 while (nrservs < 0 &&
Jeff Layton9867d762008-06-10 08:40:38 -0400761 (task = choose_victim(serv, pool, &state)) != NULL) {
Jeff Laytona75c5d02008-06-10 08:40:39 -0400762 send_sig(SIGINT, task, 1);
Greg Banksa7455442006-10-02 02:17:59 -0700763 nrservs++;
764 }
765
766 return error;
767}
Trond Myklebust24c37672008-12-23 16:30:12 -0500768EXPORT_SYMBOL_GPL(svc_set_num_threads);
Greg Banksa7455442006-10-02 02:17:59 -0700769
770/*
Neil Brownbedbdd82008-06-10 08:40:35 -0400771 * Called from a server thread as it's exiting. Caller must hold the BKL or
772 * the "service mutex", whichever is appropriate for the service.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 */
774void
775svc_exit_thread(struct svc_rqst *rqstp)
776{
777 struct svc_serv *serv = rqstp->rq_server;
Greg Banks3262c812006-10-02 02:17:58 -0700778 struct svc_pool *pool = rqstp->rq_pool;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
780 svc_release_buffer(rqstp);
Jesper Juhla51482b2005-11-08 09:41:34 -0800781 kfree(rqstp->rq_resp);
782 kfree(rqstp->rq_argp);
783 kfree(rqstp->rq_auth_data);
Greg Banks3262c812006-10-02 02:17:58 -0700784
785 spin_lock_bh(&pool->sp_lock);
786 pool->sp_nrthreads--;
Jeff Layton81244382014-11-21 14:19:28 -0500787 if (!test_and_set_bit(RQ_VICTIM, &rqstp->rq_flags))
788 list_del_rcu(&rqstp->rq_all);
Greg Banks3262c812006-10-02 02:17:58 -0700789 spin_unlock_bh(&pool->sp_lock);
790
Jeff Layton81244382014-11-21 14:19:28 -0500791 kfree_rcu(rqstp, rq_rcu_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 /* Release the server */
794 if (serv)
795 svc_destroy(serv);
796}
Trond Myklebust24c37672008-12-23 16:30:12 -0500797EXPORT_SYMBOL_GPL(svc_exit_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
799/*
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500800 * Register an "inet" protocol family netid with the local
801 * rpcbind daemon via an rpcbind v4 SET request.
Chuck Levera26cfad2008-08-18 19:34:16 -0400802 *
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500803 * No netconfig infrastructure is available in the kernel, so
804 * we map IP_ protocol numbers to netids by hand.
Chuck Levera26cfad2008-08-18 19:34:16 -0400805 *
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500806 * Returns zero on success; a negative errno value is returned
807 * if any error occurs.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 */
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400809static int __svc_rpcb_register4(struct net *net, const u32 program,
810 const u32 version,
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500811 const unsigned short protocol,
812 const unsigned short port)
Chuck Levera26cfad2008-08-18 19:34:16 -0400813{
Chuck Levercadc0fa2009-03-18 20:47:36 -0400814 const struct sockaddr_in sin = {
Chuck Levera26cfad2008-08-18 19:34:16 -0400815 .sin_family = AF_INET,
816 .sin_addr.s_addr = htonl(INADDR_ANY),
817 .sin_port = htons(port),
818 };
Chuck Levercadc0fa2009-03-18 20:47:36 -0400819 const char *netid;
820 int error;
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500821
822 switch (protocol) {
823 case IPPROTO_UDP:
824 netid = RPCBIND_NETID_UDP;
825 break;
826 case IPPROTO_TCP:
827 netid = RPCBIND_NETID_TCP;
828 break;
829 default:
Chuck Leverba5c35e2009-03-18 20:46:59 -0400830 return -ENOPROTOOPT;
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500831 }
832
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400833 error = rpcb_v4_register(net, program, version,
Chuck Levercadc0fa2009-03-18 20:47:36 -0400834 (const struct sockaddr *)&sin, netid);
835
836 /*
837 * User space didn't support rpcbind v4, so retry this
838 * registration request with the legacy rpcbind v2 protocol.
839 */
840 if (error == -EPROTONOSUPPORT)
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400841 error = rpcb_register(net, program, version, protocol, port);
Chuck Levercadc0fa2009-03-18 20:47:36 -0400842
843 return error;
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500844}
845
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000846#if IS_ENABLED(CONFIG_IPV6)
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500847/*
848 * Register an "inet6" protocol family netid with the local
849 * rpcbind daemon via an rpcbind v4 SET request.
850 *
851 * No netconfig infrastructure is available in the kernel, so
852 * we map IP_ protocol numbers to netids by hand.
853 *
854 * Returns zero on success; a negative errno value is returned
855 * if any error occurs.
856 */
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400857static int __svc_rpcb_register6(struct net *net, const u32 program,
858 const u32 version,
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500859 const unsigned short protocol,
860 const unsigned short port)
861{
Chuck Levercadc0fa2009-03-18 20:47:36 -0400862 const struct sockaddr_in6 sin6 = {
Chuck Levera26cfad2008-08-18 19:34:16 -0400863 .sin6_family = AF_INET6,
864 .sin6_addr = IN6ADDR_ANY_INIT,
865 .sin6_port = htons(port),
866 };
Chuck Levercadc0fa2009-03-18 20:47:36 -0400867 const char *netid;
868 int error;
Chuck Levera26cfad2008-08-18 19:34:16 -0400869
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500870 switch (protocol) {
871 case IPPROTO_UDP:
872 netid = RPCBIND_NETID_UDP6;
873 break;
874 case IPPROTO_TCP:
875 netid = RPCBIND_NETID_TCP6;
876 break;
877 default:
Chuck Leverba5c35e2009-03-18 20:46:59 -0400878 return -ENOPROTOOPT;
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500879 }
880
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400881 error = rpcb_v4_register(net, program, version,
Chuck Levercadc0fa2009-03-18 20:47:36 -0400882 (const struct sockaddr *)&sin6, netid);
883
884 /*
885 * User space didn't support rpcbind version 4, so we won't
886 * use a PF_INET6 listener.
887 */
888 if (error == -EPROTONOSUPPORT)
889 error = -EAFNOSUPPORT;
890
891 return error;
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500892}
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000893#endif /* IS_ENABLED(CONFIG_IPV6) */
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500894
895/*
896 * Register a kernel RPC service via rpcbind version 4.
897 *
898 * Returns zero on success; a negative errno value is returned
899 * if any error occurs.
900 */
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400901static int __svc_register(struct net *net, const char *progname,
Chuck Lever363f7242009-03-18 20:47:44 -0400902 const u32 program, const u32 version,
Chuck Lever4b62e582009-03-18 20:46:06 -0400903 const int family,
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500904 const unsigned short protocol,
905 const unsigned short port)
906{
Chuck Lever363f7242009-03-18 20:47:44 -0400907 int error = -EAFNOSUPPORT;
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500908
Chuck Levera26cfad2008-08-18 19:34:16 -0400909 switch (family) {
Chuck Lever4b62e582009-03-18 20:46:06 -0400910 case PF_INET:
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400911 error = __svc_rpcb_register4(net, program, version,
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500912 protocol, port);
Chuck Levercadc0fa2009-03-18 20:47:36 -0400913 break;
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000914#if IS_ENABLED(CONFIG_IPV6)
Chuck Lever4b62e582009-03-18 20:46:06 -0400915 case PF_INET6:
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400916 error = __svc_rpcb_register6(net, program, version,
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500917 protocol, port);
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000918#endif
Chuck Levera26cfad2008-08-18 19:34:16 -0400919 }
920
Chuck Lever363f7242009-03-18 20:47:44 -0400921 return error;
Chuck Levera26cfad2008-08-18 19:34:16 -0400922}
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500923
Chuck Levera26cfad2008-08-18 19:34:16 -0400924/**
925 * svc_register - register an RPC service with the local portmapper
926 * @serv: svc_serv struct for the service to register
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400927 * @net: net namespace for the service to register
Chuck Lever4b62e582009-03-18 20:46:06 -0400928 * @family: protocol family of service's listener socket
Chuck Levera26cfad2008-08-18 19:34:16 -0400929 * @proto: transport protocol number to advertise
930 * @port: port to advertise
931 *
Chuck Lever4b62e582009-03-18 20:46:06 -0400932 * Service is registered for any address in the passed-in protocol family
Chuck Levera26cfad2008-08-18 19:34:16 -0400933 */
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400934int svc_register(const struct svc_serv *serv, struct net *net,
935 const int family, const unsigned short proto,
936 const unsigned short port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937{
938 struct svc_program *progp;
Kinglong Mee7e55b592013-12-31 13:17:20 +0800939 struct svc_version *vers;
Chuck Leverea339d42007-10-26 13:32:56 -0400940 unsigned int i;
Chuck Lever14aeb212008-08-18 19:34:00 -0400941 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
Weston Andros Adamson0af39502012-10-23 10:43:45 -0400943 WARN_ON_ONCE(proto == 0 && port == 0);
944 if (proto == 0 && port == 0)
945 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Olaf Kirchbc5fea42006-10-04 02:16:05 -0700947 for (progp = serv->sv_program; progp; progp = progp->pg_next) {
948 for (i = 0; i < progp->pg_nvers; i++) {
Kinglong Mee7e55b592013-12-31 13:17:20 +0800949 vers = progp->pg_vers[i];
950 if (vers == NULL)
Olaf Kirchbc5fea42006-10-04 02:16:05 -0700951 continue;
952
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500953 dprintk("svc: svc_register(%sv%d, %s, %u, %u)%s\n",
Olaf Kirchbc5fea42006-10-04 02:16:05 -0700954 progp->pg_name,
Chuck Lever2c7eb0b2008-09-15 16:27:23 -0500955 i,
Olaf Kirchbc5fea42006-10-04 02:16:05 -0700956 proto == IPPROTO_UDP? "udp" : "tcp",
957 port,
Chuck Lever4b62e582009-03-18 20:46:06 -0400958 family,
Kinglong Mee7e55b592013-12-31 13:17:20 +0800959 vers->vs_hidden ?
960 " (but not telling portmap)" : "");
Olaf Kirchbc5fea42006-10-04 02:16:05 -0700961
Kinglong Mee7e55b592013-12-31 13:17:20 +0800962 if (vers->vs_hidden)
Olaf Kirchbc5fea42006-10-04 02:16:05 -0700963 continue;
964
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400965 error = __svc_register(net, progp->pg_name, progp->pg_prog,
Chuck Lever363f7242009-03-18 20:47:44 -0400966 i, family, proto, port);
Kinglong Mee7e55b592013-12-31 13:17:20 +0800967
968 if (vers->vs_rpcb_optnl) {
969 error = 0;
970 continue;
971 }
972
973 if (error < 0) {
974 printk(KERN_WARNING "svc: failed to register "
975 "%sv%u RPC service (errno %d).\n",
976 progp->pg_name, i, -error);
Olaf Kirchbc5fea42006-10-04 02:16:05 -0700977 break;
Kinglong Mee7e55b592013-12-31 13:17:20 +0800978 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 }
980 }
981
Chuck Lever7252d572008-08-18 19:34:08 -0400982 return error;
983}
984
Chuck Leverd5a86202009-03-18 20:47:29 -0400985/*
986 * If user space is running rpcbind, it should take the v4 UNSET
987 * and clear everything for this [program, version]. If user space
988 * is running portmap, it will reject the v4 UNSET, but won't have
989 * any "inet6" entries anyway. So a PMAP_UNSET should be sufficient
990 * in this case to clear all existing entries for [program, version].
991 */
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400992static void __svc_unregister(struct net *net, const u32 program, const u32 version,
Chuck Leverf6fb3f62008-09-25 11:56:57 -0400993 const char *progname)
994{
995 int error;
996
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +0400997 error = rpcb_v4_register(net, program, version, NULL, "");
Chuck Leverd5a86202009-03-18 20:47:29 -0400998
999 /*
1000 * User space didn't support rpcbind v4, so retry this
1001 * request with the legacy rpcbind v2 protocol.
1002 */
1003 if (error == -EPROTONOSUPPORT)
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +04001004 error = rpcb_register(net, program, version, 0, 0);
Chuck Leverd5a86202009-03-18 20:47:29 -04001005
Chuck Leverf6fb3f62008-09-25 11:56:57 -04001006 dprintk("svc: %s(%sv%u), error %d\n",
1007 __func__, progname, version, error);
1008}
1009
Chuck Lever7252d572008-08-18 19:34:08 -04001010/*
Chuck Leverf6fb3f62008-09-25 11:56:57 -04001011 * All netids, bind addresses and ports registered for [program, version]
1012 * are removed from the local rpcbind database (if the service is not
1013 * hidden) to make way for a new instance of the service.
Chuck Lever7252d572008-08-18 19:34:08 -04001014 *
Chuck Leverf6fb3f62008-09-25 11:56:57 -04001015 * The result of unregistration is reported via dprintk for those who want
1016 * verification of the result, but is otherwise not important.
Chuck Lever7252d572008-08-18 19:34:08 -04001017 */
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +04001018static void svc_unregister(const struct svc_serv *serv, struct net *net)
Chuck Lever7252d572008-08-18 19:34:08 -04001019{
1020 struct svc_program *progp;
1021 unsigned long flags;
1022 unsigned int i;
Chuck Lever7252d572008-08-18 19:34:08 -04001023
1024 clear_thread_flag(TIF_SIGPENDING);
1025
1026 for (progp = serv->sv_program; progp; progp = progp->pg_next) {
1027 for (i = 0; i < progp->pg_nvers; i++) {
1028 if (progp->pg_vers[i] == NULL)
1029 continue;
1030 if (progp->pg_vers[i]->vs_hidden)
1031 continue;
1032
Chuck Lever7402ab192011-05-09 15:22:55 -04001033 dprintk("svc: attempting to unregister %sv%u\n",
1034 progp->pg_name, i);
Stanislav Kinsbursky5247fab2012-01-13 14:02:48 +04001035 __svc_unregister(net, progp->pg_prog, i, progp->pg_name);
Chuck Lever7252d572008-08-18 19:34:08 -04001036 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 }
1038
Chuck Lever7252d572008-08-18 19:34:08 -04001039 spin_lock_irqsave(&current->sighand->siglock, flags);
1040 recalc_sigpending();
1041 spin_unlock_irqrestore(&current->sighand->siglock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042}
1043
1044/*
J. Bruce Fields7032a3d2012-10-09 18:33:38 -04001045 * dprintk the given error with the address of the client that caused it.
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001046 */
Jeff Laytonf895b252014-11-17 16:58:04 -05001047#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
Joe Perchesb9075fa2011-10-31 17:11:33 -07001048static __printf(2, 3)
Joe Perchese87cc472012-05-13 21:56:26 +00001049void svc_printk(struct svc_rqst *rqstp, const char *fmt, ...)
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001050{
Joe Perchese87cc472012-05-13 21:56:26 +00001051 struct va_format vaf;
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001052 va_list args;
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001053 char buf[RPC_MAX_ADDRBUFLEN];
1054
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001055 va_start(args, fmt);
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001056
Joe Perchese87cc472012-05-13 21:56:26 +00001057 vaf.fmt = fmt;
1058 vaf.va = &args;
1059
J. Bruce Fields7032a3d2012-10-09 18:33:38 -04001060 dprintk("svc: %s: %pV", svc_print_addr(rqstp, buf, sizeof(buf)), &vaf);
Joe Perchese87cc472012-05-13 21:56:26 +00001061
1062 va_end(args);
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001063}
J. Bruce Fields624ab462013-01-08 16:22:15 -05001064#else
1065static __printf(2,3) void svc_printk(struct svc_rqst *rqstp, const char *fmt, ...) {}
1066#endif
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001067
1068/*
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001069 * Common routine for processing the RPC request.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 */
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001071static int
1072svc_process_common(struct svc_rqst *rqstp, struct kvec *argv, struct kvec *resv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073{
1074 struct svc_program *progp;
1075 struct svc_version *versp = NULL; /* compiler food */
1076 struct svc_procedure *procp = NULL;
NeilBrown6fb2b472006-10-02 02:17:50 -07001077 struct svc_serv *serv = rqstp->rq_server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 kxdrproc_t xdr;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001079 __be32 *statp;
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001080 u32 prog, vers, proc;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -07001081 __be32 auth_stat, rpc_stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 int auth_res;
J.Bruce Fields8f8e05c2006-10-04 02:16:08 -07001083 __be32 *reply_statp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
1085 rpc_stat = rpc_success;
1086
1087 if (argv->iov_len < 6*4)
1088 goto err_short_len;
1089
J. Bruce Fields5c04c462006-06-30 01:56:19 -07001090 /* Will be turned off only in gss privacy case: */
Jeff Layton779fb0f2014-11-19 07:51:18 -05001091 set_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
Andy Adamson2f425872009-04-03 08:27:32 +03001092 /* Will be turned off only when NFSv4 Sessions are used */
Jeff Layton30660e04b2014-11-19 07:51:16 -05001093 set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
Jeff Layton78b65eb2014-11-19 07:51:17 -05001094 clear_bit(RQ_DROPME, &rqstp->rq_flags);
Tom Tuckere831fe62007-12-30 21:07:29 -06001095
1096 /* Setup reply header */
1097 rqstp->rq_xprt->xpt_ops->xpo_prep_reply_hdr(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 svc_putu32(resv, rqstp->rq_xid);
1100
Alexey Dobriyan76994312006-09-26 22:28:46 -07001101 vers = svc_getnl(argv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
1103 /* First words of reply: */
Alexey Dobriyan76994312006-09-26 22:28:46 -07001104 svc_putnl(resv, 1); /* REPLY */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 if (vers != 2) /* RPC version number */
1107 goto err_bad_rpc;
1108
1109 /* Save position in case we later decide to reject: */
J.Bruce Fields8f8e05c2006-10-04 02:16:08 -07001110 reply_statp = resv->iov_base + resv->iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
Alexey Dobriyan76994312006-09-26 22:28:46 -07001112 svc_putnl(resv, 0); /* ACCEPT */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Alexey Dobriyan76994312006-09-26 22:28:46 -07001114 rqstp->rq_prog = prog = svc_getnl(argv); /* program number */
1115 rqstp->rq_vers = vers = svc_getnl(argv); /* version number */
1116 rqstp->rq_proc = proc = svc_getnl(argv); /* procedure number */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
NeilBrown80d188a2005-11-07 01:00:27 -08001118 for (progp = serv->sv_program; progp; progp = progp->pg_next)
1119 if (prog == progp->pg_prog)
1120 break;
1121
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 /*
1123 * Decode auth data, and add verifier to reply buffer.
1124 * We do this before anything else in order to get a decent
1125 * auth verifier.
1126 */
1127 auth_res = svc_authenticate(rqstp, &auth_stat);
1128 /* Also give the program a chance to reject this call: */
NeilBrown80d188a2005-11-07 01:00:27 -08001129 if (auth_res == SVC_OK && progp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 auth_stat = rpc_autherr_badcred;
1131 auth_res = progp->pg_authenticate(rqstp);
1132 }
1133 switch (auth_res) {
1134 case SVC_OK:
1135 break;
1136 case SVC_GARBAGE:
Harshula Jayasuriyadd352102008-02-20 10:56:56 +11001137 goto err_garbage;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 case SVC_SYSERR:
1139 rpc_stat = rpc_system_err;
1140 goto err_bad;
1141 case SVC_DENIED:
1142 goto err_bad_auth;
NeilBrown1ebede82010-08-12 17:04:07 +10001143 case SVC_CLOSE:
1144 if (test_bit(XPT_TEMP, &rqstp->rq_xprt->xpt_flags))
1145 svc_close_xprt(rqstp->rq_xprt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 case SVC_DROP:
1147 goto dropit;
1148 case SVC_COMPLETE:
1149 goto sendit;
1150 }
NeilBrown80d188a2005-11-07 01:00:27 -08001151
Andreas Gruenbacher9ba02632005-06-22 17:16:24 +00001152 if (progp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 goto err_bad_prog;
1154
1155 if (vers >= progp->pg_nvers ||
1156 !(versp = progp->pg_vers[vers]))
1157 goto err_bad_vers;
1158
1159 procp = versp->vs_proc + proc;
1160 if (proc >= versp->vs_nproc || !procp->pc_func)
1161 goto err_bad_proc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 rqstp->rq_procinfo = procp;
1163
1164 /* Syntactic check complete */
1165 serv->sv_stats->rpccnt++;
1166
1167 /* Build the reply header. */
1168 statp = resv->iov_base +resv->iov_len;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001169 svc_putnl(resv, RPC_SUCCESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170
1171 /* Bump per-procedure stats counter */
1172 procp->pc_count++;
1173
1174 /* Initialize storage for argp and resp */
1175 memset(rqstp->rq_argp, 0, procp->pc_argsize);
1176 memset(rqstp->rq_resp, 0, procp->pc_ressize);
1177
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001178 /* un-reserve some of the out-queue now that we have a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 * better idea of reply size
1180 */
1181 if (procp->pc_xdrressize)
Jeff Laytoncd123012007-05-09 02:34:50 -07001182 svc_reserve_auth(rqstp, procp->pc_xdrressize<<2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183
1184 /* Call the function that processes the request. */
1185 if (!versp->vs_dispatch) {
1186 /* Decode arguments */
1187 xdr = procp->pc_decode;
1188 if (xdr && !xdr(rqstp, argv->iov_base, rqstp->rq_argp))
1189 goto err_garbage;
1190
1191 *statp = procp->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
1192
1193 /* Encode reply */
Jeff Layton78b65eb2014-11-19 07:51:17 -05001194 if (test_bit(RQ_DROPME, &rqstp->rq_flags)) {
NeilBrownd343fce2006-10-17 00:10:18 -07001195 if (procp->pc_release)
1196 procp->pc_release(rqstp, NULL, rqstp->rq_resp);
1197 goto dropit;
1198 }
Joe Perchesf64f9e72009-11-29 16:55:45 -08001199 if (*statp == rpc_success &&
1200 (xdr = procp->pc_encode) &&
1201 !xdr(rqstp, resv->iov_base+resv->iov_len, rqstp->rq_resp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 dprintk("svc: failed to encode reply\n");
1203 /* serv->sv_stats->rpcsystemerr++; */
1204 *statp = rpc_system_err;
1205 }
1206 } else {
1207 dprintk("svc: calling dispatcher\n");
1208 if (!versp->vs_dispatch(rqstp, statp)) {
1209 /* Release reply info */
1210 if (procp->pc_release)
1211 procp->pc_release(rqstp, NULL, rqstp->rq_resp);
1212 goto dropit;
1213 }
1214 }
1215
1216 /* Check RPC status result */
1217 if (*statp != rpc_success)
1218 resv->iov_len = ((void*)statp) - resv->iov_base + 4;
1219
1220 /* Release reply info */
1221 if (procp->pc_release)
1222 procp->pc_release(rqstp, NULL, rqstp->rq_resp);
1223
1224 if (procp->pc_encode == NULL)
1225 goto dropit;
1226
1227 sendit:
1228 if (svc_authorise(rqstp))
1229 goto dropit;
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001230 return 1; /* Caller can now send it */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
1232 dropit:
1233 svc_authorise(rqstp); /* doesn't hurt to call this twice */
1234 dprintk("svc: svc_process dropit\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 return 0;
1236
1237err_short_len:
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001238 svc_printk(rqstp, "short len %Zd, dropping request\n",
1239 argv->iov_len);
NeilBrown34e9a632007-01-29 13:19:52 -08001240
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 goto dropit; /* drop request */
1242
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243err_bad_rpc:
1244 serv->sv_stats->rpcbadfmt++;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001245 svc_putnl(resv, 1); /* REJECT */
1246 svc_putnl(resv, 0); /* RPC_MISMATCH */
1247 svc_putnl(resv, 2); /* Only RPCv2 supported */
1248 svc_putnl(resv, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 goto sendit;
1250
1251err_bad_auth:
1252 dprintk("svc: authentication failed (%d)\n", ntohl(auth_stat));
1253 serv->sv_stats->rpcbadauth++;
1254 /* Restore write pointer to location of accept status: */
J.Bruce Fields8f8e05c2006-10-04 02:16:08 -07001255 xdr_ressize_check(rqstp, reply_statp);
Alexey Dobriyan76994312006-09-26 22:28:46 -07001256 svc_putnl(resv, 1); /* REJECT */
1257 svc_putnl(resv, 1); /* AUTH_ERROR */
1258 svc_putnl(resv, ntohl(auth_stat)); /* status */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 goto sendit;
1260
1261err_bad_prog:
Andreas Gruenbacher9ba02632005-06-22 17:16:24 +00001262 dprintk("svc: unknown program %d\n", prog);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 serv->sv_stats->rpcbadfmt++;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001264 svc_putnl(resv, RPC_PROG_UNAVAIL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 goto sendit;
1266
1267err_bad_vers:
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001268 svc_printk(rqstp, "unknown version (%d for prog %d, %s)\n",
NeilBrown34e9a632007-01-29 13:19:52 -08001269 vers, prog, progp->pg_name);
1270
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 serv->sv_stats->rpcbadfmt++;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001272 svc_putnl(resv, RPC_PROG_MISMATCH);
1273 svc_putnl(resv, progp->pg_lovers);
1274 svc_putnl(resv, progp->pg_hivers);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 goto sendit;
1276
1277err_bad_proc:
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001278 svc_printk(rqstp, "unknown procedure (%d)\n", proc);
NeilBrown34e9a632007-01-29 13:19:52 -08001279
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 serv->sv_stats->rpcbadfmt++;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001281 svc_putnl(resv, RPC_PROC_UNAVAIL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 goto sendit;
1283
1284err_garbage:
Dr. David Alan Gilbert354ecbb2007-08-25 16:09:27 +01001285 svc_printk(rqstp, "failed to decode args\n");
NeilBrown34e9a632007-01-29 13:19:52 -08001286
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 rpc_stat = rpc_garbage_args;
1288err_bad:
1289 serv->sv_stats->rpcbadfmt++;
Alexey Dobriyan76994312006-09-26 22:28:46 -07001290 svc_putnl(resv, ntohl(rpc_stat));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 goto sendit;
1292}
Trond Myklebust24c37672008-12-23 16:30:12 -05001293EXPORT_SYMBOL_GPL(svc_process);
Greg Banks7adae482006-10-04 02:15:47 -07001294
1295/*
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001296 * Process the RPC request.
1297 */
1298int
1299svc_process(struct svc_rqst *rqstp)
1300{
1301 struct kvec *argv = &rqstp->rq_arg.head[0];
1302 struct kvec *resv = &rqstp->rq_res.head[0];
1303 struct svc_serv *serv = rqstp->rq_server;
1304 u32 dir;
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001305
1306 /*
1307 * Setup response xdr_buf.
1308 * Initially it has just one page
1309 */
J. Bruce Fieldsafc59402012-12-10 18:01:37 -05001310 rqstp->rq_next_page = &rqstp->rq_respages[1];
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001311 resv->iov_base = page_address(rqstp->rq_respages[0]);
1312 resv->iov_len = 0;
1313 rqstp->rq_res.pages = rqstp->rq_respages + 1;
1314 rqstp->rq_res.len = 0;
1315 rqstp->rq_res.page_base = 0;
1316 rqstp->rq_res.page_len = 0;
1317 rqstp->rq_res.buflen = PAGE_SIZE;
1318 rqstp->rq_res.tail[0].iov_base = NULL;
1319 rqstp->rq_res.tail[0].iov_len = 0;
1320
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001321 dir = svc_getnl(argv);
1322 if (dir != 0) {
1323 /* direction != CALL */
1324 svc_printk(rqstp, "bad direction %d, dropping request\n", dir);
1325 serv->sv_stats->rpcbadfmt++;
Jeff Layton860a0d92014-10-28 14:24:12 -04001326 goto out_drop;
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001327 }
1328
Andy Adamson4b5b3ba2011-01-06 02:04:24 +00001329 /* Returns 1 for send, 0 for drop */
Jeff Layton860a0d92014-10-28 14:24:12 -04001330 if (likely(svc_process_common(rqstp, argv, resv))) {
1331 int ret = svc_send(rqstp);
1332
1333 trace_svc_process(rqstp, ret);
1334 return ret;
Andy Adamson4b5b3ba2011-01-06 02:04:24 +00001335 }
Jeff Layton860a0d92014-10-28 14:24:12 -04001336out_drop:
1337 trace_svc_process(rqstp, 0);
1338 svc_drop(rqstp);
1339 return 0;
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001340}
1341
Trond Myklebust9e00abc2011-07-13 19:20:49 -04001342#if defined(CONFIG_SUNRPC_BACKCHANNEL)
Ricardo Labiaga4d6bbb62009-04-01 09:23:07 -04001343/*
1344 * Process a backchannel RPC request that arrived over an existing
1345 * outbound connection
1346 */
1347int
1348bc_svc_process(struct svc_serv *serv, struct rpc_rqst *req,
1349 struct svc_rqst *rqstp)
1350{
1351 struct kvec *argv = &rqstp->rq_arg.head[0];
1352 struct kvec *resv = &rqstp->rq_res.head[0];
Ricardo Labiaga4d6bbb62009-04-01 09:23:07 -04001353
1354 /* Build the svc_rqst used by the common processing routine */
Andy Adamson4a19de02011-01-06 02:04:35 +00001355 rqstp->rq_xprt = serv->sv_bc_xprt;
Ricardo Labiaga4d6bbb62009-04-01 09:23:07 -04001356 rqstp->rq_xid = req->rq_xid;
1357 rqstp->rq_prot = req->rq_xprt->prot;
1358 rqstp->rq_server = serv;
1359
1360 rqstp->rq_addrlen = sizeof(req->rq_xprt->addr);
1361 memcpy(&rqstp->rq_addr, &req->rq_xprt->addr, rqstp->rq_addrlen);
1362 memcpy(&rqstp->rq_arg, &req->rq_rcv_buf, sizeof(rqstp->rq_arg));
1363 memcpy(&rqstp->rq_res, &req->rq_snd_buf, sizeof(rqstp->rq_res));
1364
1365 /* reset result send buffer "put" position */
1366 resv->iov_len = 0;
1367
1368 if (rqstp->rq_prot != IPPROTO_TCP) {
1369 printk(KERN_ERR "No support for Non-TCP transports!\n");
1370 BUG();
1371 }
1372
1373 /*
1374 * Skip the next two words because they've already been
1375 * processed in the trasport
1376 */
1377 svc_getu32(argv); /* XID */
1378 svc_getnl(argv); /* CALLDIR */
1379
Andy Adamson4b5b3ba2011-01-06 02:04:24 +00001380 /* Returns 1 for send, 0 for drop */
1381 if (svc_process_common(rqstp, argv, resv)) {
1382 memcpy(&req->rq_snd_buf, &rqstp->rq_res,
1383 sizeof(req->rq_snd_buf));
1384 return bc_send(req);
1385 } else {
Trond Myklebustb3b02ae2012-05-31 15:26:38 -04001386 /* drop request */
1387 xprt_free_bc_request(req);
Andy Adamson4b5b3ba2011-01-06 02:04:24 +00001388 return 0;
1389 }
Ricardo Labiaga4d6bbb62009-04-01 09:23:07 -04001390}
Trond Myklebust0d961aa2011-07-13 19:24:15 -04001391EXPORT_SYMBOL_GPL(bc_svc_process);
Trond Myklebust9e00abc2011-07-13 19:20:49 -04001392#endif /* CONFIG_SUNRPC_BACKCHANNEL */
Ricardo Labiaga4d6bbb62009-04-01 09:23:07 -04001393
Ricardo Labiaga1cad7ea2009-04-01 09:23:06 -04001394/*
Greg Banks7adae482006-10-04 02:15:47 -07001395 * Return (transport-specific) limit on the rpc payload.
1396 */
1397u32 svc_max_payload(const struct svc_rqst *rqstp)
1398{
Tom Tucker49023152007-12-30 21:07:21 -06001399 u32 max = rqstp->rq_xprt->xpt_class->xcl_max_payload;
Greg Banks7adae482006-10-04 02:15:47 -07001400
NeilBrownc6b0a9f2006-10-06 00:44:05 -07001401 if (rqstp->rq_server->sv_max_payload < max)
1402 max = rqstp->rq_server->sv_max_payload;
Greg Banks7adae482006-10-04 02:15:47 -07001403 return max;
1404}
1405EXPORT_SYMBOL_GPL(svc_max_payload);