blob: faaf2b46273bbdc27ca5ec918112951f558ec313 [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);
Trond Myklebust09713742014-07-24 23:59:31 -040026static void svc_xprt_do_enqueue(struct svc_xprt *xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -060027
28/* apparently the "standard" is that clients close
29 * idle connections after 5 minutes, servers after
30 * 6 minutes
31 * http://www.connectathon.org/talks96/nfstcp.pdf
32 */
33static int svc_conn_age_period = 6*60;
34
Tom Tucker1d8206b92007-12-30 21:07:15 -060035/* List of registered transport classes */
36static DEFINE_SPINLOCK(svc_xprt_class_lock);
37static LIST_HEAD(svc_xprt_class_list);
38
Tom Tucker0f0257e2007-12-30 21:08:27 -060039/* SMP locking strategy:
40 *
41 * svc_pool->sp_lock protects most of the fields of that pool.
42 * svc_serv->sv_lock protects sv_tempsocks, sv_permsocks, sv_tmpcnt.
43 * when both need to be taken (rare), svc_serv->sv_lock is first.
44 * BKL protects svc_serv->sv_nrthread.
45 * svc_sock->sk_lock protects the svc_sock->sk_deferred list
46 * and the ->sk_info_authunix cache.
47 *
48 * The XPT_BUSY bit in xprt->xpt_flags prevents a transport being
49 * enqueued multiply. During normal transport processing this bit
50 * is set by svc_xprt_enqueue and cleared by svc_xprt_received.
51 * Providers should not manipulate this bit directly.
52 *
53 * Some flags can be set to certain values at any time
54 * providing that certain rules are followed:
55 *
56 * XPT_CONN, XPT_DATA:
57 * - Can be set or cleared at any time.
58 * - After a set, svc_xprt_enqueue must be called to enqueue
59 * the transport for processing.
60 * - After a clear, the transport must be read/accepted.
61 * If this succeeds, it must be set again.
62 * XPT_CLOSE:
63 * - Can set at any time. It is never cleared.
64 * XPT_DEAD:
65 * - Can only be set while XPT_BUSY is held which ensures
66 * that no other thread will be using the transport or will
67 * try to set XPT_DEAD.
68 */
69
Tom Tucker1d8206b92007-12-30 21:07:15 -060070int svc_reg_xprt_class(struct svc_xprt_class *xcl)
71{
72 struct svc_xprt_class *cl;
73 int res = -EEXIST;
74
75 dprintk("svc: Adding svc transport class '%s'\n", xcl->xcl_name);
76
77 INIT_LIST_HEAD(&xcl->xcl_list);
78 spin_lock(&svc_xprt_class_lock);
79 /* Make sure there isn't already a class with the same name */
80 list_for_each_entry(cl, &svc_xprt_class_list, xcl_list) {
81 if (strcmp(xcl->xcl_name, cl->xcl_name) == 0)
82 goto out;
83 }
84 list_add_tail(&xcl->xcl_list, &svc_xprt_class_list);
85 res = 0;
86out:
87 spin_unlock(&svc_xprt_class_lock);
88 return res;
89}
90EXPORT_SYMBOL_GPL(svc_reg_xprt_class);
91
92void svc_unreg_xprt_class(struct svc_xprt_class *xcl)
93{
94 dprintk("svc: Removing svc transport class '%s'\n", xcl->xcl_name);
95 spin_lock(&svc_xprt_class_lock);
96 list_del_init(&xcl->xcl_list);
97 spin_unlock(&svc_xprt_class_lock);
98}
99EXPORT_SYMBOL_GPL(svc_unreg_xprt_class);
100
Tom Tuckerdc9a16e2007-12-30 21:08:31 -0600101/*
102 * Format the transport list for printing
103 */
104int svc_print_xprts(char *buf, int maxlen)
105{
Pavel Emelyanov8f3a6de2010-10-05 23:30:19 +0400106 struct svc_xprt_class *xcl;
Tom Tuckerdc9a16e2007-12-30 21:08:31 -0600107 char tmpstr[80];
108 int len = 0;
109 buf[0] = '\0';
110
111 spin_lock(&svc_xprt_class_lock);
Pavel Emelyanov8f3a6de2010-10-05 23:30:19 +0400112 list_for_each_entry(xcl, &svc_xprt_class_list, xcl_list) {
Tom Tuckerdc9a16e2007-12-30 21:08:31 -0600113 int slen;
Tom Tuckerdc9a16e2007-12-30 21:08:31 -0600114
115 sprintf(tmpstr, "%s %d\n", xcl->xcl_name, xcl->xcl_max_payload);
116 slen = strlen(tmpstr);
117 if (len + slen > maxlen)
118 break;
119 len += slen;
120 strcat(buf, tmpstr);
121 }
122 spin_unlock(&svc_xprt_class_lock);
123
124 return len;
125}
126
Tom Tuckere1b31572007-12-30 21:07:46 -0600127static void svc_xprt_free(struct kref *kref)
128{
129 struct svc_xprt *xprt =
130 container_of(kref, struct svc_xprt, xpt_ref);
131 struct module *owner = xprt->xpt_class->xcl_owner;
Pavel Emelyanove3bfca02010-09-27 13:58:42 +0400132 if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags))
133 svcauth_unix_info_release(xprt);
Pavel Emelyanov4fb85182010-09-27 14:00:49 +0400134 put_net(xprt->xpt_net);
J. Bruce Fields99de8ea2010-12-08 12:45:44 -0500135 /* See comment on corresponding get in xs_setup_bc_tcp(): */
136 if (xprt->xpt_bc_xprt)
137 xprt_put(xprt->xpt_bc_xprt);
Tom Tuckere1b31572007-12-30 21:07:46 -0600138 xprt->xpt_ops->xpo_free(xprt);
139 module_put(owner);
140}
141
142void svc_xprt_put(struct svc_xprt *xprt)
143{
144 kref_put(&xprt->xpt_ref, svc_xprt_free);
145}
146EXPORT_SYMBOL_GPL(svc_xprt_put);
147
Tom Tucker1d8206b92007-12-30 21:07:15 -0600148/*
149 * Called by transport drivers to initialize the transport independent
150 * portion of the transport instance.
151 */
Stanislav Kinsburskybd4620d2011-12-06 14:19:10 +0300152void svc_xprt_init(struct net *net, struct svc_xprt_class *xcl,
153 struct svc_xprt *xprt, struct svc_serv *serv)
Tom Tucker1d8206b92007-12-30 21:07:15 -0600154{
155 memset(xprt, 0, sizeof(*xprt));
156 xprt->xpt_class = xcl;
157 xprt->xpt_ops = xcl->xcl_ops;
Tom Tuckere1b31572007-12-30 21:07:46 -0600158 kref_init(&xprt->xpt_ref);
Tom Tuckerbb5cf162007-12-30 21:07:50 -0600159 xprt->xpt_server = serv;
Tom Tucker7a182082007-12-30 21:07:53 -0600160 INIT_LIST_HEAD(&xprt->xpt_list);
161 INIT_LIST_HEAD(&xprt->xpt_ready);
Tom Tucker8c7b0172007-12-30 21:08:10 -0600162 INIT_LIST_HEAD(&xprt->xpt_deferred);
J. Bruce Fieldsedc7a892010-03-22 15:37:17 -0400163 INIT_LIST_HEAD(&xprt->xpt_users);
Tom Tuckera50fea22007-12-30 21:07:59 -0600164 mutex_init(&xprt->xpt_mutex);
Tom Tuckerdef13d72007-12-30 21:08:08 -0600165 spin_lock_init(&xprt->xpt_lock);
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600166 set_bit(XPT_BUSY, &xprt->xpt_flags);
Rahul Iyer4cfc7e62009-09-10 17:32:28 +0300167 rpc_init_wait_queue(&xprt->xpt_bc_pending, "xpt_bc_pending");
Stanislav Kinsburskybd4620d2011-12-06 14:19:10 +0300168 xprt->xpt_net = get_net(net);
Tom Tucker1d8206b92007-12-30 21:07:15 -0600169}
170EXPORT_SYMBOL_GPL(svc_xprt_init);
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600171
Chuck Lever5dd248f2008-06-30 18:45:37 -0400172static struct svc_xprt *__svc_xpo_create(struct svc_xprt_class *xcl,
173 struct svc_serv *serv,
Pavel Emelyanov62832c02010-09-29 16:04:18 +0400174 struct net *net,
Chuck Lever9652ada2009-03-18 20:46:21 -0400175 const int family,
176 const unsigned short port,
177 int flags)
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600178{
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600179 struct sockaddr_in sin = {
180 .sin_family = AF_INET,
Al Viroe6f1ceb2008-03-17 22:44:53 -0700181 .sin_addr.s_addr = htonl(INADDR_ANY),
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600182 .sin_port = htons(port),
183 };
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000184#if IS_ENABLED(CONFIG_IPV6)
Chuck Lever5dd248f2008-06-30 18:45:37 -0400185 struct sockaddr_in6 sin6 = {
186 .sin6_family = AF_INET6,
187 .sin6_addr = IN6ADDR_ANY_INIT,
188 .sin6_port = htons(port),
189 };
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000190#endif
Chuck Lever5dd248f2008-06-30 18:45:37 -0400191 struct sockaddr *sap;
192 size_t len;
193
Chuck Lever9652ada2009-03-18 20:46:21 -0400194 switch (family) {
195 case PF_INET:
Chuck Lever5dd248f2008-06-30 18:45:37 -0400196 sap = (struct sockaddr *)&sin;
197 len = sizeof(sin);
198 break;
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000199#if IS_ENABLED(CONFIG_IPV6)
Chuck Lever9652ada2009-03-18 20:46:21 -0400200 case PF_INET6:
Chuck Lever5dd248f2008-06-30 18:45:37 -0400201 sap = (struct sockaddr *)&sin6;
202 len = sizeof(sin6);
203 break;
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000204#endif
Chuck Lever5dd248f2008-06-30 18:45:37 -0400205 default:
206 return ERR_PTR(-EAFNOSUPPORT);
207 }
208
Pavel Emelyanov62832c02010-09-29 16:04:18 +0400209 return xcl->xcl_ops->xpo_create(serv, net, sap, len, flags);
Chuck Lever5dd248f2008-06-30 18:45:37 -0400210}
211
J. Bruce Fields67410192012-08-17 22:12:19 -0400212/*
213 * svc_xprt_received conditionally queues the transport for processing
214 * by another thread. The caller must hold the XPT_BUSY bit and must
215 * not thereafter touch transport data.
216 *
217 * Note: XPT_DATA only gets cleared when a read-attempt finds no (or
218 * insufficient) data.
219 */
220static void svc_xprt_received(struct svc_xprt *xprt)
221{
Weston Andros Adamsonff1fdb92012-10-23 10:43:40 -0400222 WARN_ON_ONCE(!test_bit(XPT_BUSY, &xprt->xpt_flags));
223 if (!test_bit(XPT_BUSY, &xprt->xpt_flags))
224 return;
J. Bruce Fields67410192012-08-17 22:12:19 -0400225 /* As soon as we clear busy, the xprt could be closed and
Trond Myklebust09713742014-07-24 23:59:31 -0400226 * 'put', so we need a reference to call svc_xprt_do_enqueue with:
J. Bruce Fields67410192012-08-17 22:12:19 -0400227 */
228 svc_xprt_get(xprt);
Trond Myklebust09713742014-07-24 23:59:31 -0400229 smp_mb__before_atomic();
J. Bruce Fields67410192012-08-17 22:12:19 -0400230 clear_bit(XPT_BUSY, &xprt->xpt_flags);
Trond Myklebust09713742014-07-24 23:59:31 -0400231 svc_xprt_do_enqueue(xprt);
J. Bruce Fields67410192012-08-17 22:12:19 -0400232 svc_xprt_put(xprt);
233}
234
J. Bruce Fields39b553012012-08-14 15:50:34 -0400235void svc_add_new_perm_xprt(struct svc_serv *serv, struct svc_xprt *new)
236{
237 clear_bit(XPT_TEMP, &new->xpt_flags);
238 spin_lock_bh(&serv->sv_lock);
239 list_add(&new->xpt_list, &serv->sv_permsocks);
240 spin_unlock_bh(&serv->sv_lock);
241 svc_xprt_received(new);
242}
243
Chuck Lever9652ada2009-03-18 20:46:21 -0400244int svc_create_xprt(struct svc_serv *serv, const char *xprt_name,
Pavel Emelyanovfc5d00b2010-09-29 16:03:50 +0400245 struct net *net, const int family,
246 const unsigned short port, int flags)
Chuck Lever5dd248f2008-06-30 18:45:37 -0400247{
248 struct svc_xprt_class *xcl;
249
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600250 dprintk("svc: creating transport %s[%d]\n", xprt_name, port);
251 spin_lock(&svc_xprt_class_lock);
252 list_for_each_entry(xcl, &svc_xprt_class_list, xcl_list) {
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600253 struct svc_xprt *newxprt;
NeilBrowned2849d2010-11-16 16:55:19 +1100254 unsigned short newport;
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600255
256 if (strcmp(xprt_name, xcl->xcl_name))
257 continue;
258
259 if (!try_module_get(xcl->xcl_owner))
260 goto err;
261
262 spin_unlock(&svc_xprt_class_lock);
Pavel Emelyanov62832c02010-09-29 16:04:18 +0400263 newxprt = __svc_xpo_create(xcl, serv, net, family, port, flags);
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600264 if (IS_ERR(newxprt)) {
265 module_put(xcl->xcl_owner);
266 return PTR_ERR(newxprt);
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600267 }
J. Bruce Fields39b553012012-08-14 15:50:34 -0400268 svc_add_new_perm_xprt(serv, newxprt);
NeilBrowned2849d2010-11-16 16:55:19 +1100269 newport = svc_xprt_local_port(newxprt);
NeilBrowned2849d2010-11-16 16:55:19 +1100270 return newport;
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600271 }
Tom Tucker4e5caaa2007-12-30 21:08:20 -0600272 err:
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600273 spin_unlock(&svc_xprt_class_lock);
274 dprintk("svc: transport %s not found\n", xprt_name);
Chuck Lever68717902010-01-26 14:04:13 -0500275
276 /* This errno is exposed to user space. Provide a reasonable
277 * perror msg for a bad transport. */
278 return -EPROTONOSUPPORT;
Tom Tuckerb700cbb2007-12-30 21:07:42 -0600279}
280EXPORT_SYMBOL_GPL(svc_create_xprt);
Tom Tucker9dbc2402007-12-30 21:08:12 -0600281
282/*
283 * Copy the local and remote xprt addresses to the rqstp structure
284 */
285void svc_xprt_copy_addrs(struct svc_rqst *rqstp, struct svc_xprt *xprt)
286{
Tom Tucker9dbc2402007-12-30 21:08:12 -0600287 memcpy(&rqstp->rq_addr, &xprt->xpt_remote, xprt->xpt_remotelen);
288 rqstp->rq_addrlen = xprt->xpt_remotelen;
289
290 /*
291 * Destination address in request is needed for binding the
292 * source address in RPC replies/callbacks later.
293 */
Mi Jinlong849a1cf2011-08-30 17:18:41 +0800294 memcpy(&rqstp->rq_daddr, &xprt->xpt_local, xprt->xpt_locallen);
295 rqstp->rq_daddrlen = xprt->xpt_locallen;
Tom Tucker9dbc2402007-12-30 21:08:12 -0600296}
297EXPORT_SYMBOL_GPL(svc_xprt_copy_addrs);
298
Tom Tucker0f0257e2007-12-30 21:08:27 -0600299/**
300 * svc_print_addr - Format rq_addr field for printing
301 * @rqstp: svc_rqst struct containing address to print
302 * @buf: target buffer for formatted address
303 * @len: length of target buffer
304 *
305 */
306char *svc_print_addr(struct svc_rqst *rqstp, char *buf, size_t len)
307{
308 return __svc_print_addr(svc_addr(rqstp), buf, len);
309}
310EXPORT_SYMBOL_GPL(svc_print_addr);
311
312/*
313 * Queue up an idle server thread. Must have pool->sp_lock held.
314 * Note: this is really a stack rather than a queue, so that we only
315 * use as many different threads as we need, and the rest don't pollute
316 * the cache.
317 */
318static void svc_thread_enqueue(struct svc_pool *pool, struct svc_rqst *rqstp)
319{
320 list_add(&rqstp->rq_list, &pool->sp_threads);
321}
322
323/*
324 * Dequeue an nfsd thread. Must have pool->sp_lock held.
325 */
326static void svc_thread_dequeue(struct svc_pool *pool, struct svc_rqst *rqstp)
327{
328 list_del(&rqstp->rq_list);
329}
330
J. Bruce Fields9c335c02010-10-26 11:32:03 -0400331static bool svc_xprt_has_something_to_do(struct svc_xprt *xprt)
332{
333 if (xprt->xpt_flags & ((1<<XPT_CONN)|(1<<XPT_CLOSE)))
334 return true;
335 if (xprt->xpt_flags & ((1<<XPT_DATA)|(1<<XPT_DEFERRED)))
336 return xprt->xpt_ops->xpo_has_wspace(xprt);
337 return false;
338}
339
Trond Myklebust09713742014-07-24 23:59:31 -0400340static void svc_xprt_do_enqueue(struct svc_xprt *xprt)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600341{
Tom Tucker0f0257e2007-12-30 21:08:27 -0600342 struct svc_pool *pool;
343 struct svc_rqst *rqstp;
344 int cpu;
345
J. Bruce Fields9c335c02010-10-26 11:32:03 -0400346 if (!svc_xprt_has_something_to_do(xprt))
Tom Tucker0f0257e2007-12-30 21:08:27 -0600347 return;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600348
349 cpu = get_cpu();
350 pool = svc_pool_for_cpu(xprt->xpt_server, cpu);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600351 spin_lock_bh(&pool->sp_lock);
352
J. Bruce Fields78c210e2009-08-06 15:41:34 -0400353 if (!list_empty(&pool->sp_threads) &&
354 !list_empty(&pool->sp_sockets))
355 printk(KERN_ERR
356 "svc_xprt_enqueue: "
357 "threads and transports both waiting??\n");
358
Greg Banks03cf6c92009-01-13 21:26:36 +1100359 pool->sp_stats.packets++;
360
Tom Tucker0f0257e2007-12-30 21:08:27 -0600361 /* Mark transport as busy. It will remain in this state until
362 * the provider calls svc_xprt_received. We update XPT_BUSY
363 * atomically because it also guards against trying to enqueue
364 * the transport twice.
365 */
366 if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags)) {
367 /* Don't enqueue transport while already enqueued */
368 dprintk("svc: transport %p busy, not enqueued\n", xprt);
369 goto out_unlock;
370 }
Tom Tucker0f0257e2007-12-30 21:08:27 -0600371
J. Bruce Fields78c210e2009-08-06 15:41:34 -0400372 if (!list_empty(&pool->sp_threads)) {
Tom Tucker0f0257e2007-12-30 21:08:27 -0600373 rqstp = list_entry(pool->sp_threads.next,
374 struct svc_rqst,
375 rq_list);
376 dprintk("svc: transport %p served by daemon %p\n",
377 xprt, rqstp);
378 svc_thread_dequeue(pool, rqstp);
379 if (rqstp->rq_xprt)
380 printk(KERN_ERR
381 "svc_xprt_enqueue: server %p, rq_xprt=%p!\n",
382 rqstp, rqstp->rq_xprt);
Trond Myklebust983c6842014-08-03 13:03:10 -0400383 /* Note the order of the following 3 lines:
384 * We want to assign xprt to rqstp->rq_xprt only _after_
385 * we've woken up the process, so that we don't race with
386 * the lockless check in svc_get_next_xprt().
387 */
Tom Tucker0f0257e2007-12-30 21:08:27 -0600388 svc_xprt_get(xprt);
Trond Myklebust983c6842014-08-03 13:03:10 -0400389 wake_up_process(rqstp->rq_task);
390 rqstp->rq_xprt = xprt;
Greg Banks03cf6c92009-01-13 21:26:36 +1100391 pool->sp_stats.threads_woken++;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600392 } 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);
Trond Myklebust983c6842014-08-03 13:03:10 -0400400 put_cpu();
Tom Tucker0f0257e2007-12-30 21:08:27 -0600401}
Trond Myklebust09713742014-07-24 23:59:31 -0400402
403/*
404 * Queue up a transport with data pending. If there are idle nfsd
405 * processes, wake 'em up.
406 *
407 */
408void svc_xprt_enqueue(struct svc_xprt *xprt)
409{
410 if (test_bit(XPT_BUSY, &xprt->xpt_flags))
411 return;
412 svc_xprt_do_enqueue(xprt);
413}
Tom Tucker0f0257e2007-12-30 21:08:27 -0600414EXPORT_SYMBOL_GPL(svc_xprt_enqueue);
415
416/*
417 * Dequeue the first transport. Must be called with the pool->sp_lock held.
418 */
419static struct svc_xprt *svc_xprt_dequeue(struct svc_pool *pool)
420{
421 struct svc_xprt *xprt;
422
423 if (list_empty(&pool->sp_sockets))
424 return NULL;
425
426 xprt = list_entry(pool->sp_sockets.next,
427 struct svc_xprt, xpt_ready);
428 list_del_init(&xprt->xpt_ready);
429
430 dprintk("svc: transport %p dequeued, inuse=%d\n",
431 xprt, atomic_read(&xprt->xpt_ref.refcount));
432
433 return xprt;
434}
435
Tom Tucker0f0257e2007-12-30 21:08:27 -0600436/**
437 * svc_reserve - change the space reserved for the reply to a request.
438 * @rqstp: The request in question
439 * @space: new max space to reserve
440 *
441 * Each request reserves some space on the output queue of the transport
442 * to make sure the reply fits. This function reduces that reserved
443 * space to be the amount of space used already, plus @space.
444 *
445 */
446void svc_reserve(struct svc_rqst *rqstp, int space)
447{
448 space += rqstp->rq_res.head[0].iov_len;
449
450 if (space < rqstp->rq_reserved) {
451 struct svc_xprt *xprt = rqstp->rq_xprt;
452 atomic_sub((rqstp->rq_reserved - space), &xprt->xpt_reserved);
453 rqstp->rq_reserved = space;
454
Trond Myklebust51877682014-07-24 23:59:33 -0400455 if (xprt->xpt_ops->xpo_adjust_wspace)
456 xprt->xpt_ops->xpo_adjust_wspace(xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600457 svc_xprt_enqueue(xprt);
458 }
459}
Trond Myklebust24c37672008-12-23 16:30:12 -0500460EXPORT_SYMBOL_GPL(svc_reserve);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600461
462static void svc_xprt_release(struct svc_rqst *rqstp)
463{
464 struct svc_xprt *xprt = rqstp->rq_xprt;
465
466 rqstp->rq_xprt->xpt_ops->xpo_release_rqst(rqstp);
467
Tom Tucker2779e3a2009-01-05 11:12:52 -0600468 kfree(rqstp->rq_deferred);
469 rqstp->rq_deferred = NULL;
470
Tom Tucker0f0257e2007-12-30 21:08:27 -0600471 svc_free_res_pages(rqstp);
472 rqstp->rq_res.page_len = 0;
473 rqstp->rq_res.page_base = 0;
474
475 /* Reset response buffer and release
476 * the reservation.
477 * But first, check that enough space was reserved
478 * for the reply, otherwise we have a bug!
479 */
480 if ((rqstp->rq_res.len) > rqstp->rq_reserved)
481 printk(KERN_ERR "RPC request reserved %d but used %d\n",
482 rqstp->rq_reserved,
483 rqstp->rq_res.len);
484
485 rqstp->rq_res.head[0].iov_len = 0;
486 svc_reserve(rqstp, 0);
487 rqstp->rq_xprt = NULL;
488
489 svc_xprt_put(xprt);
490}
491
492/*
493 * External function to wake up a server waiting for data
494 * This really only makes sense for services like lockd
495 * which have exactly one thread anyway.
496 */
497void svc_wake_up(struct svc_serv *serv)
498{
499 struct svc_rqst *rqstp;
500 unsigned int i;
501 struct svc_pool *pool;
502
503 for (i = 0; i < serv->sv_nrpools; i++) {
504 pool = &serv->sv_pools[i];
505
506 spin_lock_bh(&pool->sp_lock);
507 if (!list_empty(&pool->sp_threads)) {
508 rqstp = list_entry(pool->sp_threads.next,
509 struct svc_rqst,
510 rq_list);
511 dprintk("svc: daemon %p woken up.\n", rqstp);
512 /*
513 svc_thread_dequeue(pool, rqstp);
514 rqstp->rq_xprt = NULL;
515 */
Trond Myklebust983c6842014-08-03 13:03:10 -0400516 wake_up_process(rqstp->rq_task);
Andriy Skulysh35525b72013-01-07 00:12:15 +0200517 } else
518 pool->sp_task_pending = 1;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600519 spin_unlock_bh(&pool->sp_lock);
520 }
521}
Trond Myklebust24c37672008-12-23 16:30:12 -0500522EXPORT_SYMBOL_GPL(svc_wake_up);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600523
524int svc_port_is_privileged(struct sockaddr *sin)
525{
526 switch (sin->sa_family) {
527 case AF_INET:
528 return ntohs(((struct sockaddr_in *)sin)->sin_port)
529 < PROT_SOCK;
530 case AF_INET6:
531 return ntohs(((struct sockaddr_in6 *)sin)->sin6_port)
532 < PROT_SOCK;
533 default:
534 return 0;
535 }
536}
537
538/*
Jeff Laytonc9233eb2008-10-20 11:51:57 -0400539 * Make sure that we don't have too many active connections. If we have,
540 * something must be dropped. It's not clear what will happen if we allow
541 * "too many" connections, but when dealing with network-facing software,
542 * we have to code defensively. Here we do that by imposing hard limits.
Tom Tucker0f0257e2007-12-30 21:08:27 -0600543 *
544 * There's no point in trying to do random drop here for DoS
545 * prevention. The NFS clients does 1 reconnect in 15 seconds. An
546 * attacker can easily beat that.
547 *
548 * The only somewhat efficient mechanism would be if drop old
549 * connections from the same IP first. But right now we don't even
550 * record the client IP in svc_sock.
Jeff Laytonc9233eb2008-10-20 11:51:57 -0400551 *
552 * single-threaded services that expect a lot of clients will probably
553 * need to set sv_maxconn to override the default value which is based
554 * on the number of threads
Tom Tucker0f0257e2007-12-30 21:08:27 -0600555 */
556static void svc_check_conn_limits(struct svc_serv *serv)
557{
Jeff Laytonc9233eb2008-10-20 11:51:57 -0400558 unsigned int limit = serv->sv_maxconn ? serv->sv_maxconn :
559 (serv->sv_nrthreads+3) * 20;
560
561 if (serv->sv_tmpcnt > limit) {
Tom Tucker0f0257e2007-12-30 21:08:27 -0600562 struct svc_xprt *xprt = NULL;
563 spin_lock_bh(&serv->sv_lock);
564 if (!list_empty(&serv->sv_tempsocks)) {
Joe Perchese87cc472012-05-13 21:56:26 +0000565 /* Try to help the admin */
566 net_notice_ratelimited("%s: too many open connections, consider increasing the %s\n",
567 serv->sv_name, serv->sv_maxconn ?
568 "max number of connections" :
569 "number of threads");
Tom Tucker0f0257e2007-12-30 21:08:27 -0600570 /*
571 * Always select the oldest connection. It's not fair,
572 * but so is life
573 */
574 xprt = list_entry(serv->sv_tempsocks.prev,
575 struct svc_xprt,
576 xpt_list);
577 set_bit(XPT_CLOSE, &xprt->xpt_flags);
578 svc_xprt_get(xprt);
579 }
580 spin_unlock_bh(&serv->sv_lock);
581
582 if (xprt) {
583 svc_xprt_enqueue(xprt);
584 svc_xprt_put(xprt);
585 }
586 }
587}
588
Rashika Kheriae1d83ee2014-02-09 22:33:03 +0530589static int svc_alloc_arg(struct svc_rqst *rqstp)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600590{
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400591 struct svc_serv *serv = rqstp->rq_server;
592 struct xdr_buf *arg;
593 int pages;
594 int i;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600595
596 /* now allocate needed pages. If we get a failure, sleep briefly */
597 pages = (serv->sv_max_mesg + PAGE_SIZE) / PAGE_SIZE;
Weston Andros Adamsonb25cd052012-10-23 10:43:41 -0400598 WARN_ON_ONCE(pages >= RPCSVC_MAXPAGES);
599 if (pages >= RPCSVC_MAXPAGES)
600 /* use as many pages as possible */
601 pages = RPCSVC_MAXPAGES - 1;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600602 for (i = 0; i < pages ; i++)
603 while (rqstp->rq_pages[i] == NULL) {
604 struct page *p = alloc_page(GFP_KERNEL);
605 if (!p) {
Jeff Layton7b54fe62008-02-12 11:47:24 -0500606 set_current_state(TASK_INTERRUPTIBLE);
607 if (signalled() || kthread_should_stop()) {
608 set_current_state(TASK_RUNNING);
Jeff Layton70867212008-02-07 16:34:54 -0500609 return -EINTR;
Jeff Layton7b54fe62008-02-12 11:47:24 -0500610 }
611 schedule_timeout(msecs_to_jiffies(500));
Tom Tucker0f0257e2007-12-30 21:08:27 -0600612 }
613 rqstp->rq_pages[i] = p;
614 }
J. Bruce Fields2825a7f2013-08-26 16:04:46 -0400615 rqstp->rq_page_end = &rqstp->rq_pages[i];
Tom Tucker0f0257e2007-12-30 21:08:27 -0600616 rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */
Tom Tucker0f0257e2007-12-30 21:08:27 -0600617
618 /* Make arg->head point to first page and arg->pages point to rest */
619 arg = &rqstp->rq_arg;
620 arg->head[0].iov_base = page_address(rqstp->rq_pages[0]);
621 arg->head[0].iov_len = PAGE_SIZE;
622 arg->pages = rqstp->rq_pages + 1;
623 arg->page_base = 0;
624 /* save at least one page for response */
625 arg->page_len = (pages-2)*PAGE_SIZE;
626 arg->len = (pages-1)*PAGE_SIZE;
627 arg->tail[0].iov_len = 0;
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400628 return 0;
629}
Tom Tucker0f0257e2007-12-30 21:08:27 -0600630
Rashika Kheriae1d83ee2014-02-09 22:33:03 +0530631static struct svc_xprt *svc_get_next_xprt(struct svc_rqst *rqstp, long timeout)
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400632{
633 struct svc_xprt *xprt;
634 struct svc_pool *pool = rqstp->rq_pool;
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400635 long time_left;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600636
NeilBrownf16b6e82010-08-12 17:04:06 +1000637 /* Normally we will wait up to 5 seconds for any required
638 * cache information to be provided.
639 */
640 rqstp->rq_chandle.thread_wait = 5*HZ;
641
Tom Tucker0f0257e2007-12-30 21:08:27 -0600642 spin_lock_bh(&pool->sp_lock);
643 xprt = svc_xprt_dequeue(pool);
644 if (xprt) {
645 rqstp->rq_xprt = xprt;
646 svc_xprt_get(xprt);
NeilBrownf16b6e82010-08-12 17:04:06 +1000647
648 /* As there is a shortage of threads and this request
J. Bruce Fields6610f722010-08-26 13:19:52 -0400649 * had to be queued, don't allow the thread to wait so
NeilBrownf16b6e82010-08-12 17:04:06 +1000650 * long for cache updates.
651 */
652 rqstp->rq_chandle.thread_wait = 1*HZ;
Andriy Skulysh35525b72013-01-07 00:12:15 +0200653 pool->sp_task_pending = 0;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600654 } else {
Andriy Skulysh35525b72013-01-07 00:12:15 +0200655 if (pool->sp_task_pending) {
656 pool->sp_task_pending = 0;
Trond Myklebust106f3592014-08-03 13:03:09 -0400657 xprt = ERR_PTR(-EAGAIN);
658 goto out;
Andriy Skulysh35525b72013-01-07 00:12:15 +0200659 }
Tom Tucker0f0257e2007-12-30 21:08:27 -0600660 /*
661 * We have to be able to interrupt this wait
662 * to bring down the daemons ...
663 */
664 set_current_state(TASK_INTERRUPTIBLE);
Jeff Layton70867212008-02-07 16:34:54 -0500665
Trond Myklebust983c6842014-08-03 13:03:10 -0400666 /* No data pending. Go to sleep */
667 svc_thread_enqueue(pool, rqstp);
668
Jeff Layton70867212008-02-07 16:34:54 -0500669 /*
670 * checking kthread_should_stop() here allows us to avoid
671 * locking and signalling when stopping kthreads that call
672 * svc_recv. If the thread has already been woken up, then
673 * we can exit here without sleeping. If not, then it
674 * it'll be woken up quickly during the schedule_timeout
675 */
676 if (kthread_should_stop()) {
677 set_current_state(TASK_RUNNING);
Trond Myklebust106f3592014-08-03 13:03:09 -0400678 xprt = ERR_PTR(-EINTR);
679 goto out;
Jeff Layton70867212008-02-07 16:34:54 -0500680 }
681
Tom Tucker0f0257e2007-12-30 21:08:27 -0600682 spin_unlock_bh(&pool->sp_lock);
683
Greg Banks03cf6c92009-01-13 21:26:36 +1100684 time_left = schedule_timeout(timeout);
Trond Myklebust983c6842014-08-03 13:03:10 -0400685 __set_current_state(TASK_RUNNING);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600686
687 try_to_freeze();
688
Trond Myklebust106f3592014-08-03 13:03:09 -0400689 xprt = rqstp->rq_xprt;
690 if (xprt != NULL)
691 return xprt;
692
693 spin_lock_bh(&pool->sp_lock);
Greg Banks03cf6c92009-01-13 21:26:36 +1100694 if (!time_left)
695 pool->sp_stats.threads_timedout++;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600696
697 xprt = rqstp->rq_xprt;
698 if (!xprt) {
699 svc_thread_dequeue(pool, rqstp);
700 spin_unlock_bh(&pool->sp_lock);
701 dprintk("svc: server %p, no data yet\n", rqstp);
Jeff Layton70867212008-02-07 16:34:54 -0500702 if (signalled() || kthread_should_stop())
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400703 return ERR_PTR(-EINTR);
Jeff Layton70867212008-02-07 16:34:54 -0500704 else
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400705 return ERR_PTR(-EAGAIN);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600706 }
707 }
Trond Myklebust106f3592014-08-03 13:03:09 -0400708out:
Tom Tucker0f0257e2007-12-30 21:08:27 -0600709 spin_unlock_bh(&pool->sp_lock);
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400710 return xprt;
711}
Tom Tucker0f0257e2007-12-30 21:08:27 -0600712
Rashika Kheriae1d83ee2014-02-09 22:33:03 +0530713static void svc_add_new_temp_xprt(struct svc_serv *serv, struct svc_xprt *newxpt)
J. Bruce Fields65b2e662012-08-18 15:44:33 -0400714{
715 spin_lock_bh(&serv->sv_lock);
716 set_bit(XPT_TEMP, &newxpt->xpt_flags);
717 list_add(&newxpt->xpt_list, &serv->sv_tempsocks);
718 serv->sv_tmpcnt++;
719 if (serv->sv_temptimer.function == NULL) {
720 /* setup timer to age temp transports */
721 setup_timer(&serv->sv_temptimer, svc_age_temp_xprts,
722 (unsigned long)serv);
723 mod_timer(&serv->sv_temptimer,
724 jiffies + svc_conn_age_period * HZ);
725 }
726 spin_unlock_bh(&serv->sv_lock);
727 svc_xprt_received(newxpt);
728}
729
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400730static int svc_handle_xprt(struct svc_rqst *rqstp, struct svc_xprt *xprt)
731{
732 struct svc_serv *serv = rqstp->rq_server;
733 int len = 0;
734
J. Bruce Fields1b644b62010-02-28 16:33:31 -0500735 if (test_bit(XPT_CLOSE, &xprt->xpt_flags)) {
736 dprintk("svc_recv: found XPT_CLOSE\n");
737 svc_delete_xprt(xprt);
J. Bruce Fieldsca7896cd2010-10-25 14:12:40 -0400738 /* Leave XPT_BUSY set on the dead xprt: */
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400739 return 0;
J. Bruce Fieldsca7896cd2010-10-25 14:12:40 -0400740 }
741 if (test_bit(XPT_LISTENER, &xprt->xpt_flags)) {
Tom Tucker0f0257e2007-12-30 21:08:27 -0600742 struct svc_xprt *newxpt;
J. Bruce Fields65b2e662012-08-18 15:44:33 -0400743 /*
744 * We know this module_get will succeed because the
745 * listener holds a reference too
746 */
747 __module_get(xprt->xpt_class->xcl_owner);
748 svc_check_conn_limits(xprt->xpt_server);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600749 newxpt = xprt->xpt_ops->xpo_accept(xprt);
J. Bruce Fields65b2e662012-08-18 15:44:33 -0400750 if (newxpt)
751 svc_add_new_temp_xprt(serv, newxpt);
Trond Myklebustc7891022014-05-18 14:05:22 -0400752 else
753 module_put(xprt->xpt_class->xcl_owner);
Trond Myklebust9e5b2082014-08-03 13:03:06 -0400754 } else {
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400755 /* XPT_DATA|XPT_DEFERRED case: */
Tom Tucker0f0257e2007-12-30 21:08:27 -0600756 dprintk("svc: server %p, pool %u, transport %p, inuse=%d\n",
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400757 rqstp, rqstp->rq_pool->sp_id, xprt,
Tom Tucker0f0257e2007-12-30 21:08:27 -0600758 atomic_read(&xprt->xpt_ref.refcount));
759 rqstp->rq_deferred = svc_deferred_dequeue(xprt);
J. Bruce Fieldsca7896cd2010-10-25 14:12:40 -0400760 if (rqstp->rq_deferred)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600761 len = svc_deferred_recv(rqstp);
J. Bruce Fieldsca7896cd2010-10-25 14:12:40 -0400762 else
Tom Tucker0f0257e2007-12-30 21:08:27 -0600763 len = xprt->xpt_ops->xpo_recvfrom(rqstp);
764 dprintk("svc: got len=%d\n", len);
J. Bruce Fieldsd10f27a2012-08-17 17:31:53 -0400765 rqstp->rq_reserved = serv->sv_max_mesg;
766 atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600767 }
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400768 /* clear XPT_BUSY: */
J. Bruce Fieldsca7896cd2010-10-25 14:12:40 -0400769 svc_xprt_received(xprt);
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400770 return len;
771}
772
773/*
774 * Receive the next request on any transport. This code is carefully
775 * organised not to touch any cachelines in the shared svc_serv
776 * structure, only cachelines in the local svc_pool.
777 */
778int svc_recv(struct svc_rqst *rqstp, long timeout)
779{
780 struct svc_xprt *xprt = NULL;
781 struct svc_serv *serv = rqstp->rq_server;
782 int len, err;
783
784 dprintk("svc: server %p waiting for data (to = %ld)\n",
785 rqstp, timeout);
786
787 if (rqstp->rq_xprt)
788 printk(KERN_ERR
789 "svc_recv: service %p, transport not NULL!\n",
790 rqstp);
Trond Myklebust983c6842014-08-03 13:03:10 -0400791
792 /* Make sure the task pointer is set! */
793 if (WARN_ON_ONCE(!rqstp->rq_task))
794 rqstp->rq_task = current_task;
J. Bruce Fields6797fa52012-08-18 15:33:51 -0400795
796 err = svc_alloc_arg(rqstp);
797 if (err)
798 return err;
799
800 try_to_freeze();
801 cond_resched();
802 if (signalled() || kthread_should_stop())
803 return -EINTR;
804
805 xprt = svc_get_next_xprt(rqstp, timeout);
806 if (IS_ERR(xprt))
807 return PTR_ERR(xprt);
808
809 len = svc_handle_xprt(rqstp, xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600810
811 /* No data, incomplete (TCP) read, or accept() */
J. Bruce Fields9f9d2eb2012-08-17 21:35:24 -0400812 if (len <= 0)
J. Bruce Fieldsca7896cd2010-10-25 14:12:40 -0400813 goto out;
814
Tom Tucker0f0257e2007-12-30 21:08:27 -0600815 clear_bit(XPT_OLD, &xprt->xpt_flags);
816
Chuck Lever16e4d932014-05-19 13:40:22 -0400817 rqstp->rq_secure = xprt->xpt_ops->xpo_secure_port(rqstp);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600818 rqstp->rq_chandle.defer = svc_defer;
819
820 if (serv->sv_stats)
821 serv->sv_stats->netcnt++;
822 return len;
J. Bruce Fieldsca7896cd2010-10-25 14:12:40 -0400823out:
824 rqstp->rq_res.len = 0;
825 svc_xprt_release(rqstp);
826 return -EAGAIN;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600827}
Trond Myklebust24c37672008-12-23 16:30:12 -0500828EXPORT_SYMBOL_GPL(svc_recv);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600829
830/*
831 * Drop request
832 */
833void svc_drop(struct svc_rqst *rqstp)
834{
835 dprintk("svc: xprt %p dropped request\n", rqstp->rq_xprt);
836 svc_xprt_release(rqstp);
837}
Trond Myklebust24c37672008-12-23 16:30:12 -0500838EXPORT_SYMBOL_GPL(svc_drop);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600839
840/*
841 * Return reply to client.
842 */
843int svc_send(struct svc_rqst *rqstp)
844{
845 struct svc_xprt *xprt;
846 int len;
847 struct xdr_buf *xb;
848
849 xprt = rqstp->rq_xprt;
850 if (!xprt)
851 return -EFAULT;
852
853 /* release the receive skb before sending the reply */
854 rqstp->rq_xprt->xpt_ops->xpo_release_rqst(rqstp);
855
856 /* calculate over-all length */
857 xb = &rqstp->rq_res;
858 xb->len = xb->head[0].iov_len +
859 xb->page_len +
860 xb->tail[0].iov_len;
861
862 /* Grab mutex to serialize outgoing data. */
863 mutex_lock(&xprt->xpt_mutex);
J. Bruce Fieldsf06f00a2012-08-20 16:04:40 -0400864 if (test_bit(XPT_DEAD, &xprt->xpt_flags)
865 || test_bit(XPT_CLOSE, &xprt->xpt_flags))
Tom Tucker0f0257e2007-12-30 21:08:27 -0600866 len = -ENOTCONN;
867 else
868 len = xprt->xpt_ops->xpo_sendto(rqstp);
869 mutex_unlock(&xprt->xpt_mutex);
Rahul Iyer4cfc7e62009-09-10 17:32:28 +0300870 rpc_wake_up(&xprt->xpt_bc_pending);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600871 svc_xprt_release(rqstp);
872
873 if (len == -ECONNREFUSED || len == -ENOTCONN || len == -EAGAIN)
874 return 0;
875 return len;
876}
877
878/*
879 * Timer function to close old temporary transports, using
880 * a mark-and-sweep algorithm.
881 */
882static void svc_age_temp_xprts(unsigned long closure)
883{
884 struct svc_serv *serv = (struct svc_serv *)closure;
885 struct svc_xprt *xprt;
886 struct list_head *le, *next;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600887
888 dprintk("svc_age_temp_xprts\n");
889
890 if (!spin_trylock_bh(&serv->sv_lock)) {
891 /* busy, try again 1 sec later */
892 dprintk("svc_age_temp_xprts: busy\n");
893 mod_timer(&serv->sv_temptimer, jiffies + HZ);
894 return;
895 }
896
897 list_for_each_safe(le, next, &serv->sv_tempsocks) {
898 xprt = list_entry(le, struct svc_xprt, xpt_list);
899
900 /* First time through, just mark it OLD. Second time
901 * through, close it. */
902 if (!test_and_set_bit(XPT_OLD, &xprt->xpt_flags))
903 continue;
Joe Perchesf64f9e72009-11-29 16:55:45 -0800904 if (atomic_read(&xprt->xpt_ref.refcount) > 1 ||
905 test_bit(XPT_BUSY, &xprt->xpt_flags))
Tom Tucker0f0257e2007-12-30 21:08:27 -0600906 continue;
J. Bruce Fieldse75bafb2013-02-10 11:33:48 -0500907 list_del_init(le);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600908 set_bit(XPT_CLOSE, &xprt->xpt_flags);
909 set_bit(XPT_DETACHED, &xprt->xpt_flags);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600910 dprintk("queuing xprt %p for closing\n", xprt);
911
912 /* a thread will dequeue and close it soon */
913 svc_xprt_enqueue(xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600914 }
J. Bruce Fieldse75bafb2013-02-10 11:33:48 -0500915 spin_unlock_bh(&serv->sv_lock);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600916
917 mod_timer(&serv->sv_temptimer, jiffies + svc_conn_age_period * HZ);
918}
919
J. Bruce Fieldsedc7a892010-03-22 15:37:17 -0400920static void call_xpt_users(struct svc_xprt *xprt)
921{
922 struct svc_xpt_user *u;
923
924 spin_lock(&xprt->xpt_lock);
925 while (!list_empty(&xprt->xpt_users)) {
926 u = list_first_entry(&xprt->xpt_users, struct svc_xpt_user, list);
927 list_del(&u->list);
928 u->callback(u);
929 }
930 spin_unlock(&xprt->xpt_lock);
931}
932
Tom Tucker0f0257e2007-12-30 21:08:27 -0600933/*
934 * Remove a dead transport
935 */
J. Bruce Fields7710ec32011-11-25 18:44:05 -0500936static void svc_delete_xprt(struct svc_xprt *xprt)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600937{
938 struct svc_serv *serv = xprt->xpt_server;
Tom Tucker22945e42009-01-05 15:21:19 -0600939 struct svc_deferred_req *dr;
940
941 /* Only do this once */
942 if (test_and_set_bit(XPT_DEAD, &xprt->xpt_flags))
J. Bruce Fieldsac9303e2010-10-23 11:16:10 -0400943 BUG();
Tom Tucker0f0257e2007-12-30 21:08:27 -0600944
945 dprintk("svc: svc_delete_xprt(%p)\n", xprt);
946 xprt->xpt_ops->xpo_detach(xprt);
947
948 spin_lock_bh(&serv->sv_lock);
949 if (!test_and_set_bit(XPT_DETACHED, &xprt->xpt_flags))
950 list_del_init(&xprt->xpt_list);
Weston Andros Adamson01047292012-10-23 10:43:48 -0400951 WARN_ON_ONCE(!list_empty(&xprt->xpt_ready));
Tom Tucker22945e42009-01-05 15:21:19 -0600952 if (test_bit(XPT_TEMP, &xprt->xpt_flags))
953 serv->sv_tmpcnt--;
J. Bruce Fields788e69e2010-03-29 21:02:31 -0400954 spin_unlock_bh(&serv->sv_lock);
Tom Tucker22945e42009-01-05 15:21:19 -0600955
Neil Brownab1b18f2010-02-27 09:33:40 +1100956 while ((dr = svc_deferred_dequeue(xprt)) != NULL)
Tom Tucker22945e42009-01-05 15:21:19 -0600957 kfree(dr);
Tom Tucker22945e42009-01-05 15:21:19 -0600958
J. Bruce Fieldsedc7a892010-03-22 15:37:17 -0400959 call_xpt_users(xprt);
Tom Tucker22945e42009-01-05 15:21:19 -0600960 svc_xprt_put(xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600961}
962
963void svc_close_xprt(struct svc_xprt *xprt)
964{
965 set_bit(XPT_CLOSE, &xprt->xpt_flags);
966 if (test_and_set_bit(XPT_BUSY, &xprt->xpt_flags))
967 /* someone else will have to effect the close */
968 return;
J. Bruce Fieldsb1763312010-10-25 20:24:48 -0400969 /*
970 * We expect svc_close_xprt() to work even when no threads are
971 * running (e.g., while configuring the server before starting
972 * any threads), so if the transport isn't busy, we delete
973 * it ourself:
974 */
Tom Tucker0f0257e2007-12-30 21:08:27 -0600975 svc_delete_xprt(xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600976}
Tom Tuckera2178132007-12-30 21:08:35 -0600977EXPORT_SYMBOL_GPL(svc_close_xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600978
J. Bruce Fieldscc630d92013-02-10 16:08:11 -0500979static int svc_close_list(struct svc_serv *serv, struct list_head *xprt_list, struct net *net)
Tom Tucker0f0257e2007-12-30 21:08:27 -0600980{
981 struct svc_xprt *xprt;
J. Bruce Fieldscc630d92013-02-10 16:08:11 -0500982 int ret = 0;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600983
J. Bruce Fields719f8bc2012-08-13 17:03:00 -0400984 spin_lock(&serv->sv_lock);
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -0500985 list_for_each_entry(xprt, xprt_list, xpt_list) {
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +0400986 if (xprt->xpt_net != net)
987 continue;
J. Bruce Fieldscc630d92013-02-10 16:08:11 -0500988 ret++;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600989 set_bit(XPT_CLOSE, &xprt->xpt_flags);
J. Bruce Fieldscc630d92013-02-10 16:08:11 -0500990 svc_xprt_enqueue(xprt);
Tom Tucker0f0257e2007-12-30 21:08:27 -0600991 }
J. Bruce Fields719f8bc2012-08-13 17:03:00 -0400992 spin_unlock(&serv->sv_lock);
J. Bruce Fieldscc630d92013-02-10 16:08:11 -0500993 return ret;
Tom Tucker0f0257e2007-12-30 21:08:27 -0600994}
995
J. Bruce Fieldscc630d92013-02-10 16:08:11 -0500996static struct svc_xprt *svc_dequeue_net(struct svc_serv *serv, struct net *net)
J. Bruce Fields2fefb8a2011-11-29 11:35:35 -0500997{
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -0500998 struct svc_pool *pool;
999 struct svc_xprt *xprt;
1000 struct svc_xprt *tmp;
1001 int i;
1002
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -05001003 for (i = 0; i < serv->sv_nrpools; i++) {
1004 pool = &serv->sv_pools[i];
1005
1006 spin_lock_bh(&pool->sp_lock);
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +04001007 list_for_each_entry_safe(xprt, tmp, &pool->sp_sockets, xpt_ready) {
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +04001008 if (xprt->xpt_net != net)
1009 continue;
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -05001010 list_del_init(&xprt->xpt_ready);
J. Bruce Fieldscc630d92013-02-10 16:08:11 -05001011 spin_unlock_bh(&pool->sp_lock);
1012 return xprt;
J. Bruce Fieldsb4f36f82011-11-29 17:00:26 -05001013 }
1014 spin_unlock_bh(&pool->sp_lock);
1015 }
J. Bruce Fieldscc630d92013-02-10 16:08:11 -05001016 return NULL;
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +04001017}
1018
J. Bruce Fieldscc630d92013-02-10 16:08:11 -05001019static void svc_clean_up_xprts(struct svc_serv *serv, struct net *net)
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +04001020{
1021 struct svc_xprt *xprt;
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +04001022
J. Bruce Fieldscc630d92013-02-10 16:08:11 -05001023 while ((xprt = svc_dequeue_net(serv, net))) {
1024 set_bit(XPT_CLOSE, &xprt->xpt_flags);
J. Bruce Fields719f8bc2012-08-13 17:03:00 -04001025 svc_delete_xprt(xprt);
J. Bruce Fieldscc630d92013-02-10 16:08:11 -05001026 }
Stanislav Kinsbursky3a22bf52012-01-31 14:09:08 +04001027}
1028
J. Bruce Fieldscc630d92013-02-10 16:08:11 -05001029/*
1030 * Server threads may still be running (especially in the case where the
1031 * service is still running in other network namespaces).
1032 *
1033 * So we shut down sockets the same way we would on a running server, by
1034 * setting XPT_CLOSE, enqueuing, and letting a thread pick it up to do
1035 * the close. In the case there are no such other threads,
1036 * threads running, svc_clean_up_xprts() does a simple version of a
1037 * server's main event loop, and in the case where there are other
1038 * threads, we may need to wait a little while and then check again to
1039 * see if they're done.
1040 */
Stanislav Kinsbursky7b147f12012-01-31 14:09:17 +04001041void svc_close_net(struct svc_serv *serv, struct net *net)
Stanislav Kinsbursky3a22bf52012-01-31 14:09:08 +04001042{
J. Bruce Fieldscc630d92013-02-10 16:08:11 -05001043 int delay = 0;
Stanislav Kinsbursky6f513362012-01-31 14:09:00 +04001044
J. Bruce Fieldscc630d92013-02-10 16:08:11 -05001045 while (svc_close_list(serv, &serv->sv_permsocks, net) +
1046 svc_close_list(serv, &serv->sv_tempsocks, net)) {
1047
1048 svc_clean_up_xprts(serv, net);
1049 msleep(delay++);
1050 }
J. Bruce Fields2fefb8a2011-11-29 11:35:35 -05001051}
1052
Tom Tucker0f0257e2007-12-30 21:08:27 -06001053/*
1054 * Handle defer and revisit of requests
1055 */
1056
1057static void svc_revisit(struct cache_deferred_req *dreq, int too_many)
1058{
1059 struct svc_deferred_req *dr =
1060 container_of(dreq, struct svc_deferred_req, handle);
1061 struct svc_xprt *xprt = dr->xprt;
1062
Tom Tucker22945e42009-01-05 15:21:19 -06001063 spin_lock(&xprt->xpt_lock);
1064 set_bit(XPT_DEFERRED, &xprt->xpt_flags);
1065 if (too_many || test_bit(XPT_DEAD, &xprt->xpt_flags)) {
1066 spin_unlock(&xprt->xpt_lock);
1067 dprintk("revisit canceled\n");
Tom Tucker0f0257e2007-12-30 21:08:27 -06001068 svc_xprt_put(xprt);
1069 kfree(dr);
1070 return;
1071 }
1072 dprintk("revisit queued\n");
1073 dr->xprt = NULL;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001074 list_add(&dr->handle.recent, &xprt->xpt_deferred);
1075 spin_unlock(&xprt->xpt_lock);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001076 svc_xprt_enqueue(xprt);
1077 svc_xprt_put(xprt);
1078}
1079
Tom Tucker260c1d12007-12-30 21:08:29 -06001080/*
1081 * Save the request off for later processing. The request buffer looks
1082 * like this:
1083 *
1084 * <xprt-header><rpc-header><rpc-pagelist><rpc-tail>
1085 *
1086 * This code can only handle requests that consist of an xprt-header
1087 * and rpc-header.
1088 */
Tom Tucker0f0257e2007-12-30 21:08:27 -06001089static struct cache_deferred_req *svc_defer(struct cache_req *req)
1090{
1091 struct svc_rqst *rqstp = container_of(req, struct svc_rqst, rq_chandle);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001092 struct svc_deferred_req *dr;
1093
Andy Adamson2f425872009-04-03 08:27:32 +03001094 if (rqstp->rq_arg.page_len || !rqstp->rq_usedeferral)
Tom Tucker0f0257e2007-12-30 21:08:27 -06001095 return NULL; /* if more than a page, give up FIXME */
1096 if (rqstp->rq_deferred) {
1097 dr = rqstp->rq_deferred;
1098 rqstp->rq_deferred = NULL;
1099 } else {
Tom Tucker260c1d12007-12-30 21:08:29 -06001100 size_t skip;
1101 size_t size;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001102 /* FIXME maybe discard if size too large */
Tom Tucker260c1d12007-12-30 21:08:29 -06001103 size = sizeof(struct svc_deferred_req) + rqstp->rq_arg.len;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001104 dr = kmalloc(size, GFP_KERNEL);
1105 if (dr == NULL)
1106 return NULL;
1107
1108 dr->handle.owner = rqstp->rq_server;
1109 dr->prot = rqstp->rq_prot;
1110 memcpy(&dr->addr, &rqstp->rq_addr, rqstp->rq_addrlen);
1111 dr->addrlen = rqstp->rq_addrlen;
1112 dr->daddr = rqstp->rq_daddr;
1113 dr->argslen = rqstp->rq_arg.len >> 2;
Tom Tucker260c1d12007-12-30 21:08:29 -06001114 dr->xprt_hlen = rqstp->rq_xprt_hlen;
1115
1116 /* back up head to the start of the buffer and copy */
1117 skip = rqstp->rq_arg.len - rqstp->rq_arg.head[0].iov_len;
1118 memcpy(dr->args, rqstp->rq_arg.head[0].iov_base - skip,
1119 dr->argslen << 2);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001120 }
1121 svc_xprt_get(rqstp->rq_xprt);
1122 dr->xprt = rqstp->rq_xprt;
J. Bruce Fields9e701c62011-01-02 21:56:36 -05001123 rqstp->rq_dropme = true;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001124
1125 dr->handle.revisit = svc_revisit;
1126 return &dr->handle;
1127}
1128
1129/*
1130 * recv data from a deferred request into an active one
1131 */
1132static int svc_deferred_recv(struct svc_rqst *rqstp)
1133{
1134 struct svc_deferred_req *dr = rqstp->rq_deferred;
1135
Tom Tucker260c1d12007-12-30 21:08:29 -06001136 /* setup iov_base past transport header */
1137 rqstp->rq_arg.head[0].iov_base = dr->args + (dr->xprt_hlen>>2);
1138 /* The iov_len does not include the transport header bytes */
1139 rqstp->rq_arg.head[0].iov_len = (dr->argslen<<2) - dr->xprt_hlen;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001140 rqstp->rq_arg.page_len = 0;
Tom Tucker260c1d12007-12-30 21:08:29 -06001141 /* The rq_arg.len includes the transport header bytes */
1142 rqstp->rq_arg.len = dr->argslen<<2;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001143 rqstp->rq_prot = dr->prot;
1144 memcpy(&rqstp->rq_addr, &dr->addr, dr->addrlen);
1145 rqstp->rq_addrlen = dr->addrlen;
Tom Tucker260c1d12007-12-30 21:08:29 -06001146 /* Save off transport header len in case we get deferred again */
1147 rqstp->rq_xprt_hlen = dr->xprt_hlen;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001148 rqstp->rq_daddr = dr->daddr;
1149 rqstp->rq_respages = rqstp->rq_pages;
Tom Tucker260c1d12007-12-30 21:08:29 -06001150 return (dr->argslen<<2) - dr->xprt_hlen;
Tom Tucker0f0257e2007-12-30 21:08:27 -06001151}
1152
1153
1154static struct svc_deferred_req *svc_deferred_dequeue(struct svc_xprt *xprt)
1155{
1156 struct svc_deferred_req *dr = NULL;
1157
1158 if (!test_bit(XPT_DEFERRED, &xprt->xpt_flags))
1159 return NULL;
1160 spin_lock(&xprt->xpt_lock);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001161 if (!list_empty(&xprt->xpt_deferred)) {
1162 dr = list_entry(xprt->xpt_deferred.next,
1163 struct svc_deferred_req,
1164 handle.recent);
1165 list_del_init(&dr->handle.recent);
J. Bruce Fields62bac4a2010-10-25 12:50:15 -04001166 } else
1167 clear_bit(XPT_DEFERRED, &xprt->xpt_flags);
Tom Tucker0f0257e2007-12-30 21:08:27 -06001168 spin_unlock(&xprt->xpt_lock);
1169 return dr;
1170}
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001171
Chuck Lever156e6202009-03-18 20:45:58 -04001172/**
1173 * svc_find_xprt - find an RPC transport instance
1174 * @serv: pointer to svc_serv to search
1175 * @xcl_name: C string containing transport's class name
Stanislav Kinsbursky4cb54ca2012-01-20 16:50:53 +04001176 * @net: owner net pointer
Chuck Lever156e6202009-03-18 20:45:58 -04001177 * @af: Address family of transport's local address
1178 * @port: transport's IP port number
1179 *
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001180 * Return the transport instance pointer for the endpoint accepting
1181 * connections/peer traffic from the specified transport class,
1182 * address family and port.
1183 *
1184 * Specifying 0 for the address family or port is effectively a
1185 * wild-card, and will result in matching the first transport in the
1186 * service's list that has a matching class name.
1187 */
Chuck Lever156e6202009-03-18 20:45:58 -04001188struct svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name,
Stanislav Kinsbursky4cb54ca2012-01-20 16:50:53 +04001189 struct net *net, const sa_family_t af,
1190 const unsigned short port)
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001191{
1192 struct svc_xprt *xprt;
1193 struct svc_xprt *found = NULL;
1194
1195 /* Sanity check the args */
Chuck Lever156e6202009-03-18 20:45:58 -04001196 if (serv == NULL || xcl_name == NULL)
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001197 return found;
1198
1199 spin_lock_bh(&serv->sv_lock);
1200 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
Stanislav Kinsbursky4cb54ca2012-01-20 16:50:53 +04001201 if (xprt->xpt_net != net)
1202 continue;
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001203 if (strcmp(xprt->xpt_class->xcl_name, xcl_name))
1204 continue;
1205 if (af != AF_UNSPEC && af != xprt->xpt_local.ss_family)
1206 continue;
Chuck Lever156e6202009-03-18 20:45:58 -04001207 if (port != 0 && port != svc_xprt_local_port(xprt))
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001208 continue;
1209 found = xprt;
Tom Tuckera2178132007-12-30 21:08:35 -06001210 svc_xprt_get(xprt);
Tom Tucker7fcb98d2007-12-30 21:08:33 -06001211 break;
1212 }
1213 spin_unlock_bh(&serv->sv_lock);
1214 return found;
1215}
1216EXPORT_SYMBOL_GPL(svc_find_xprt);
Tom Tucker9571af12007-12-30 21:08:37 -06001217
Chuck Lever335c54b2009-04-23 19:32:25 -04001218static int svc_one_xprt_name(const struct svc_xprt *xprt,
1219 char *pos, int remaining)
1220{
1221 int len;
1222
1223 len = snprintf(pos, remaining, "%s %u\n",
1224 xprt->xpt_class->xcl_name,
1225 svc_xprt_local_port(xprt));
1226 if (len >= remaining)
1227 return -ENAMETOOLONG;
1228 return len;
1229}
1230
1231/**
1232 * svc_xprt_names - format a buffer with a list of transport names
1233 * @serv: pointer to an RPC service
1234 * @buf: pointer to a buffer to be filled in
1235 * @buflen: length of buffer to be filled in
1236 *
1237 * Fills in @buf with a string containing a list of transport names,
1238 * each name terminated with '\n'.
1239 *
1240 * Returns positive length of the filled-in string on success; otherwise
1241 * a negative errno value is returned if an error occurs.
Tom Tucker9571af12007-12-30 21:08:37 -06001242 */
Chuck Lever335c54b2009-04-23 19:32:25 -04001243int svc_xprt_names(struct svc_serv *serv, char *buf, const int buflen)
Tom Tucker9571af12007-12-30 21:08:37 -06001244{
1245 struct svc_xprt *xprt;
Chuck Lever335c54b2009-04-23 19:32:25 -04001246 int len, totlen;
1247 char *pos;
Tom Tucker9571af12007-12-30 21:08:37 -06001248
1249 /* Sanity check args */
1250 if (!serv)
1251 return 0;
1252
1253 spin_lock_bh(&serv->sv_lock);
Chuck Lever335c54b2009-04-23 19:32:25 -04001254
1255 pos = buf;
1256 totlen = 0;
Tom Tucker9571af12007-12-30 21:08:37 -06001257 list_for_each_entry(xprt, &serv->sv_permsocks, xpt_list) {
Chuck Lever335c54b2009-04-23 19:32:25 -04001258 len = svc_one_xprt_name(xprt, pos, buflen - totlen);
1259 if (len < 0) {
1260 *buf = '\0';
1261 totlen = len;
1262 }
1263 if (len <= 0)
Tom Tucker9571af12007-12-30 21:08:37 -06001264 break;
Chuck Lever335c54b2009-04-23 19:32:25 -04001265
1266 pos += len;
Tom Tucker9571af12007-12-30 21:08:37 -06001267 totlen += len;
1268 }
Chuck Lever335c54b2009-04-23 19:32:25 -04001269
Tom Tucker9571af12007-12-30 21:08:37 -06001270 spin_unlock_bh(&serv->sv_lock);
1271 return totlen;
1272}
1273EXPORT_SYMBOL_GPL(svc_xprt_names);
Greg Banks03cf6c92009-01-13 21:26:36 +11001274
1275
1276/*----------------------------------------------------------------------------*/
1277
1278static void *svc_pool_stats_start(struct seq_file *m, loff_t *pos)
1279{
1280 unsigned int pidx = (unsigned int)*pos;
1281 struct svc_serv *serv = m->private;
1282
1283 dprintk("svc_pool_stats_start, *pidx=%u\n", pidx);
1284
Greg Banks03cf6c92009-01-13 21:26:36 +11001285 if (!pidx)
1286 return SEQ_START_TOKEN;
1287 return (pidx > serv->sv_nrpools ? NULL : &serv->sv_pools[pidx-1]);
1288}
1289
1290static void *svc_pool_stats_next(struct seq_file *m, void *p, loff_t *pos)
1291{
1292 struct svc_pool *pool = p;
1293 struct svc_serv *serv = m->private;
1294
1295 dprintk("svc_pool_stats_next, *pos=%llu\n", *pos);
1296
1297 if (p == SEQ_START_TOKEN) {
1298 pool = &serv->sv_pools[0];
1299 } else {
1300 unsigned int pidx = (pool - &serv->sv_pools[0]);
1301 if (pidx < serv->sv_nrpools-1)
1302 pool = &serv->sv_pools[pidx+1];
1303 else
1304 pool = NULL;
1305 }
1306 ++*pos;
1307 return pool;
1308}
1309
1310static void svc_pool_stats_stop(struct seq_file *m, void *p)
1311{
Greg Banks03cf6c92009-01-13 21:26:36 +11001312}
1313
1314static int svc_pool_stats_show(struct seq_file *m, void *p)
1315{
1316 struct svc_pool *pool = p;
1317
1318 if (p == SEQ_START_TOKEN) {
J. Bruce Fields78c210e2009-08-06 15:41:34 -04001319 seq_puts(m, "# pool packets-arrived sockets-enqueued threads-woken threads-timedout\n");
Greg Banks03cf6c92009-01-13 21:26:36 +11001320 return 0;
1321 }
1322
J. Bruce Fields78c210e2009-08-06 15:41:34 -04001323 seq_printf(m, "%u %lu %lu %lu %lu\n",
Greg Banks03cf6c92009-01-13 21:26:36 +11001324 pool->sp_id,
1325 pool->sp_stats.packets,
1326 pool->sp_stats.sockets_queued,
1327 pool->sp_stats.threads_woken,
Greg Banks03cf6c92009-01-13 21:26:36 +11001328 pool->sp_stats.threads_timedout);
1329
1330 return 0;
1331}
1332
1333static const struct seq_operations svc_pool_stats_seq_ops = {
1334 .start = svc_pool_stats_start,
1335 .next = svc_pool_stats_next,
1336 .stop = svc_pool_stats_stop,
1337 .show = svc_pool_stats_show,
1338};
1339
1340int svc_pool_stats_open(struct svc_serv *serv, struct file *file)
1341{
1342 int err;
1343
1344 err = seq_open(file, &svc_pool_stats_seq_ops);
1345 if (!err)
1346 ((struct seq_file *) file->private_data)->private = serv;
1347 return err;
1348}
1349EXPORT_SYMBOL(svc_pool_stats_open);
1350
1351/*----------------------------------------------------------------------------*/