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/sched/signal.h>
13 #include <linux/sunrpc/svc.h>
14 #include <linux/sunrpc/svcsock.h>
15 #include <linux/nfs_fs.h>
16 #include <linux/errno.h>
17 #include <linux/mutex.h>
18 #include <linux/freezer.h>
19 #include <linux/kthread.h>
20 #include <linux/sunrpc/svcauth_gss.h>
21 #include <linux/sunrpc/bc_xprt.h>
23 #include <net/inet_sock.h>
30 #define NFSDBG_FACILITY NFSDBG_CALLBACK
32 struct nfs_callback_data
{
34 struct svc_serv
*serv
;
37 static struct nfs_callback_data nfs_callback_info
[NFS4_MAX_MINOR_VERSION
+ 1];
38 static DEFINE_MUTEX(nfs_callback_mutex
);
39 static struct svc_program nfs4_callback_program
;
41 static int nfs4_callback_up_net(struct svc_serv
*serv
, struct net
*net
)
44 struct nfs_net
*nn
= net_generic(net
, nfs_net_id
);
46 ret
= svc_create_xprt(serv
, "tcp", net
, PF_INET
,
47 nfs_callback_set_tcpport
, SVC_SOCK_ANONYMOUS
);
50 nn
->nfs_callback_tcpport
= ret
;
51 dprintk("NFS: Callback listener port = %u (af %u, net %p)\n",
52 nn
->nfs_callback_tcpport
, PF_INET
, net
);
54 ret
= svc_create_xprt(serv
, "tcp", net
, PF_INET6
,
55 nfs_callback_set_tcpport
, SVC_SOCK_ANONYMOUS
);
57 nn
->nfs_callback_tcpport6
= ret
;
58 dprintk("NFS: Callback listener port = %u (af %u, net %p)\n",
59 nn
->nfs_callback_tcpport6
, PF_INET6
, net
);
60 } else if (ret
!= -EAFNOSUPPORT
)
65 return (ret
) ? ret
: -ENOMEM
;
69 * This is the NFSv4 callback kernel thread.
72 nfs4_callback_svc(void *vrqstp
)
75 struct svc_rqst
*rqstp
= vrqstp
;
79 while (!kthread_should_stop()) {
81 * Listen for a request on the socket
83 err
= svc_recv(rqstp
, MAX_SCHEDULE_TIMEOUT
);
84 if (err
== -EAGAIN
|| err
== -EINTR
)
91 #if defined(CONFIG_NFS_V4_1)
93 * The callback service for NFSv4.1 callbacks
96 nfs41_callback_svc(void *vrqstp
)
98 struct svc_rqst
*rqstp
= vrqstp
;
99 struct svc_serv
*serv
= rqstp
->rq_server
;
100 struct rpc_rqst
*req
;
106 while (!kthread_should_stop()) {
110 prepare_to_wait(&serv
->sv_cb_waitq
, &wq
, TASK_INTERRUPTIBLE
);
111 spin_lock_bh(&serv
->sv_cb_lock
);
112 if (!list_empty(&serv
->sv_cb_list
)) {
113 req
= list_first_entry(&serv
->sv_cb_list
,
114 struct rpc_rqst
, rq_bc_list
);
115 list_del(&req
->rq_bc_list
);
116 spin_unlock_bh(&serv
->sv_cb_lock
);
117 finish_wait(&serv
->sv_cb_waitq
, &wq
);
118 dprintk("Invoking bc_svc_process()\n");
119 error
= bc_svc_process(serv
, req
, rqstp
);
120 dprintk("bc_svc_process() returned w/ error code= %d\n",
123 spin_unlock_bh(&serv
->sv_cb_lock
);
125 finish_wait(&serv
->sv_cb_waitq
, &wq
);
127 flush_signals(current
);
132 static inline void nfs_callback_bc_serv(u32 minorversion
, struct rpc_xprt
*xprt
,
133 struct svc_serv
*serv
)
137 * Save the svc_serv in the transport so that it can
138 * be referenced when the session backchannel is initialized
140 xprt
->bc_serv
= serv
;
143 static inline void nfs_callback_bc_serv(u32 minorversion
, struct rpc_xprt
*xprt
,
144 struct svc_serv
*serv
)
147 #endif /* CONFIG_NFS_V4_1 */
149 static int nfs_callback_start_svc(int minorversion
, struct rpc_xprt
*xprt
,
150 struct svc_serv
*serv
)
152 int nrservs
= nfs_callback_nr_threads
;
155 nfs_callback_bc_serv(minorversion
, xprt
, serv
);
157 if (nrservs
< NFS4_MIN_NR_CALLBACK_THREADS
)
158 nrservs
= NFS4_MIN_NR_CALLBACK_THREADS
;
160 if (serv
->sv_nrthreads
-1 == nrservs
)
163 ret
= serv
->sv_ops
->svo_setup(serv
, NULL
, nrservs
);
165 serv
->sv_ops
->svo_setup(serv
, NULL
, 0);
168 dprintk("nfs_callback_up: service started\n");
172 static void nfs_callback_down_net(u32 minorversion
, struct svc_serv
*serv
, struct net
*net
)
174 struct nfs_net
*nn
= net_generic(net
, nfs_net_id
);
176 if (--nn
->cb_users
[minorversion
])
179 dprintk("NFS: destroy per-net callback data; net=%p\n", net
);
180 svc_shutdown_net(serv
, net
);
183 static int nfs_callback_up_net(int minorversion
, struct svc_serv
*serv
,
184 struct net
*net
, struct rpc_xprt
*xprt
)
186 struct nfs_net
*nn
= net_generic(net
, nfs_net_id
);
189 if (nn
->cb_users
[minorversion
]++)
192 dprintk("NFS: create per-net callback data; net=%p\n", net
);
194 ret
= svc_bind(serv
, net
);
196 printk(KERN_WARNING
"NFS: bind callback service failed\n");
200 ret
= -EPROTONOSUPPORT
;
201 if (!IS_ENABLED(CONFIG_NFS_V4_1
) || minorversion
== 0)
202 ret
= nfs4_callback_up_net(serv
, net
);
203 else if (xprt
->ops
->bc_up
)
204 ret
= xprt
->ops
->bc_up(serv
, net
);
207 printk(KERN_ERR
"NFS: callback service start failed\n");
213 svc_rpcb_cleanup(serv
, net
);
215 nn
->cb_users
[minorversion
]--;
216 dprintk("NFS: Couldn't create callback socket: err = %d; "
217 "net = %p\n", ret
, net
);
221 static struct svc_serv_ops nfs40_cb_sv_ops
= {
222 .svo_function
= nfs4_callback_svc
,
223 .svo_enqueue_xprt
= svc_xprt_do_enqueue
,
224 .svo_setup
= svc_set_num_threads
,
225 .svo_module
= THIS_MODULE
,
227 #if defined(CONFIG_NFS_V4_1)
228 static struct svc_serv_ops nfs41_cb_sv_ops
= {
229 .svo_function
= nfs41_callback_svc
,
230 .svo_enqueue_xprt
= svc_xprt_do_enqueue
,
231 .svo_setup
= svc_set_num_threads
,
232 .svo_module
= THIS_MODULE
,
235 struct svc_serv_ops
*nfs4_cb_sv_ops
[] = {
236 [0] = &nfs40_cb_sv_ops
,
237 [1] = &nfs41_cb_sv_ops
,
240 struct svc_serv_ops
*nfs4_cb_sv_ops
[] = {
241 [0] = &nfs40_cb_sv_ops
,
246 static struct svc_serv
*nfs_callback_create_svc(int minorversion
)
248 struct nfs_callback_data
*cb_info
= &nfs_callback_info
[minorversion
];
249 struct svc_serv
*serv
;
250 struct svc_serv_ops
*sv_ops
;
253 * Check whether we're already up and running.
257 * Note: increase service usage, because later in case of error
258 * svc_destroy() will be called.
260 svc_get(cb_info
->serv
);
261 return cb_info
->serv
;
264 switch (minorversion
) {
266 sv_ops
= nfs4_cb_sv_ops
[0];
269 sv_ops
= nfs4_cb_sv_ops
[1];
273 return ERR_PTR(-ENOTSUPP
);
276 * Sanity check: if there's no task,
277 * we should be the first user ...
280 printk(KERN_WARNING
"nfs_callback_create_svc: no kthread, %d users??\n",
283 serv
= svc_create(&nfs4_callback_program
, NFS4_CALLBACK_BUFSIZE
, sv_ops
);
285 printk(KERN_ERR
"nfs_callback_create_svc: create service failed\n");
286 return ERR_PTR(-ENOMEM
);
288 cb_info
->serv
= serv
;
289 /* As there is only one thread we need to over-ride the
290 * default maximum of 80 connections
292 serv
->sv_maxconn
= 1024;
293 dprintk("nfs_callback_create_svc: service created\n");
298 * Bring up the callback thread if it is not already up.
300 int nfs_callback_up(u32 minorversion
, struct rpc_xprt
*xprt
)
302 struct svc_serv
*serv
;
303 struct nfs_callback_data
*cb_info
= &nfs_callback_info
[minorversion
];
305 struct net
*net
= xprt
->xprt_net
;
307 mutex_lock(&nfs_callback_mutex
);
309 serv
= nfs_callback_create_svc(minorversion
);
315 ret
= nfs_callback_up_net(minorversion
, serv
, net
, xprt
);
319 ret
= nfs_callback_start_svc(minorversion
, xprt
, serv
);
325 * svc_create creates the svc_serv with sv_nrthreads == 1, and then
326 * svc_prepare_thread increments that. So we need to call svc_destroy
327 * on both success and failure so that the refcount is 1 when the
332 cb_info
->serv
= NULL
;
335 mutex_unlock(&nfs_callback_mutex
);
339 nfs_callback_down_net(minorversion
, serv
, net
);
340 dprintk("NFS: Couldn't create server thread; err = %d\n", ret
);
345 * Kill the callback thread if it's no longer being used.
347 void nfs_callback_down(int minorversion
, struct net
*net
)
349 struct nfs_callback_data
*cb_info
= &nfs_callback_info
[minorversion
];
350 struct svc_serv
*serv
;
352 mutex_lock(&nfs_callback_mutex
);
353 serv
= cb_info
->serv
;
354 nfs_callback_down_net(minorversion
, serv
, net
);
356 if (cb_info
->users
== 0) {
358 serv
->sv_ops
->svo_setup(serv
, NULL
, 0);
360 dprintk("nfs_callback_down: service destroyed\n");
361 cb_info
->serv
= NULL
;
363 mutex_unlock(&nfs_callback_mutex
);
366 /* Boolean check of RPC_AUTH_GSS principal */
368 check_gss_callback_principal(struct nfs_client
*clp
, struct svc_rqst
*rqstp
)
370 char *p
= rqstp
->rq_cred
.cr_principal
;
372 if (rqstp
->rq_authop
->flavour
!= RPC_AUTH_GSS
)
375 /* No RPC_AUTH_GSS on NFSv4.1 back channel yet */
376 if (clp
->cl_minorversion
!= 0)
379 * It might just be a normal user principal, in which case
380 * userspace won't bother to tell us the name at all.
386 * Did we get the acceptor from userland during the SETCLIENID
389 if (clp
->cl_acceptor
)
390 return !strcmp(p
, clp
->cl_acceptor
);
393 * Otherwise try to verify it using the cl_hostname. Note that this
394 * doesn't work if a non-canonical hostname was used in the devname.
397 /* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
399 if (memcmp(p
, "nfs@", 4) != 0)
402 if (strcmp(p
, clp
->cl_hostname
) != 0)
408 * pg_authenticate method for nfsv4 callback threads.
410 * The authflavor has been negotiated, so an incorrect flavor is a server
411 * bug. Deny packets with incorrect authflavor.
413 * All other checking done after NFS decoding where the nfs_client can be
414 * found in nfs4_callback_compound
416 static int nfs_callback_authenticate(struct svc_rqst
*rqstp
)
418 switch (rqstp
->rq_authop
->flavour
) {
420 if (rqstp
->rq_proc
!= CB_NULL
)
424 /* No RPC_AUTH_GSS support yet in NFSv4.1 */
425 if (svc_is_backchannel(rqstp
))
432 * Define NFS4 callback program
434 static struct svc_version
*nfs4_callback_version
[] = {
435 [1] = &nfs4_callback_version1
,
436 [4] = &nfs4_callback_version4
,
439 static struct svc_stat nfs4_callback_stats
;
441 static struct svc_program nfs4_callback_program
= {
442 .pg_prog
= NFS4_CALLBACK
, /* RPC service number */
443 .pg_nvers
= ARRAY_SIZE(nfs4_callback_version
), /* Number of entries */
444 .pg_vers
= nfs4_callback_version
, /* version table */
445 .pg_name
= "NFSv4 callback", /* service name */
446 .pg_class
= "nfs", /* authentication class */
447 .pg_stats
= &nfs4_callback_stats
,
448 .pg_authenticate
= nfs_callback_authenticate
,