blob: b8e47fac731557bdde5bc5d96250e30a822f6c6c [file] [log] [blame]
Tom Tucker1d8206b92007-12-30 21:07:15 -06001/*
2 * linux/net/sunrpc/svc_xprt.c
3 *
4 * Author: Tom Tucker <tom@opengridcomputing.com>
5 */
6
7#include <linux/sched.h>
8#include <linux/errno.h>
Tom Tucker1d8206b92007-12-30 21:07:15 -06009#include <linux/freezer.h>
Jeff Layton70867212008-02-07 16:34:54 -050010#include <linux/kthread.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090011#include <linux/slab.h>
Tom Tucker1d8206b92007-12-30 21:07:15 -060012#include <net/sock.h>
Tom Tucker1d8206b92007-12-30 21:07:15 -060013#include <linux/sunrpc/stats.h>
14#include <linux/sunrpc/svc_xprt.h>
H Hartley Sweetendcf1a352009-04-22 20:18:19 -040015#include <linux/sunrpc/svcsock.h>
J. Bruce Fields99de8ea2010-12-08 12:45:44 -050016#include <linux/sunrpc/xprt.h>
Paul Gortmaker3a9a2312011-05-27 09:12:25 -040017#include <linux/module.h>
Tom Tucker1d8206b92007-12-30 21:07:15 -060018
19#define RPCDBG_FACILITY RPCDBG_SVCXPRT
20
Tom Tucker0f0257e2007-12-30 21:08:27 -060021static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt);
22static int svc_deferred_recv(struct svc_rqst *rqstp);
23static struct cache_deferred_req *svc_defer(struct cache_req *req);
24static void svc_age_temp_xprts(unsigned long closure);
J. Bruce Fields7710ec32011-11-25 18:44:05 -050025static void svc_delete_xprt(struct svc_xprt *xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -060026
27/* apparently the "standard" is that clients close
28 * idle connections after 5 minutes, servers after
29 * 6 minutes
30 * http://www.connectathon.org/talks96/nfstcp.pdf
31 */
32static int svc_conn_age_period = 6*60;
33
Tom Tucker1d8206b92007-12-30 21:07:15 -060034/* List of registered transport classes */
35static DEFINE_SPINLOCK(svc_xprt_class_lock);
36static LIST_HEAD(svc_xprt_class_list);
37
Tom Tucker0f0257e2007-12-30 21:08:27 -060038/* SMP locking strategy:
39 *
40 * svc_pool->sp_lock protects most of the fields of that pool.
41 * svc_serv->sv_lock protects sv_tempsocks, sv_permsocks, sv_tmpcnt.
42 * when both need to be taken (rare), svc_serv->sv_lock is first.
43 * BKL protects svc_serv->sv_nrthread.
44 * svc_sock->sk_lock protects the svc_sock->sk_deferred list
45 * and the ->sk_info_authunix cache.
46 *
47 * The XPT_BUSY bit in xprt->xpt_flags prevents a transport being
48 * enqueued multiply. During normal transport processing this bit
49 * is set by svc_xprt_enqueue and cleared by svc_xprt_received.
50 * Providers should not manipulate this bit directly.
51 *
52 * Some flags can be set to certain values at any time
53 * providing that certain rules are followed:
54 *
55 * XPT_CONN, XPT_DATA:
56 * - Can be set or cleared at any time.
57 * - After a set, svc_xprt_enqueue must be called to enqueue
58 * the transport for processing.
59 * - After a clear, the transport must be read/accepted.
60 * If this succeeds, it must be set again.
61 * XPT_CLOSE:
62 * - Can set at any time. It is never cleared.
63 * XPT_DEAD:
64 * - Can only be set while XPT_BUSY is held which ensures
65 * that no other thread will be using the transport or will
66 * try to set XPT_DEAD.
67 */
68
Tom Tucker1d8206b92007-12-30 21:07:15 -060069int svc_reg_xprt_class(struct svc_xprt_class *xcl)
70{
71 struct svc_xprt_class *cl;
72 int res = -EEXIST;
73
74 dprintk("svc: Adding svc transport class '%s'\n", xcl->xcl_name);
75
76 INIT_LIST_HEAD(&xcl->xcl_list);
77 spin_lock(&svc_xprt_class_lock);
78 /* Make sure there isn't already a class with the same name */
79 list_for_each_entry(cl, &svc_xprt_class_list, xcl_list) {
80 if (strcmp(xcl->xcl_name, cl->xcl_name) == 0)
81 goto out;
82 }
83 list_add_tail(&xcl->xcl_list, &svc_xprt_class_list);
84 res = 0;
85out:
86 spin_unlock(&svc_xprt_class_lock);
87 return res;
88}
89EXPORT_SYMBOL_GPL(svc_reg_xprt_class);
90
91void svc_unreg_xprt_class(struct svc_xprt_class *xcl)
92{
93 dprintk("svc: Removing svc transport class '%s'\n", xcl->xcl_name);
94 spin_lock(&svc_xprt_class_lock);
95 list_del_init(&xcl->xcl_list);
96 spin_unlock(&svc_xprt_class_lock);
97}
98EXPORT_SYMBOL_GPL(svc_unreg_xprt_class);
99
Tom Tuckerdc9a16e2007-12-30 21:08:31 -0600100/*
101 * Format the transport list for printing
102 */
103int svc_print_xprts(char *buf, int maxlen)
104{
Pavel Emelyanov8f3a6de2010-10-05 23:30:19 +0400105 struct svc_xprt_class *xcl;
Tom Tuckerdc9a16e2007-12-30 21:08:31 -0600106 char tmpstr[80];
107 int len = 0;
108 buf[0] = '\0';
109
110 spin_lock(&svc_xprt_class_lock);
Pavel Emelyanov8f3a6de2010-10-05 23:30:19 +0400111 list_for_each_entry(xcl, &svc_xprt_class_list, xcl_list) {
Tom Tuckerdc9a16e2007-12-30 21:08:31 -0600112 int slen;
Tom Tuckerdc9a16e2007-12-30 21:08:31 -0600113
114 sprintf(tmpstr, "%s %d\n", xcl->xcl_name, xcl->xcl_max_payload);
115 slen = strlen(tmpstr);
116 if (len + slen > maxlen)
117 break;
118 len += slen;
119 strcat(buf, tmpstr);
120 }
121 spin_unlock(&svc_xprt_class_lock);
122
123 return len;
124}
125
Tom Tuckere1b31572007-12-30 21:07:46 -0600126static void svc_xprt_free(struct kref *kref)
127{
128 struct svc_xprt *xprt =
129 container_of(kref, struct svc_xprt, xpt_ref);
130 struct module *owner = xprt->xpt_class->xcl_owner;
Pavel Emelyanove3bfca02010-09-27 13:58:42 +0400131 if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags))
132 svcauth_unix_info_release(xprt);
Pavel Emelyanov4fb85182010-09-27 14:00:49 +0400133 put_net(xprt->xpt_net);
J. Bruce Fields99de8ea2010-12-08 12:45:44 -0500134 /* See comment on corresponding get in xs_setup_bc_tcp(): */
135 if (xprt->xpt_bc_xprt)
136 xprt_put(xprt->xpt_bc_xprt);
Tom Tuckere1b31572007-12-30 21:07:46 -0600137 xprt->xpt_ops->xpo_free(xprt);
138 module_put(owner);
139}
140
141void svc_xprt_put(struct svc_xprt *xprt)
142{
143 kref_put(&xprt->xpt_ref, svc_xprt_free);
144}
145EXPORT_SYMBOL_GPL(svc_xprt_put);
146
Tom Tucker1d8206b92007-12-30 21:07:15 -0600147/*
148 * Called by transport drivers to initialize the transport independent
149 * portion of the transport instance.
150 */
Stanislav Kinsburskybd4620d2011-12-06 14:19:10 +0300151void svc_xprt_init(struct net *net, struct svc_xprt_class *xcl,
152 struct svc_xprt *xprt, struct svc_serv *serv)
Tom Tucker1d8206b92007-12-30 21:07:15 -0600153{
154 memset(xprt, 0, sizeof(*xprt));
155 xprt->xpt_class = xcl;
156 xprt->xpt_ops = xcl->xcl_ops;
Tom Tuckere1b31572007-12-30 21:07:46 -0600157 kref_init(&xprt->xpt_ref);
Tom Tuckerbb5cf162007-12-30 21:07:50 -0600158 xprt->xpt_server = serv;
Tom Tucker7a182082007-12-30 21:07:53 -0600159 INIT_LIST_HEAD(&xprt->xpt_list);
160 INIT_LIST_HEAD(&xprt->xpt_ready);
Tom Tucker8c7b0172007-12-30 21:08:10 -0600161 INIT_LIST_HEAD(&xprt->xpt_deferred);
J. Bruce Fieldsedc7a892010-03-22 15:37:17 -0400162 INIT_LIST_HEAD(&xprt->xpt_users);
Tom Tuckera50fea22007-12-30 21:07:59 -0600163 mutex_init(&xprt->xpt_mutex);
Tom Tuckerdef13d72007-12-30 21:08:08 -0600164 spin_lock_init(&xprt->xpt_lock);
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600165 set_bit(XPT_BUSY, &xprt->xpt_flags);
Rahul Iyer4cfc7e62009-09-10 17:32:28 +0300166 rpc_init_wait_queue(&xprt->xpt_bc_pending, "xpt_bc_pending");
Stanislav Kinsburskybd4620d2011-12-06 14:19:10 +0300167 xprt->xpt_net = get_net(net);
Tom Tucker1d8206b92007-12-30 21:07:15 -0600168}
169EXPORT_SYMBOL_GPL(svc_xprt_init);
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600170
Chuck Lever5dd248f2008-06-30 18:45:37 -0400171static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
172 struct svc_serv *serv,
Pavel Emelyanov62832c02010-09-29 16:04:18 +0400173 struct net *net,
Chuck Lever9652ada2009-03-18 20:46:21 -0400174 const int family,
175 const unsigned short port,
176 int flags)
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600177{
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600178 struct sockaddr_in sin = {
179 .sin_family = AF_INET,
Al Viroe6f1ceb2008-03-17 22:44:53 -0700180 .sin_addr.s_addr = htonl(INADDR_ANY),
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600181 .sin_port = htons(port),
182 };
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000183#if IS_ENABLED(CONFIG_IPV6)
Chuck Lever5dd248f2008-06-30 18:45:37 -0400184 struct sockaddr_in6 sin6 = {
185 .sin6_family = AF_INET6,
186 .sin6_addr = IN6ADDR_ANY_INIT,
187 .sin6_port = htons(port),
188 };
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000189#endif
Chuck Lever5dd248f2008-06-30 18:45:37 -0400190 struct sockaddr *sap;
191 size_t len;
192
Chuck Lever9652ada2009-03-18 20:46:21 -0400193 switch (family) {
194 case PF_INET:
Chuck Lever5dd248f2008-06-30 18:45:37 -0400195 sap = (struct sockaddr *)&sin;
196 len = sizeof(sin);
197 break;
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000198#if IS_ENABLED(CONFIG_IPV6)
Chuck Lever9652ada2009-03-18 20:46:21 -0400199 case PF_INET6:
Chuck Lever5dd248f2008-06-30 18:45:37 -0400200 sap = (struct sockaddr *)&sin6;
201 len = sizeof(sin6);
202 break;
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000203#endif
Chuck Lever5dd248f2008-06-30 18:45:37 -0400204 default:
205 return ERR_PTR(-EAFNOSUPPORT);
206 }
207
Pavel Emelyanov62832c02010-09-29 16:04:18 +0400208 return xcl->xcl_ops->xpo_create(serv, net, sap, len, flags);
Chuck Lever5dd248f2008-06-30 18:45:37 -0400209}
210
J. Bruce Fields67410192012-08-17 22:12:19 -0400211/*
212 * svc_xprt_received conditionally queues the transport for processing
213 * by another thread. The caller must hold the XPT_BUSY bit and must
214 * not thereafter touch transport data.
215 *
216 * Note: XPT_DATA only gets cleared when a read-attempt finds no (or
217 * insufficient) data.
218 */
219static void svc_xprt_received(struct svc_xprt *xprt)
220{
Weston Andros Adamsonff1fdb92012-10-23 10:43:40 -0400221 WARN_ON_ONCE(!test_bit(XPT_BUSY, &xprt->xpt_flags));
222 if (!test_bit(XPT_BUSY, &xprt->xpt_flags))
223 return;
J. Bruce Fields67410192012-08-17 22:12:19 -0400224 /* As soon as we clear busy, the xprt could be closed and
225 * 'put', so we need a reference to call svc_xprt_enqueue with:
226 */
227 svc_xprt_get(xprt);
228 clear_bit(XPT_BUSY, &xprt->xpt_flags);
229 svc_xprt_enqueue(xprt);
230 svc_xprt_put(xprt);
231}
232
J. Bruce Fields39b55302012-08-14 15:50:34 -0400233void svc_add_new_perm_xprt(struct svc_serv *serv, struct svc_xprt *new)
234{
235 clear_bit(XPT_TEMP, &new->xpt_flags);
236 spin_lock_bh(&serv->sv_lock);
237 list_add(&new->xpt_list, &serv->sv_permsocks);
238 spin_unlock_bh(&serv->sv_lock);
239 svc_xprt_received(new);
240}
241
Chuck Lever9652ada2009-03-18 20:46:21 -0400242int svc_create_xprt(struct svc_serv *serv, const char *xprt_name,
Pavel Emelyanovfc5d00b2010-09-29 16:03:50 +0400243 struct net *net, const int family,
244 const unsigned short port, int flags)
Chuck Lever5dd248f2008-06-30 18:45:37 -0400245{
246 struct svc_xprt_class *xcl;
247
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600248 dprintk("svc: creating transport %s[%d]\n", xprt_name, port);
249 spin_lock(&svc_xprt_class_lock);
250 list_for_each_entry(xcl, &svc_xprt_class_list, xcl_list) {
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600251 struct svc_xprt *newxprt;
NeilBrowned2849d2010-11-16 16:55:19 +1100252 unsigned short newport;
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600253
254 if (strcmp(xprt_name, xcl->xcl_name))
255 continue;
256
257 if (!try_module_get(xcl->xcl_owner))
258 goto err;
259
260 spin_unlock(&svc_xprt_class_lock);
Pavel Emelyanov62832c02010-09-29 16:04:18 +0400261 newxprt = __svc_xpo_create(xcl, serv, net, family, port, flags);
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600262 if (IS_ERR(newxprt)) {
263 module_put(xcl->xcl_owner);
264 return PTR_ERR(newxprt);
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600265 }
J. Bruce Fields39b55302012-08-14 15:50:34 -0400266 svc_add_new_perm_xprt(serv, newxprt);
NeilBrowned2849d2010-11-16 16:55:19 +1100267 newport = svc_xprt_local_port(newxprt);
NeilBrowned2849d2010-11-16 16:55:19 +1100268 return newport;
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600269 }
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600270 err:
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600271 spin_unlock(&svc_xprt_class_lock);
272 dprintk("svc: transport %s not found\n", xprt_name);
Chuck Lever68717902010-01-26 14:04:13 -0500273
274 /* This errno is exposed to user space. Provide a reasonable
275 * perror msg for a bad transport. */
276 return -EPROTONOSUPPORT;
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600277}
278EXPORT_SYMBOL_GPL(svc_create_xprt);
Tom Tucker9dbc2402007-12-30 21:08:12 -0600279
280/*
281 * Copy the local and remote xprt addresses to the rqstp structure
282 */
283void svc_xprt_copy_addrs(struct svc_rqst *rqstp, struct svc_xprt *xprt)
284{
Tom Tucker9dbc2402007-12-30 21:08:12 -0600285 memcpy(&rqstp->rq_addr, &xprt->xpt_remote, xprt->xpt_remotelen);
286 rqstp->rq_addrlen = xprt->xpt_remotelen;
287
288 /*
289 * Destination address in request is needed for binding the
290 * source address in RPC replies/callbacks later.
291 */
Mi Jinlong849a1cf2011-08-30 17:18:41 +0800292 memcpy(&rqstp->rq_daddr, &xprt->xpt_local, xprt->xpt_locallen);
293 rqstp->rq_daddrlen = xprt->xpt_locallen;
Tom Tucker9dbc2402007-12-30 21:08:12 -0600294}
295EXPORT_SYMBOL_GPL(svc_xprt_copy_addrs);
296
Tom Tucker0f0257e2007-12-30 21:08:27 -0600297/**
298 * svc_print_addr - Format rq_addr field for printing
299 * @rqstp: svc_rqst struct containing address to print
300 * @buf: target buffer for formatted address
301 * @len: length of target buffer
302 *
303 */
304char *svc_print_addr(struct svc_rqst *rqstp, char *buf, size_t len)
305{
306 return __svc_print_addr(svc_addr(rqstp), buf, len);
307}
308EXPORT_SYMBOL_GPL(svc_print_addr);
309
310/*
311 * Queue up an idle server thread. Must have pool->sp_lock held.
312 * Note: this is really a stack rather than a queue, so that we only
313 * use as many different threads as we need, and the rest don't pollute
314 * the cache.
315 */
316static void svc_thread_enqueue(struct svc_pool *pool, struct svc_rqst *rqstp)
317{
318 list_add(&rqstp->rq_list, &pool->sp_threads);
319}
320
321/*
322 * Dequeue an nfsd thread. Must have pool->sp_lock held.
323 */
324static void svc_thread_dequeue(struct svc_pool *pool, struct svc_rqst *rqstp)
325{
326 list_del(&rqstp->rq_list);
327}
328
J. Bruce Fields9c335c02010-10-26 11:32:03 -0400329static bool svc_xprt_has_something_to_do(struct svc_xprt *xprt)
330{
331 if (xprt->xpt_flags & ((1<<XPT_CONN)|(1<<XPT_CLOSE)))
332 return true;
333 if (xprt->xpt_flags & ((1<<XPT_DATA)|(1<<XPT_DEFERRED)))
334 return xprt->xpt_ops->xpo_has_wspace(xprt);
335 return false;
336}
337
Tom Tucker0f0257e2007-12-30 21:08:27 -0600338/*
339 * Queue up a transport with data pending. If there are idle nfsd
340 * processes, wake 'em up.
341 *
342 */
343void svc_xprt_enqueue(struct svc_xprt *xprt)
344{
Tom Tucker0f0257e2007-12-30 21:08:27 -0600345 struct svc_pool *pool;
346 struct svc_rqst *rqstp;
347 int cpu;
348
J. Bruce Fields9c335c02010-10-26 11:32:03 -0400349 if (!svc_xprt_has_something_to_do(xprt))
Tom Tucker0f0257e2007-12-30 21:08:27 -0600350 return;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600351
352 cpu = get_cpu();
353 pool = svc_pool_for_cpu(xprt->xpt_server, cpu);
354 put_cpu();
355
356 spin_lock_bh(&pool->sp_lock);
357
J. Bruce Fields78c210e2009-08-06 15:41:34 -0400358 if (!list_empty(&pool->sp_threads) &&
359 !list_empty(&pool->sp_sockets))
360 printk(KERN_ERR
361 "svc_xprt_enqueue: "
362 "threads and transports both waiting??\n");
363
Greg Banks03cf6c92009-01-13 21:26:36 +1100364 pool->sp_stats.packets++;
365
Tom Tucker0f0257e2007-12-30 21:08:27 -0600366 /* Mark transport as busy. It will remain in this state until
367 * the provider calls svc_xprt_received. We update XPT_BUSY
368 * atomically because it also guards against trying to enqueue
369 * the transport twice.
370 */
371 if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags)) {
372 /* Don't enqueue transport while already enqueued */
373 dprintk("svc: transport %p busy, not enqueued\n", xprt);
374 goto out_unlock;
375 }
Tom Tucker0f0257e2007-12-30 21:08:27 -0600376
J. Bruce Fields78c210e2009-08-06 15:41:34 -0400377 if (!list_empty(&pool->sp_threads)) {
Tom Tucker0f0257e2007-12-30 21:08:27 -0600378 rqstp = list_entry(pool->sp_threads.next,
379 struct svc_rqst,
380 rq_list);
381 dprintk("svc: transport %p served by daemon %p\n",
382 xprt, rqstp);
383 svc_thread_dequeue(pool, rqstp);
384 if (rqstp->rq_xprt)
385 printk(KERN_ERR
386 "svc_xprt_enqueue: server %p, rq_xprt=%p!\n",
387 rqstp, rqstp->rq_xprt);
388 rqstp->rq_xprt = xprt;
389 svc_xprt_get(xprt);
Greg Banks03cf6c92009-01-13 21:26:36 +1100390 pool->sp_stats.threads_woken++;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600391 wake_up(&rqstp->rq_wait);
392 } else {
393 dprintk("svc: transport %p put into queue\n", xprt);
394 list_add_tail(&xprt->xpt_ready, &pool->sp_sockets);
Greg Banks03cf6c92009-01-13 21:26:36 +1100395 pool->sp_stats.sockets_queued++;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600396 }
397
398out_unlock:
399 spin_unlock_bh(&pool->sp_lock);
400}
401EXPORT_SYMBOL_GPL(svc_xprt_enqueue);
402
403/*
404 * Dequeue the first transport. Must be called with the pool->sp_lock held.
405 */
406static struct svc_xprt *svc_xprt_dequeue(struct svc_pool *pool)
407{
408 struct svc_xprt *xprt;
409
410 if (list_empty(&pool->sp_sockets))
411 return NULL;
412
413 xprt = list_entry(pool->sp_sockets.next,
414 struct svc_xprt, xpt_ready);
415 list_del_init(&xprt->xpt_ready);
416
417 dprintk("svc: transport %p dequeued, inuse=%d\n",
418 xprt, atomic_read(&xprt->xpt_ref.refcount));
419
420 return xprt;
421}
422
Tom Tucker0f0257e2007-12-30 21:08:27 -0600423/**
424 * svc_reserve - change the space reserved for the reply to a request.
425 * @rqstp: The request in question
426 * @space: new max space to reserve
427 *
428 * Each request reserves some space on the output queue of the transport
429 * to make sure the reply fits. This function reduces that reserved
430 * space to be the amount of space used already, plus @space.
431 *
432 */
433void svc_reserve(struct svc_rqst *rqstp, int space)
434{
435 space += rqstp->rq_res.head[0].iov_len;
436
437 if (space < rqstp->rq_reserved) {
438 struct svc_xprt *xprt = rqstp->rq_xprt;
439 atomic_sub((rqstp->rq_reserved - space), &xprt->xpt_reserved);
440 rqstp->rq_reserved = space;
441
442 svc_xprt_enqueue(xprt);
443 }
444}
Trond Myklebust24c37672008-12-23 16:30:12 -0500445EXPORT_SYMBOL_GPL(svc_reserve);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600446
447static void svc_xprt_release(struct svc_rqst *rqstp)
448{
449 struct svc_xprt *xprt = rqstp->rq_xprt;
450
451 rqstp->rq_xprt->xpt_ops->xpo_release_rqst(rqstp);
452
Tom Tucker2779e3a2009-01-05 11:12:52 -0600453 kfree(rqstp->rq_deferred);
454 rqstp->rq_deferred = NULL;
455
Tom Tucker0f0257e2007-12-30 21:08:27 -0600456 svc_free_res_pages(rqstp);
457 rqstp->rq_res.page_len = 0;
458 rqstp->rq_res.page_base = 0;
459
460 /* Reset response buffer and release
461 * the reservation.
462 * But first, check that enough space was reserved
463 * for the reply, otherwise we have a bug!
464 */
465 if ((rqstp->rq_res.len) > rqstp->rq_reserved)
466 printk(KERN_ERR "RPC request reserved %d but used %d\n",
467 rqstp->rq_reserved,
468 rqstp->rq_res.len);
469
470 rqstp->rq_res.head[0].iov_len = 0;
471 svc_reserve(rqstp, 0);
472 rqstp->rq_xprt = NULL;
473
474 svc_xprt_put(xprt);
475}
476
477/*
478 * External function to wake up a server waiting for data
479 * This really only makes sense for services like lockd
480 * which have exactly one thread anyway.
481 */
482void svc_wake_up(struct svc_serv *serv)
483{
484 struct svc_rqst *rqstp;
485 unsigned int i;
486 struct svc_pool *pool;
487
488 for (i = 0; i < serv->sv_nrpools; i++) {
489 pool = &serv->sv_pools[i];
490
491 spin_lock_bh(&pool->sp_lock);
492 if (!list_empty(&pool->sp_threads)) {
493 rqstp = list_entry(pool->sp_threads.next,
494 struct svc_rqst,
495 rq_list);
496 dprintk("svc: daemon %p woken up.\n", rqstp);
497 /*
498 svc_thread_dequeue(pool, rqstp);
499 rqstp->rq_xprt = NULL;
500 */
501 wake_up(&rqstp->rq_wait);
502 }
503 spin_unlock_bh(&pool->sp_lock);
504 }
505}
Trond Myklebust24c37672008-12-23 16:30:12 -0500506EXPORT_SYMBOL_GPL(svc_wake_up);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600507
508int svc_port_is_privileged(struct sockaddr *sin)
509{
510 switch (sin->sa_family) {
511 case AF_INET:
512 return ntohs(((struct sockaddr_in *)sin)->sin_port)
513 < PROT_SOCK;
514 case AF_INET6:
515 return ntohs(((struct sockaddr_in6 *)sin)->sin6_port)
516 < PROT_SOCK;
517 default:
518 return 0;
519 }
520}
521
522/*
Jeff Laytonc9233eb2008-10-20 11:51:57 -0400523 * Make sure that we don't have too many active connections. If we have,
524 * something must be dropped. It's not clear what will happen if we allow
525 * "too many" connections, but when dealing with network-facing software,
526 * we have to code defensively. Here we do that by imposing hard limits.
Tom Tucker0f0257e2007-12-30 21:08:27 -0600527 *
528 * There's no point in trying to do random drop here for DoS
529 * prevention. The NFS clients does 1 reconnect in 15 seconds. An
530 * attacker can easily beat that.
531 *
532 * The only somewhat efficient mechanism would be if drop old
533 * connections from the same IP first. But right now we don't even
534 * record the client IP in svc_sock.
Jeff Laytonc9233eb2008-10-20 11:51:57 -0400535 *
536 * single-threaded services that expect a lot of clients will probably
537 * need to set sv_maxconn to override the default value which is based
538 * on the number of threads
Tom Tucker0f0257e2007-12-30 21:08:27 -0600539 */
540static void svc_check_conn_limits(struct svc_serv *serv)
541{
Jeff Laytonc9233eb2008-10-20 11:51:57 -0400542 unsigned int limit = serv->sv_maxconn ? serv->sv_maxconn :
543 (serv->sv_nrthreads+3) * 20;
544
545 if (serv->sv_tmpcnt > limit) {
Tom Tucker0f0257e2007-12-30 21:08:27 -0600546 struct svc_xprt *xprt = NULL;
547 spin_lock_bh(&serv->sv_lock);
548 if (!list_empty(&serv->sv_tempsocks)) {
Joe Perchese87cc472012-05-13 21:56:26 +0000549 /* Try to help the admin */
550 net_notice_ratelimited("%s: too many open connections, consider increasing the %s\n",
551 serv->sv_name, serv->sv_maxconn ?
552 "max number of connections" :
553 "number of threads");
Tom Tucker0f0257e2007-12-30 21:08:27 -0600554 /*
555 * Always select the oldest connection. It's not fair,
556 * but so is life
557 */
558 xprt = list_entry(serv->sv_tempsocks.prev,
559 struct svc_xprt,
560 xpt_list);
561 set_bit(XPT_CLOSE, &xprt->xpt_flags);
562 svc_xprt_get(xprt);
563 }
564 spin_unlock_bh(&serv->sv_lock);
565
566 if (xprt) {
567 svc_xprt_enqueue(xprt);
568 svc_xprt_put(xprt);
569 }
570 }
571}
572
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400573int svc_alloc_arg(struct svc_rqst *rqstp)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600574{
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400575 struct svc_serv *serv = rqstp->rq_server;
576 struct xdr_buf *arg;
577 int pages;
578 int i;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600579
580 /* now allocate needed pages. If we get a failure, sleep briefly */
581 pages = (serv->sv_max_mesg + PAGE_SIZE) / PAGE_SIZE;
Weston Andros Adamsonb25cd052012-10-23 10:43:41 -0400582 WARN_ON_ONCE(pages >= RPCSVC_MAXPAGES);
583 if (pages >= RPCSVC_MAXPAGES)
584 /* use as many pages as possible */
585 pages = RPCSVC_MAXPAGES - 1;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600586 for (i = 0; i < pages ; i++)
587 while (rqstp->rq_pages[i] == NULL) {
588 struct page *p = alloc_page(GFP_KERNEL);
589 if (!p) {
Jeff Layton7b54fe62008-02-12 11:47:24 -0500590 set_current_state(TASK_INTERRUPTIBLE);
591 if (signalled() || kthread_should_stop()) {
592 set_current_state(TASK_RUNNING);
Jeff Layton70867212008-02-07 16:34:54 -0500593 return -EINTR;
Jeff Layton7b54fe62008-02-12 11:47:24 -0500594 }
595 schedule_timeout(msecs_to_jiffies(500));
Tom Tucker0f0257e2007-12-30 21:08:27 -0600596 }
597 rqstp->rq_pages[i] = p;
598 }
599 rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */
Tom Tucker0f0257e2007-12-30 21:08:27 -0600600
601 /* Make arg->head point to first page and arg->pages point to rest */
602 arg = &rqstp->rq_arg;
603 arg->head[0].iov_base = page_address(rqstp->rq_pages[0]);
604 arg->head[0].iov_len = PAGE_SIZE;
605 arg->pages = rqstp->rq_pages + 1;
606 arg->page_base = 0;
607 /* save at least one page for response */
608 arg->page_len = (pages-2)*PAGE_SIZE;
609 arg->len = (pages-1)*PAGE_SIZE;
610 arg->tail[0].iov_len = 0;
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400611 return 0;
612}
Tom Tucker0f0257e2007-12-30 21:08:27 -0600613
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400614struct svc_xprt *svc_get_next_xprt(struct svc_rqst *rqstp, long timeout)
615{
616 struct svc_xprt *xprt;
617 struct svc_pool *pool = rqstp->rq_pool;
618 DECLARE_WAITQUEUE(wait, current);
619 long time_left;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600620
NeilBrownf16b6e82010-08-12 17:04:06 +1000621 /* Normally we will wait up to 5 seconds for any required
622 * cache information to be provided.
623 */
624 rqstp->rq_chandle.thread_wait = 5*HZ;
625
Tom Tucker0f0257e2007-12-30 21:08:27 -0600626 spin_lock_bh(&pool->sp_lock);
627 xprt = svc_xprt_dequeue(pool);
628 if (xprt) {
629 rqstp->rq_xprt = xprt;
630 svc_xprt_get(xprt);
NeilBrownf16b6e82010-08-12 17:04:06 +1000631
632 /* As there is a shortage of threads and this request
J. Bruce Fields6610f722010-08-26 13:19:52 -0400633 * had to be queued, don't allow the thread to wait so
NeilBrownf16b6e82010-08-12 17:04:06 +1000634 * long for cache updates.
635 */
636 rqstp->rq_chandle.thread_wait = 1*HZ;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600637 } else {
638 /* No data pending. Go to sleep */
639 svc_thread_enqueue(pool, rqstp);
640
641 /*
642 * We have to be able to interrupt this wait
643 * to bring down the daemons ...
644 */
645 set_current_state(TASK_INTERRUPTIBLE);
Jeff Layton70867212008-02-07 16:34:54 -0500646
647 /*
648 * checking kthread_should_stop() here allows us to avoid
649 * locking and signalling when stopping kthreads that call
650 * svc_recv. If the thread has already been woken up, then
651 * we can exit here without sleeping. If not, then it
652 * it'll be woken up quickly during the schedule_timeout
653 */
654 if (kthread_should_stop()) {
655 set_current_state(TASK_RUNNING);
656 spin_unlock_bh(&pool->sp_lock);
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400657 return ERR_PTR(-EINTR);
Jeff Layton70867212008-02-07 16:34:54 -0500658 }
659
Tom Tucker0f0257e2007-12-30 21:08:27 -0600660 add_wait_queue(&rqstp->rq_wait, &wait);
661 spin_unlock_bh(&pool->sp_lock);
662
Greg Banks03cf6c92009-01-13 21:26:36 +1100663 time_left = schedule_timeout(timeout);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600664
665 try_to_freeze();
666
667 spin_lock_bh(&pool->sp_lock);
668 remove_wait_queue(&rqstp->rq_wait, &wait);
Greg Banks03cf6c92009-01-13 21:26:36 +1100669 if (!time_left)
670 pool->sp_stats.threads_timedout++;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600671
672 xprt = rqstp->rq_xprt;
673 if (!xprt) {
674 svc_thread_dequeue(pool, rqstp);
675 spin_unlock_bh(&pool->sp_lock);
676 dprintk("svc: server %p, no data yet\n", rqstp);
Jeff Layton70867212008-02-07 16:34:54 -0500677 if (signalled() || kthread_should_stop())
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400678 return ERR_PTR(-EINTR);
Jeff Layton70867212008-02-07 16:34:54 -0500679 else
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400680 return ERR_PTR(-EAGAIN);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600681 }
682 }
683 spin_unlock_bh(&pool->sp_lock);
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400684 return xprt;
685}
Tom Tucker0f0257e2007-12-30 21:08:27 -0600686
J. Bruce Fields65b2e662012-08-18 15:44:33 -0400687void svc_add_new_temp_xprt(struct svc_serv *serv, struct svc_xprt *newxpt)
688{
689 spin_lock_bh(&serv->sv_lock);
690 set_bit(XPT_TEMP, &newxpt->xpt_flags);
691 list_add(&newxpt->xpt_list, &serv->sv_tempsocks);
692 serv->sv_tmpcnt++;
693 if (serv->sv_temptimer.function == NULL) {
694 /* setup timer to age temp transports */
695 setup_timer(&serv->sv_temptimer, svc_age_temp_xprts,
696 (unsigned long)serv);
697 mod_timer(&serv->sv_temptimer,
698 jiffies + svc_conn_age_period * HZ);
699 }
700 spin_unlock_bh(&serv->sv_lock);
701 svc_xprt_received(newxpt);
702}
703
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400704static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
705{
706 struct svc_serv *serv = rqstp->rq_server;
707 int len = 0;
708
J. Bruce Fields1b644b62010-02-28 16:33:31 -0500709 if (test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
710 dprintk("svc_recv: found XPT_CLOSE\n");
711 svc_delete_xprt(xprt);
J. Bruce Fieldsca7896c2010-10-25 14:12:40 -0400712 /* Leave XPT_BUSY set on the dead xprt: */
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400713 return 0;
J. Bruce Fieldsca7896c2010-10-25 14:12:40 -0400714 }
715 if (test_bit(XPT_LISTENER, &xprt->xpt_flags)) {
Tom Tucker0f0257e2007-12-30 21:08:27 -0600716 struct svc_xprt *newxpt;
J. Bruce Fields65b2e662012-08-18 15:44:33 -0400717 /*
718 * We know this module_get will succeed because the
719 * listener holds a reference too
720 */
721 __module_get(xprt->xpt_class->xcl_owner);
722 svc_check_conn_limits(xprt->xpt_server);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600723 newxpt = xprt->xpt_ops->xpo_accept(xprt);
J. Bruce Fields65b2e662012-08-18 15:44:33 -0400724 if (newxpt)
725 svc_add_new_temp_xprt(serv, newxpt);
J. Bruce Fields9c335c02010-10-26 11:32:03 -0400726 } else if (xprt->xpt_ops->xpo_has_wspace(xprt)) {
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400727 /* XPT_DATA|XPT_DEFERRED case: */
Tom Tucker0f0257e2007-12-30 21:08:27 -0600728 dprintk("svc: server %p, pool %u, transport %p, inuse=%d\n",
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400729 rqstp, rqstp->rq_pool->sp_id, xprt,
Tom Tucker0f0257e2007-12-30 21:08:27 -0600730 atomic_read(&xprt->xpt_ref.refcount));
731 rqstp->rq_deferred = svc_deferred_dequeue(xprt);
J. Bruce Fieldsca7896c2010-10-25 14:12:40 -0400732 if (rqstp->rq_deferred)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600733 len = svc_deferred_recv(rqstp);
J. Bruce Fieldsca7896c2010-10-25 14:12:40 -0400734 else
Tom Tucker0f0257e2007-12-30 21:08:27 -0600735 len = xprt->xpt_ops->xpo_recvfrom(rqstp);
736 dprintk("svc: got len=%d\n", len);
J. Bruce Fieldsd10f27a2012-08-17 17:31:53 -0400737 rqstp->rq_reserved = serv->sv_max_mesg;
738 atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600739 }
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400740 /* clear XPT_BUSY: */
J. Bruce Fieldsca7896c2010-10-25 14:12:40 -0400741 svc_xprt_received(xprt);
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400742 return len;
743}
744
745/*
746 * Receive the next request on any transport. This code is carefully
747 * organised not to touch any cachelines in the shared svc_serv
748 * structure, only cachelines in the local svc_pool.
749 */
750int svc_recv(struct svc_rqst *rqstp, long timeout)
751{
752 struct svc_xprt *xprt = NULL;
753 struct svc_serv *serv = rqstp->rq_server;
754 int len, err;
755
756 dprintk("svc: server %p waiting for data (to = %ld)\n",
757 rqstp, timeout);
758
759 if (rqstp->rq_xprt)
760 printk(KERN_ERR
761 "svc_recv: service %p, transport not NULL!\n",
762 rqstp);
763 if (waitqueue_active(&rqstp->rq_wait))
764 printk(KERN_ERR
765 "svc_recv: service %p, wait queue active!\n",
766 rqstp);
767
768 err = svc_alloc_arg(rqstp);
769 if (err)
770 return err;
771
772 try_to_freeze();
773 cond_resched();
774 if (signalled() || kthread_should_stop())
775 return -EINTR;
776
777 xprt = svc_get_next_xprt(rqstp, timeout);
778 if (IS_ERR(xprt))
779 return PTR_ERR(xprt);
780
781 len = svc_handle_xprt(rqstp, xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600782
783 /* No data, incomplete (TCP) read, or accept() */
J. Bruce Fields9f9d2eb2012-08-17 21:35:24 -0400784 if (len <= 0)
J. Bruce Fieldsca7896c2010-10-25 14:12:40 -0400785 goto out;
786
Tom Tucker0f0257e2007-12-30 21:08:27 -0600787 clear_bit(XPT_OLD, &xprt->xpt_flags);
788
789 rqstp->rq_secure = svc_port_is_privileged(svc_addr(rqstp));
790 rqstp->rq_chandle.defer = svc_defer;
791
792 if (serv->sv_stats)
793 serv->sv_stats->netcnt++;
794 return len;
J. Bruce Fieldsca7896c2010-10-25 14:12:40 -0400795out:
796 rqstp->rq_res.len = 0;
797 svc_xprt_release(rqstp);
798 return -EAGAIN;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600799}
Trond Myklebust24c37672008-12-23 16:30:12 -0500800EXPORT_SYMBOL_GPL(svc_recv);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600801
802/*
803 * Drop request
804 */
805void svc_drop(struct svc_rqst *rqstp)
806{
807 dprintk("svc: xprt %p dropped request\n", rqstp->rq_xprt);
808 svc_xprt_release(rqstp);
809}
Trond Myklebust24c37672008-12-23 16:30:12 -0500810EXPORT_SYMBOL_GPL(svc_drop);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600811
812/*
813 * Return reply to client.
814 */
815int svc_send(struct svc_rqst *rqstp)
816{
817 struct svc_xprt *xprt;
818 int len;
819 struct xdr_buf *xb;
820
821 xprt = rqstp->rq_xprt;
822 if (!xprt)
823 return -EFAULT;
824
825 /* release the receive skb before sending the reply */
826 rqstp->rq_xprt->xpt_ops->xpo_release_rqst(rqstp);
827
828 /* calculate over-all length */
829 xb = &rqstp->rq_res;
830 xb->len = xb->head[0].iov_len +
831 xb->page_len +
832 xb->tail[0].iov_len;
833
834 /* Grab mutex to serialize outgoing data. */
835 mutex_lock(&xprt->xpt_mutex);
J. Bruce Fieldsf06f00a2012-08-20 16:04:40 -0400836 if (test_bit(XPT_DEAD, &xprt->xpt_flags)
837 || test_bit(XPT_CLOSE, &xprt->xpt_flags))
Tom Tucker0f0257e2007-12-30 21:08:27 -0600838 len = -ENOTCONN;
839 else
840 len = xprt->xpt_ops->xpo_sendto(rqstp);
841 mutex_unlock(&xprt->xpt_mutex);
Rahul Iyer4cfc7e62009-09-10 17:32:28 +0300842 rpc_wake_up(&xprt->xpt_bc_pending);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600843 svc_xprt_release(rqstp);
844
845 if (len == -ECONNREFUSED || len == -ENOTCONN || len == -EAGAIN)
846 return 0;
847 return len;
848}
849
850/*
851 * Timer function to close old temporary transports, using
852 * a mark-and-sweep algorithm.
853 */
854static void svc_age_temp_xprts(unsigned long closure)
855{
856 struct svc_serv *serv = (struct svc_serv *)closure;
857 struct svc_xprt *xprt;
858 struct list_head *le, *next;
859 LIST_HEAD(to_be_aged);
860
861 dprintk("svc_age_temp_xprts\n");
862
863 if (!spin_trylock_bh(&serv->sv_lock)) {
864 /* busy, try again 1 sec later */
865 dprintk("svc_age_temp_xprts: busy\n");
866 mod_timer(&serv->sv_temptimer, jiffies + HZ);
867 return;
868 }
869
870 list_for_each_safe(le, next, &serv->sv_tempsocks) {
871 xprt = list_entry(le, struct svc_xprt, xpt_list);
872
873 /* First time through, just mark it OLD. Second time
874 * through, close it. */
875 if (!test_and_set_bit(XPT_OLD, &xprt->xpt_flags))
876 continue;
Joe Perchesf64f9e72009-11-29 16:55:45 -0800877 if (atomic_read(&xprt->xpt_ref.refcount) > 1 ||
878 test_bit(XPT_BUSY, &xprt->xpt_flags))
Tom Tucker0f0257e2007-12-30 21:08:27 -0600879 continue;
880 svc_xprt_get(xprt);
881 list_move(le, &to_be_aged);
882 set_bit(XPT_CLOSE, &xprt->xpt_flags);
883 set_bit(XPT_DETACHED, &xprt->xpt_flags);
884 }
885 spin_unlock_bh(&serv->sv_lock);
886
887 while (!list_empty(&to_be_aged)) {
888 le = to_be_aged.next;
889 /* fiddling the xpt_list node is safe 'cos we're XPT_DETACHED */
890 list_del_init(le);
891 xprt = list_entry(le, struct svc_xprt, xpt_list);
892
893 dprintk("queuing xprt %p for closing\n", xprt);
894
895 /* a thread will dequeue and close it soon */
896 svc_xprt_enqueue(xprt);
897 svc_xprt_put(xprt);
898 }
899
900 mod_timer(&serv->sv_temptimer, jiffies + svc_conn_age_period * HZ);
901}
902
J. Bruce Fieldsedc7a892010-03-22 15:37:17 -0400903static void call_xpt_users(struct svc_xprt *xprt)
904{
905 struct svc_xpt_user *u;
906
907 spin_lock(&xprt->xpt_lock);
908 while (!list_empty(&xprt->xpt_users)) {
909 u = list_first_entry(&xprt->xpt_users, struct svc_xpt_user, list);
910 list_del(&u->list);
911 u->callback(u);
912 }
913 spin_unlock(&xprt->xpt_lock);
914}
915
Tom Tucker0f0257e2007-12-30 21:08:27 -0600916/*
917 * Remove a dead transport
918 */
J. Bruce Fields7710ec32011-11-25 18:44:05 -0500919static void svc_delete_xprt(struct svc_xprt *xprt)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600920{
921 struct svc_serv *serv = xprt->xpt_server;
Tom Tucker22945e42009-01-05 15:21:19 -0600922 struct svc_deferred_req *dr;
923
924 /* Only do this once */
925 if (test_and_set_bit(XPT_DEAD, &xprt->xpt_flags))
J. Bruce Fieldsac9303e2010-10-23 11:16:10 -0400926 BUG();
Tom Tucker0f0257e2007-12-30 21:08:27 -0600927
928 dprintk("svc: svc_delete_xprt(%p)\n", xprt);
929 xprt->xpt_ops->xpo_detach(xprt);
930
931 spin_lock_bh(&serv->sv_lock);
932 if (!test_and_set_bit(XPT_DETACHED, &xprt->xpt_flags))
933 list_del_init(&xprt->xpt_list);
Weston Andros Adamson01047292012-10-23 10:43:48 -0400934 WARN_ON_ONCE(!list_empty(&xprt->xpt_ready));
Tom Tucker22945e42009-01-05 15:21:19 -0600935 if (test_bit(XPT_TEMP, &xprt->xpt_flags))
936 serv->sv_tmpcnt--;
J. Bruce Fields788e69e2010-03-29 21:02:31 -0400937 spin_unlock_bh(&serv->sv_lock);
Tom Tucker22945e42009-01-05 15:21:19 -0600938
Neil Brownab1b18f2010-02-27 09:33:40 +1100939 while ((dr = svc_deferred_dequeue(xprt)) != NULL)
Tom Tucker22945e42009-01-05 15:21:19 -0600940 kfree(dr);
Tom Tucker22945e42009-01-05 15:21:19 -0600941
J. Bruce Fieldsedc7a892010-03-22 15:37:17 -0400942 call_xpt_users(xprt);
Tom Tucker22945e42009-01-05 15:21:19 -0600943 svc_xprt_put(xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600944}
945
946void svc_close_xprt(struct svc_xprt *xprt)
947{
948 set_bit(XPT_CLOSE, &xprt->xpt_flags);
949 if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
950 /* someone else will have to effect the close */
951 return;
J. Bruce Fieldsb1763312010-10-25 20:24:48 -0400952 /*
953 * We expect svc_close_xprt() to work even when no threads are
954 * running (e.g., while configuring the server before starting
955 * any threads), so if the transport isn't busy, we delete
956 * it ourself:
957 */
Tom Tucker0f0257e2007-12-30 21:08:27 -0600958 svc_delete_xprt(xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600959}
Tom Tuckera2178132007-12-30 21:08:35 -0600960EXPORT_SYMBOL_GPL(svc_close_xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600961
J. Bruce Fields719f8bc2012-08-13 17:03:00 -0400962static void svc_close_list(struct svc_serv *serv, struct list_head *xprt_list, struct net *net)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600963{
964 struct svc_xprt *xprt;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600965
J. Bruce Fields719f8bc2012-08-13 17:03:00 -0400966 spin_lock(&serv->sv_lock);
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -0500967 list_for_each_entry(xprt, xprt_list, xpt_list) {
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +0400968 if (xprt->xpt_net != net)
969 continue;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600970 set_bit(XPT_CLOSE, &xprt->xpt_flags);
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -0500971 set_bit(XPT_BUSY, &xprt->xpt_flags);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600972 }
J. Bruce Fields719f8bc2012-08-13 17:03:00 -0400973 spin_unlock(&serv->sv_lock);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600974}
975
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +0400976static void svc_clear_pools(struct svc_serv *serv, struct net *net)
J. Bruce Fields2fefb8a2011-11-29 11:35:35 -0500977{
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -0500978 struct svc_pool *pool;
979 struct svc_xprt *xprt;
980 struct svc_xprt *tmp;
981 int i;
982
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -0500983 for (i = 0; i < serv->sv_nrpools; i++) {
984 pool = &serv->sv_pools[i];
985
986 spin_lock_bh(&pool->sp_lock);
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +0400987 list_for_each_entry_safe(xprt, tmp, &pool->sp_sockets, xpt_ready) {
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +0400988 if (xprt->xpt_net != net)
989 continue;
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -0500990 list_del_init(&xprt->xpt_ready);
991 }
992 spin_unlock_bh(&pool->sp_lock);
993 }
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +0400994}
995
J. Bruce Fields719f8bc2012-08-13 17:03:00 -0400996static void svc_clear_list(struct svc_serv *serv, struct list_head *xprt_list, struct net *net)
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +0400997{
998 struct svc_xprt *xprt;
999 struct svc_xprt *tmp;
J. Bruce Fields719f8bc2012-08-13 17:03:00 -04001000 LIST_HEAD(victims);
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +04001001
J. Bruce Fields719f8bc2012-08-13 17:03:00 -04001002 spin_lock(&serv->sv_lock);
Stanislav Kinsbursky3a22bf52012-01-31 14:09:08 +04001003 list_for_each_entry_safe(xprt, tmp, xprt_list, xpt_list) {
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +04001004 if (xprt->xpt_net != net)
1005 continue;
J. Bruce Fields719f8bc2012-08-13 17:03:00 -04001006 list_move(&xprt->xpt_list, &victims);
Stanislav Kinsbursky3a22bf52012-01-31 14:09:08 +04001007 }
J. Bruce Fields719f8bc2012-08-13 17:03:00 -04001008 spin_unlock(&serv->sv_lock);
1009
1010 list_for_each_entry_safe(xprt, tmp, &victims, xpt_list)
1011 svc_delete_xprt(xprt);
Stanislav Kinsbursky3a22bf52012-01-31 14:09:08 +04001012}
1013
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +04001014void svc_close_net(struct svc_serv *serv, struct net *net)
Stanislav Kinsbursky3a22bf52012-01-31 14:09:08 +04001015{
J. Bruce Fields719f8bc2012-08-13 17:03:00 -04001016 svc_close_list(serv, &serv->sv_tempsocks, net);
1017 svc_close_list(serv, &serv->sv_permsocks, net);
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +04001018
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +04001019 svc_clear_pools(serv, net);
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -05001020 /*
1021 * At this point the sp_sockets lists will stay empty, since
J. Bruce Fields3ddbe872012-05-16 17:14:14 -04001022 * svc_xprt_enqueue will not add new entries without taking the
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -05001023 * sp_lock and checking XPT_BUSY.
1024 */
J. Bruce Fields719f8bc2012-08-13 17:03:00 -04001025 svc_clear_list(serv, &serv->sv_tempsocks, net);
1026 svc_clear_list(serv, &serv->sv_permsocks, net);
J. Bruce Fields2fefb8a2011-11-29 11:35:35 -05001027}
1028
Tom Tucker0f0257e2007-12-30 21:08:27 -06001029/*
1030 * Handle defer and revisit of requests
1031 */
1032
1033static void svc_revisit(struct cache_deferred_req *dreq, int too_many)
1034{
1035 struct svc_deferred_req *dr =
1036 container_of(dreq, struct svc_deferred_req, handle);
1037 struct svc_xprt *xprt = dr->xprt;
1038
Tom Tucker22945e42009-01-05 15:21:19 -06001039 spin_lock(&xprt->xpt_lock);
1040 set_bit(XPT_DEFERRED, &xprt->xpt_flags);
1041 if (too_many || test_bit(XPT_DEAD, &xprt->xpt_flags)) {
1042 spin_unlock(&xprt->xpt_lock);
1043 dprintk("revisit canceled\n");
Tom Tucker0f0257e2007-12-30 21:08:27 -06001044 svc_xprt_put(xprt);
1045 kfree(dr);
1046 return;
1047 }
1048 dprintk("revisit queued\n");
1049 dr->xprt = NULL;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001050 list_add(&dr->handle.recent, &xprt->xpt_deferred);
1051 spin_unlock(&xprt->xpt_lock);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001052 svc_xprt_enqueue(xprt);
1053 svc_xprt_put(xprt);
1054}
1055
Tom Tucker260c1d12007-12-30 21:08:29 -06001056/*
1057 * Save the request off for later processing. The request buffer looks
1058 * like this:
1059 *
1060 * <xprt-header><rpc-header><rpc-pagelist><rpc-tail>
1061 *
1062 * This code can only handle requests that consist of an xprt-header
1063 * and rpc-header.
1064 */
Tom Tucker0f0257e2007-12-30 21:08:27 -06001065static struct cache_deferred_req *svc_defer(struct cache_req *req)
1066{
1067 struct svc_rqst *rqstp = container_of(req, struct svc_rqst, rq_chandle);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001068 struct svc_deferred_req *dr;
1069
Andy Adamson2f425872009-04-03 08:27:32 +03001070 if (rqstp->rq_arg.page_len || !rqstp->rq_usedeferral)
Tom Tucker0f0257e2007-12-30 21:08:27 -06001071 return NULL; /* if more than a page, give up FIXME */
1072 if (rqstp->rq_deferred) {
1073 dr = rqstp->rq_deferred;
1074 rqstp->rq_deferred = NULL;
1075 } else {
Tom Tucker260c1d12007-12-30 21:08:29 -06001076 size_t skip;
1077 size_t size;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001078 /* FIXME maybe discard if size too large */
Tom Tucker260c1d12007-12-30 21:08:29 -06001079 size = sizeof(struct svc_deferred_req) + rqstp->rq_arg.len;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001080 dr = kmalloc(size, GFP_KERNEL);
1081 if (dr == NULL)
1082 return NULL;
1083
1084 dr->handle.owner = rqstp->rq_server;
1085 dr->prot = rqstp->rq_prot;
1086 memcpy(&dr->addr, &rqstp->rq_addr, rqstp->rq_addrlen);
1087 dr->addrlen = rqstp->rq_addrlen;
1088 dr->daddr = rqstp->rq_daddr;
1089 dr->argslen = rqstp->rq_arg.len >> 2;
Tom Tucker260c1d12007-12-30 21:08:29 -06001090 dr->xprt_hlen = rqstp->rq_xprt_hlen;
1091
1092 /* back up head to the start of the buffer and copy */
1093 skip = rqstp->rq_arg.len - rqstp->rq_arg.head[0].iov_len;
1094 memcpy(dr->args, rqstp->rq_arg.head[0].iov_base - skip,
1095 dr->argslen << 2);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001096 }
1097 svc_xprt_get(rqstp->rq_xprt);
1098 dr->xprt = rqstp->rq_xprt;
J. Bruce Fields9e701c62011-01-02 21:56:36 -05001099 rqstp->rq_dropme = true;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001100
1101 dr->handle.revisit = svc_revisit;
1102 return &dr->handle;
1103}
1104
1105/*
1106 * recv data from a deferred request into an active one
1107 */
1108static int svc_deferred_recv(struct svc_rqst *rqstp)
1109{
1110 struct svc_deferred_req *dr = rqstp->rq_deferred;
1111
Tom Tucker260c1d12007-12-30 21:08:29 -06001112 /* setup iov_base past transport header */
1113 rqstp->rq_arg.head[0].iov_base = dr->args + (dr->xprt_hlen>>2);
1114 /* The iov_len does not include the transport header bytes */
1115 rqstp->rq_arg.head[0].iov_len = (dr->argslen<<2) - dr->xprt_hlen;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001116 rqstp->rq_arg.page_len = 0;
Tom Tucker260c1d12007-12-30 21:08:29 -06001117 /* The rq_arg.len includes the transport header bytes */
1118 rqstp->rq_arg.len = dr->argslen<<2;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001119 rqstp->rq_prot = dr->prot;
1120 memcpy(&rqstp->rq_addr, &dr->addr, dr->addrlen);
1121 rqstp->rq_addrlen = dr->addrlen;
Tom Tucker260c1d12007-12-30 21:08:29 -06001122 /* Save off transport header len in case we get deferred again */
1123 rqstp->rq_xprt_hlen = dr->xprt_hlen;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001124 rqstp->rq_daddr = dr->daddr;
1125 rqstp->rq_respages = rqstp->rq_pages;
Tom Tucker260c1d12007-12-30 21:08:29 -06001126 return (dr->argslen<<2) - dr->xprt_hlen;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001127}
1128
1129
1130static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt)
1131{
1132 struct svc_deferred_req *dr = NULL;
1133
1134 if (!test_bit(XPT_DEFERRED, &xprt->xpt_flags))
1135 return NULL;
1136 spin_lock(&xprt->xpt_lock);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001137 if (!list_empty(&xprt->xpt_deferred)) {
1138 dr = list_entry(xprt->xpt_deferred.next,
1139 struct svc_deferred_req,
1140 handle.recent);
1141 list_del_init(&dr->handle.recent);
J. Bruce Fields62bac4a2010-10-25 12:50:15 -04001142 } else
1143 clear_bit(XPT_DEFERRED, &xprt->xpt_flags);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001144 spin_unlock(&xprt->xpt_lock);
1145 return dr;
1146}
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001147
Chuck Lever156e6202009-03-18 20:45:58 -04001148/**
1149 * svc_find_xprt - find an RPC transport instance
1150 * @serv: pointer to svc_serv to search
1151 * @xcl_name: C string containing transport's class name
Stanislav Kinsbursky4cb54ca2012-01-20 16:50:53 +04001152 * @net: owner net pointer
Chuck Lever156e6202009-03-18 20:45:58 -04001153 * @af: Address family of transport's local address
1154 * @port: transport's IP port number
1155 *
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001156 * Return the transport instance pointer for the endpoint accepting
1157 * connections/peer traffic from the specified transport class,
1158 * address family and port.
1159 *
1160 * Specifying 0 for the address family or port is effectively a
1161 * wild-card, and will result in matching the first transport in the
1162 * service's list that has a matching class name.
1163 */
Chuck Lever156e6202009-03-18 20:45:58 -04001164struct svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name,
Stanislav Kinsbursky4cb54ca2012-01-20 16:50:53 +04001165 struct net *net, const sa_family_t af,
1166 const unsigned short port)
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001167{
1168 struct svc_xprt *xprt;
1169 struct svc_xprt *found = NULL;
1170
1171 /* Sanity check the args */
Chuck Lever156e6202009-03-18 20:45:58 -04001172 if (serv == NULL || xcl_name == NULL)
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001173 return found;
1174
1175 spin_lock_bh(&serv->sv_lock);
1176 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
Stanislav Kinsbursky4cb54ca2012-01-20 16:50:53 +04001177 if (xprt->xpt_net != net)
1178 continue;
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001179 if (strcmp(xprt->xpt_class->xcl_name, xcl_name))
1180 continue;
1181 if (af != AF_UNSPEC && af != xprt->xpt_local.ss_family)
1182 continue;
Chuck Lever156e6202009-03-18 20:45:58 -04001183 if (port != 0 && port != svc_xprt_local_port(xprt))
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001184 continue;
1185 found = xprt;
Tom Tuckera2178132007-12-30 21:08:35 -06001186 svc_xprt_get(xprt);
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001187 break;
1188 }
1189 spin_unlock_bh(&serv->sv_lock);
1190 return found;
1191}
1192EXPORT_SYMBOL_GPL(svc_find_xprt);
Tom Tucker9571af12007-12-30 21:08:37 -06001193
Chuck Lever335c54b2009-04-23 19:32:25 -04001194static int svc_one_xprt_name(const struct svc_xprt *xprt,
1195 char *pos, int remaining)
1196{
1197 int len;
1198
1199 len = snprintf(pos, remaining, "%s %u\n",
1200 xprt->xpt_class->xcl_name,
1201 svc_xprt_local_port(xprt));
1202 if (len >= remaining)
1203 return -ENAMETOOLONG;
1204 return len;
1205}
1206
1207/**
1208 * svc_xprt_names - format a buffer with a list of transport names
1209 * @serv: pointer to an RPC service
1210 * @buf: pointer to a buffer to be filled in
1211 * @buflen: length of buffer to be filled in
1212 *
1213 * Fills in @buf with a string containing a list of transport names,
1214 * each name terminated with '\n'.
1215 *
1216 * Returns positive length of the filled-in string on success; otherwise
1217 * a negative errno value is returned if an error occurs.
Tom Tucker9571af12007-12-30 21:08:37 -06001218 */
Chuck Lever335c54b2009-04-23 19:32:25 -04001219int svc_xprt_names(struct svc_serv *serv, char *buf, const int buflen)
Tom Tucker9571af12007-12-30 21:08:37 -06001220{
1221 struct svc_xprt *xprt;
Chuck Lever335c54b2009-04-23 19:32:25 -04001222 int len, totlen;
1223 char *pos;
Tom Tucker9571af12007-12-30 21:08:37 -06001224
1225 /* Sanity check args */
1226 if (!serv)
1227 return 0;
1228
1229 spin_lock_bh(&serv->sv_lock);
Chuck Lever335c54b2009-04-23 19:32:25 -04001230
1231 pos = buf;
1232 totlen = 0;
Tom Tucker9571af12007-12-30 21:08:37 -06001233 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
Chuck Lever335c54b2009-04-23 19:32:25 -04001234 len = svc_one_xprt_name(xprt, pos, buflen - totlen);
1235 if (len < 0) {
1236 *buf = '\0';
1237 totlen = len;
1238 }
1239 if (len <= 0)
Tom Tucker9571af12007-12-30 21:08:37 -06001240 break;
Chuck Lever335c54b2009-04-23 19:32:25 -04001241
1242 pos += len;
Tom Tucker9571af12007-12-30 21:08:37 -06001243 totlen += len;
1244 }
Chuck Lever335c54b2009-04-23 19:32:25 -04001245
Tom Tucker9571af12007-12-30 21:08:37 -06001246 spin_unlock_bh(&serv->sv_lock);
1247 return totlen;
1248}
1249EXPORT_SYMBOL_GPL(svc_xprt_names);
Greg Banks03cf6c92009-01-13 21:26:36 +11001250
1251
1252/*----------------------------------------------------------------------------*/
1253
1254static void *svc_pool_stats_start(struct seq_file *m, loff_t *pos)
1255{
1256 unsigned int pidx = (unsigned int)*pos;
1257 struct svc_serv *serv = m->private;
1258
1259 dprintk("svc_pool_stats_start, *pidx=%u\n", pidx);
1260
Greg Banks03cf6c92009-01-13 21:26:36 +11001261 if (!pidx)
1262 return SEQ_START_TOKEN;
1263 return (pidx > serv->sv_nrpools ? NULL : &serv->sv_pools[pidx-1]);
1264}
1265
1266static void *svc_pool_stats_next(struct seq_file *m, void *p, loff_t *pos)
1267{
1268 struct svc_pool *pool = p;
1269 struct svc_serv *serv = m->private;
1270
1271 dprintk("svc_pool_stats_next, *pos=%llu\n", *pos);
1272
1273 if (p == SEQ_START_TOKEN) {
1274 pool = &serv->sv_pools[0];
1275 } else {
1276 unsigned int pidx = (pool - &serv->sv_pools[0]);
1277 if (pidx < serv->sv_nrpools-1)
1278 pool = &serv->sv_pools[pidx+1];
1279 else
1280 pool = NULL;
1281 }
1282 ++*pos;
1283 return pool;
1284}
1285
1286static void svc_pool_stats_stop(struct seq_file *m, void *p)
1287{
Greg Banks03cf6c92009-01-13 21:26:36 +11001288}
1289
1290static int svc_pool_stats_show(struct seq_file *m, void *p)
1291{
1292 struct svc_pool *pool = p;
1293
1294 if (p == SEQ_START_TOKEN) {
J. Bruce Fields78c210e2009-08-06 15:41:34 -04001295 seq_puts(m, "# pool packets-arrived sockets-enqueued threads-woken threads-timedout\n");
Greg Banks03cf6c92009-01-13 21:26:36 +11001296 return 0;
1297 }
1298
J. Bruce Fields78c210e2009-08-06 15:41:34 -04001299 seq_printf(m, "%u %lu %lu %lu %lu\n",
Greg Banks03cf6c92009-01-13 21:26:36 +11001300 pool->sp_id,
1301 pool->sp_stats.packets,
1302 pool->sp_stats.sockets_queued,
1303 pool->sp_stats.threads_woken,
Greg Banks03cf6c92009-01-13 21:26:36 +11001304 pool->sp_stats.threads_timedout);
1305
1306 return 0;
1307}
1308
1309static const struct seq_operations svc_pool_stats_seq_ops = {
1310 .start = svc_pool_stats_start,
1311 .next = svc_pool_stats_next,
1312 .stop = svc_pool_stats_stop,
1313 .show = svc_pool_stats_show,
1314};
1315
1316int svc_pool_stats_open(struct svc_serv *serv, struct file *file)
1317{
1318 int err;
1319
1320 err = seq_open(file, &svc_pool_stats_seq_ops);
1321 if (!err)
1322 ((struct seq_file *) file->private_data)->private = serv;
1323 return err;
1324}
1325EXPORT_SYMBOL(svc_pool_stats_open);
1326
1327/*----------------------------------------------------------------------------*/