2 * linux/fs/nfs/callback.c
4 * Copyright (C) 2004 Trond Myklebust
6 * NFSv4 callback handling
9 #include <linux/completion.h>
11 #include <linux/module.h>
12 #include <linux/sunrpc/svc.h>
13 #include <linux/sunrpc/svcsock.h>
14 #include <linux/nfs_fs.h>
15 #include <linux/errno.h>
16 #include <linux/mutex.h>
17 #include <linux/freezer.h>
18 #include <linux/kthread.h>
19 #include <linux/sunrpc/svcauth_gss.h>
20 #include <linux/sunrpc/bc_xprt.h>
22 #include <net/inet_sock.h>
29 #define NFSDBG_FACILITY NFSDBG_CALLBACK
31 struct nfs_callback_data {
33 struct svc_serv *serv;
36 static struct nfs_callback_data nfs_callback_info[NFS4_MAX_MINOR_VERSION + 1];
37 static DEFINE_MUTEX(nfs_callback_mutex);
38 static struct svc_program nfs4_callback_program;
40 static int nfs4_callback_up_net(struct svc_serv *serv, struct net *net)
43 struct nfs_net *nn = net_generic(net, nfs_net_id);
45 ret = svc_create_xprt(serv, "tcp", net, PF_INET,
46 nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
49 nn->nfs_callback_tcpport = ret;
50 dprintk("NFS: Callback listener port = %u (af %u, net %p)\n",
51 nn->nfs_callback_tcpport, PF_INET, net);
53 ret = svc_create_xprt(serv, "tcp", net, PF_INET6,
54 nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
56 nn->nfs_callback_tcpport6 = ret;
57 dprintk("NFS: Callback listener port = %u (af %u, net %p)\n",
58 nn->nfs_callback_tcpport6, PF_INET6, net);
59 } else if (ret != -EAFNOSUPPORT)
64 return (ret) ? ret : -ENOMEM;
68 * This is the NFSv4 callback kernel thread.
71 nfs4_callback_svc(void *vrqstp)
74 struct svc_rqst *rqstp = vrqstp;
78 while (!kthread_freezable_should_stop(NULL)) {
80 if (signal_pending(current))
81 flush_signals(current);
83 * Listen for a request on the socket
85 err = svc_recv(rqstp, MAX_SCHEDULE_TIMEOUT);
86 if (err == -EAGAIN || err == -EINTR)
90 svc_exit_thread(rqstp);
91 module_put_and_exit(0);
95 #if defined(CONFIG_NFS_V4_1)
97 * The callback service for NFSv4.1 callbacks
100 nfs41_callback_svc(void *vrqstp)
102 struct svc_rqst *rqstp = vrqstp;
103 struct svc_serv *serv = rqstp->rq_server;
104 struct rpc_rqst *req;
110 while (!kthread_freezable_should_stop(NULL)) {
112 if (signal_pending(current))
113 flush_signals(current);
115 prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE);
116 spin_lock_bh(&serv->sv_cb_lock);
117 if (!list_empty(&serv->sv_cb_list)) {
118 req = list_first_entry(&serv->sv_cb_list,
119 struct rpc_rqst, rq_bc_list);
120 list_del(&req->rq_bc_list);
121 spin_unlock_bh(&serv->sv_cb_lock);
122 finish_wait(&serv->sv_cb_waitq, &wq);
123 dprintk("Invoking bc_svc_process()\n");
124 error = bc_svc_process(serv, req, rqstp);
125 dprintk("bc_svc_process() returned w/ error code= %d\n",
128 spin_unlock_bh(&serv->sv_cb_lock);
129 if (!kthread_should_stop())
131 finish_wait(&serv->sv_cb_waitq, &wq);
134 svc_exit_thread(rqstp);
135 module_put_and_exit(0);
139 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
140 struct svc_serv *serv)
144 * Save the svc_serv in the transport so that it can
145 * be referenced when the session backchannel is initialized
147 xprt->bc_serv = serv;
150 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
151 struct svc_serv *serv)
154 #endif /* CONFIG_NFS_V4_1 */
156 static int nfs_callback_start_svc(int minorversion, struct rpc_xprt *xprt,
157 struct svc_serv *serv)
159 int nrservs = nfs_callback_nr_threads;
162 nfs_callback_bc_serv(minorversion, xprt, serv);
164 if (nrservs < NFS4_MIN_NR_CALLBACK_THREADS)
165 nrservs = NFS4_MIN_NR_CALLBACK_THREADS;
167 if (serv->sv_nrthreads-1 == nrservs)
170 ret = serv->sv_ops->svo_setup(serv, NULL, nrservs);
172 serv->sv_ops->svo_setup(serv, NULL, 0);
175 dprintk("nfs_callback_up: service started\n");
179 static void nfs_callback_down_net(u32 minorversion, struct svc_serv *serv, struct net *net)
181 struct nfs_net *nn = net_generic(net, nfs_net_id);
183 if (--nn->cb_users[minorversion])
186 dprintk("NFS: destroy per-net callback data; net=%p\n", net);
187 svc_shutdown_net(serv, net);
190 static int nfs_callback_up_net(int minorversion, struct svc_serv *serv,
191 struct net *net, struct rpc_xprt *xprt)
193 struct nfs_net *nn = net_generic(net, nfs_net_id);
196 if (nn->cb_users[minorversion]++)
199 dprintk("NFS: create per-net callback data; net=%p\n", net);
201 ret = svc_bind(serv, net);
203 printk(KERN_WARNING "NFS: bind callback service failed\n");
207 ret = -EPROTONOSUPPORT;
208 if (!IS_ENABLED(CONFIG_NFS_V4_1) || minorversion == 0)
209 ret = nfs4_callback_up_net(serv, net);
210 else if (xprt->ops->bc_up)
211 ret = xprt->ops->bc_up(serv, net);
214 printk(KERN_ERR "NFS: callback service start failed\n");
220 svc_rpcb_cleanup(serv, net);
222 nn->cb_users[minorversion]--;
223 dprintk("NFS: Couldn't create callback socket: err = %d; "
224 "net = %p\n", ret, net);
228 static struct svc_serv_ops nfs40_cb_sv_ops = {
229 .svo_function = nfs4_callback_svc,
230 .svo_enqueue_xprt = svc_xprt_do_enqueue,
231 .svo_setup = svc_set_num_threads_sync,
232 .svo_module = THIS_MODULE,
234 #if defined(CONFIG_NFS_V4_1)
235 static struct svc_serv_ops nfs41_cb_sv_ops = {
236 .svo_function = nfs41_callback_svc,
237 .svo_enqueue_xprt = svc_xprt_do_enqueue,
238 .svo_setup = svc_set_num_threads_sync,
239 .svo_module = THIS_MODULE,
242 static struct svc_serv_ops *nfs4_cb_sv_ops[] = {
243 [0] = &nfs40_cb_sv_ops,
244 [1] = &nfs41_cb_sv_ops,
247 static struct svc_serv_ops *nfs4_cb_sv_ops[] = {
248 [0] = &nfs40_cb_sv_ops,
253 static struct svc_serv *nfs_callback_create_svc(int minorversion)
255 struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
256 struct svc_serv *serv;
257 struct svc_serv_ops *sv_ops;
260 * Check whether we're already up and running.
264 * Note: increase service usage, because later in case of error
265 * svc_destroy() will be called.
267 svc_get(cb_info->serv);
268 return cb_info->serv;
271 switch (minorversion) {
273 sv_ops = nfs4_cb_sv_ops[0];
276 sv_ops = nfs4_cb_sv_ops[1];
280 return ERR_PTR(-ENOTSUPP);
283 * Sanity check: if there's no task,
284 * we should be the first user ...
287 printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n",
290 serv = svc_create_pooled(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, sv_ops);
292 printk(KERN_ERR "nfs_callback_create_svc: create service failed\n");
293 return ERR_PTR(-ENOMEM);
295 cb_info->serv = serv;
296 /* As there is only one thread we need to over-ride the
297 * default maximum of 80 connections
299 serv->sv_maxconn = 1024;
300 dprintk("nfs_callback_create_svc: service created\n");
305 * Bring up the callback thread if it is not already up.
307 int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
309 struct svc_serv *serv;
310 struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
312 struct net *net = xprt->xprt_net;
314 mutex_lock(&nfs_callback_mutex);
316 serv = nfs_callback_create_svc(minorversion);
322 ret = nfs_callback_up_net(minorversion, serv, net, xprt);
326 ret = nfs_callback_start_svc(minorversion, xprt, serv);
332 * svc_create creates the svc_serv with sv_nrthreads == 1, and then
333 * svc_prepare_thread increments that. So we need to call svc_destroy
334 * on both success and failure so that the refcount is 1 when the
339 cb_info->serv = NULL;
342 mutex_unlock(&nfs_callback_mutex);
346 nfs_callback_down_net(minorversion, serv, net);
347 dprintk("NFS: Couldn't create server thread; err = %d\n", ret);
352 * Kill the callback thread if it's no longer being used.
354 void nfs_callback_down(int minorversion, struct net *net)
356 struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
357 struct svc_serv *serv;
359 mutex_lock(&nfs_callback_mutex);
360 serv = cb_info->serv;
361 nfs_callback_down_net(minorversion, serv, net);
363 if (cb_info->users == 0) {
365 serv->sv_ops->svo_setup(serv, NULL, 0);
367 dprintk("nfs_callback_down: service destroyed\n");
368 cb_info->serv = NULL;
370 mutex_unlock(&nfs_callback_mutex);
373 /* Boolean check of RPC_AUTH_GSS principal */
375 check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp)
377 char *p = rqstp->rq_cred.cr_principal;
379 if (rqstp->rq_authop->flavour != RPC_AUTH_GSS)
382 /* No RPC_AUTH_GSS on NFSv4.1 back channel yet */
383 if (clp->cl_minorversion != 0)
386 * It might just be a normal user principal, in which case
387 * userspace won't bother to tell us the name at all.
393 * Did we get the acceptor from userland during the SETCLIENID
396 if (clp->cl_acceptor)
397 return !strcmp(p, clp->cl_acceptor);
400 * Otherwise try to verify it using the cl_hostname. Note that this
401 * doesn't work if a non-canonical hostname was used in the devname.
404 /* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
406 if (memcmp(p, "nfs@", 4) != 0)
409 if (strcmp(p, clp->cl_hostname) != 0)
415 * pg_authenticate method for nfsv4 callback threads.
417 * The authflavor has been negotiated, so an incorrect flavor is a server
418 * bug. Deny packets with incorrect authflavor.
420 * All other checking done after NFS decoding where the nfs_client can be
421 * found in nfs4_callback_compound
423 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
425 switch (rqstp->rq_authop->flavour) {
427 if (rqstp->rq_proc != CB_NULL)
431 /* No RPC_AUTH_GSS support yet in NFSv4.1 */
432 if (svc_is_backchannel(rqstp))
439 * Define NFS4 callback program
441 static struct svc_version *nfs4_callback_version[] = {
442 [1] = &nfs4_callback_version1,
443 [4] = &nfs4_callback_version4,
446 static struct svc_stat nfs4_callback_stats;
448 static struct svc_program nfs4_callback_program = {
449 .pg_prog = NFS4_CALLBACK, /* RPC service number */
450 .pg_nvers = ARRAY_SIZE(nfs4_callback_version), /* Number of entries */
451 .pg_vers = nfs4_callback_version, /* version table */
452 .pg_name = "NFSv4 callback", /* service name */
453 .pg_class = "nfs", /* authentication class */
454 .pg_stats = &nfs4_callback_stats,
455 .pg_authenticate = nfs_callback_authenticate,