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/mutex.h>
16 #include <linux/freezer.h>
17 #include <linux/kthread.h>
18 #include <linux/sunrpc/svcauth_gss.h>
19 #if defined(CONFIG_NFS_V4_1)
20 #include <linux/sunrpc/bc_xprt.h>
23 #include <net/inet_sock.h>
29 #define NFSDBG_FACILITY NFSDBG_CALLBACK
31 struct nfs_callback_data
{
33 struct svc_serv
*serv
;
34 struct svc_rqst
*rqst
;
35 struct task_struct
*task
;
38 static struct nfs_callback_data nfs_callback_info
[NFS4_MAX_MINOR_VERSION
+ 1];
39 static DEFINE_MUTEX(nfs_callback_mutex
);
40 static struct svc_program nfs4_callback_program
;
42 unsigned int nfs_callback_set_tcpport
;
43 unsigned short nfs_callback_tcpport
;
44 unsigned short nfs_callback_tcpport6
;
45 #define NFS_CALLBACK_MAXPORTNR (65535U)
47 static int param_set_portnr(const char *val
, const struct kernel_param
*kp
)
54 ret
= strict_strtoul(val
, 0, &num
);
55 if (ret
== -EINVAL
|| num
> NFS_CALLBACK_MAXPORTNR
)
57 *((unsigned int *)kp
->arg
) = num
;
60 static struct kernel_param_ops param_ops_portnr
= {
61 .set
= param_set_portnr
,
62 .get
= param_get_uint
,
64 #define param_check_portnr(name, p) __param_check(name, p, unsigned int);
66 module_param_named(callback_tcpport
, nfs_callback_set_tcpport
, portnr
, 0644);
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
) {
90 printk(KERN_WARNING
"%s: unexpected error "
91 "from svc_recv (%d)\n", __func__
, err
);
94 schedule_timeout_uninterruptible(HZ
);
104 * Prepare to bring up the NFSv4 callback service
107 nfs4_callback_up(struct svc_serv
*serv
)
111 ret
= svc_create_xprt(serv
, "tcp", &init_net
, PF_INET
,
112 nfs_callback_set_tcpport
, SVC_SOCK_ANONYMOUS
);
115 nfs_callback_tcpport
= ret
;
116 dprintk("NFS: Callback listener port = %u (af %u)\n",
117 nfs_callback_tcpport
, PF_INET
);
119 ret
= svc_create_xprt(serv
, "tcp", &init_net
, PF_INET6
,
120 nfs_callback_set_tcpport
, SVC_SOCK_ANONYMOUS
);
122 nfs_callback_tcpport6
= ret
;
123 dprintk("NFS: Callback listener port = %u (af %u)\n",
124 nfs_callback_tcpport6
, PF_INET6
);
125 } else if (ret
== -EAFNOSUPPORT
)
130 return svc_prepare_thread(serv
, &serv
->sv_pools
[0]);
138 #if defined(CONFIG_NFS_V4_1)
140 * The callback service for NFSv4.1 callbacks
143 nfs41_callback_svc(void *vrqstp
)
145 struct svc_rqst
*rqstp
= vrqstp
;
146 struct svc_serv
*serv
= rqstp
->rq_server
;
147 struct rpc_rqst
*req
;
153 while (!kthread_should_stop()) {
154 prepare_to_wait(&serv
->sv_cb_waitq
, &wq
, TASK_INTERRUPTIBLE
);
155 spin_lock_bh(&serv
->sv_cb_lock
);
156 if (!list_empty(&serv
->sv_cb_list
)) {
157 req
= list_first_entry(&serv
->sv_cb_list
,
158 struct rpc_rqst
, rq_bc_list
);
159 list_del(&req
->rq_bc_list
);
160 spin_unlock_bh(&serv
->sv_cb_lock
);
161 dprintk("Invoking bc_svc_process()\n");
162 error
= bc_svc_process(serv
, req
, rqstp
);
163 dprintk("bc_svc_process() returned w/ error code= %d\n",
166 spin_unlock_bh(&serv
->sv_cb_lock
);
169 finish_wait(&serv
->sv_cb_waitq
, &wq
);
175 * Bring up the NFSv4.1 callback service
178 nfs41_callback_up(struct svc_serv
*serv
, struct rpc_xprt
*xprt
)
180 struct svc_xprt
*bc_xprt
;
181 struct svc_rqst
*rqstp
= ERR_PTR(-ENOMEM
);
183 dprintk("--> %s\n", __func__
);
184 /* Create a svc_sock for the service */
185 bc_xprt
= svc_sock_create(serv
, xprt
->prot
);
190 * Save the svc_serv in the transport so that it can
191 * be referenced when the session backchannel is initialized
193 serv
->bc_xprt
= bc_xprt
;
194 xprt
->bc_serv
= serv
;
196 INIT_LIST_HEAD(&serv
->sv_cb_list
);
197 spin_lock_init(&serv
->sv_cb_lock
);
198 init_waitqueue_head(&serv
->sv_cb_waitq
);
199 rqstp
= svc_prepare_thread(serv
, &serv
->sv_pools
[0]);
201 svc_sock_destroy(bc_xprt
);
203 dprintk("--> %s return %p\n", __func__
, rqstp
);
207 static inline int nfs_minorversion_callback_svc_setup(u32 minorversion
,
208 struct svc_serv
*serv
, struct rpc_xprt
*xprt
,
209 struct svc_rqst
**rqstpp
, int (**callback_svc
)(void *vrqstp
))
212 *rqstpp
= nfs41_callback_up(serv
, xprt
);
213 *callback_svc
= nfs41_callback_svc
;
218 static inline void nfs_callback_bc_serv(u32 minorversion
, struct rpc_xprt
*xprt
,
219 struct nfs_callback_data
*cb_info
)
222 xprt
->bc_serv
= cb_info
->serv
;
225 static inline int nfs_minorversion_callback_svc_setup(u32 minorversion
,
226 struct svc_serv
*serv
, struct rpc_xprt
*xprt
,
227 struct svc_rqst
**rqstpp
, int (**callback_svc
)(void *vrqstp
))
232 static inline void nfs_callback_bc_serv(u32 minorversion
, struct rpc_xprt
*xprt
,
233 struct nfs_callback_data
*cb_info
)
236 #endif /* CONFIG_NFS_V4_1 */
239 * Bring up the callback thread if it is not already up.
241 int nfs_callback_up(u32 minorversion
, struct rpc_xprt
*xprt
)
243 struct svc_serv
*serv
= NULL
;
244 struct svc_rqst
*rqstp
;
245 int (*callback_svc
)(void *vrqstp
);
246 struct nfs_callback_data
*cb_info
= &nfs_callback_info
[minorversion
];
249 int minorversion_setup
;
251 mutex_lock(&nfs_callback_mutex
);
252 if (cb_info
->users
++ || cb_info
->task
!= NULL
) {
253 nfs_callback_bc_serv(minorversion
, xprt
, cb_info
);
256 serv
= svc_create(&nfs4_callback_program
, NFS4_CALLBACK_BUFSIZE
, NULL
);
262 minorversion_setup
= nfs_minorversion_callback_svc_setup(minorversion
,
263 serv
, xprt
, &rqstp
, &callback_svc
);
264 if (!minorversion_setup
) {
265 /* v4.0 callback setup */
266 rqstp
= nfs4_callback_up(serv
);
267 callback_svc
= nfs4_callback_svc
;
271 ret
= PTR_ERR(rqstp
);
275 svc_sock_update_bufs(serv
);
277 sprintf(svc_name
, "nfsv4.%u-svc", minorversion
);
278 cb_info
->serv
= serv
;
279 cb_info
->rqst
= rqstp
;
280 cb_info
->task
= kthread_run(callback_svc
, cb_info
->rqst
, svc_name
);
281 if (IS_ERR(cb_info
->task
)) {
282 ret
= PTR_ERR(cb_info
->task
);
283 svc_exit_thread(cb_info
->rqst
);
284 cb_info
->rqst
= NULL
;
285 cb_info
->task
= NULL
;
290 * svc_create creates the svc_serv with sv_nrthreads == 1, and then
291 * svc_prepare_thread increments that. So we need to call svc_destroy
292 * on both success and failure so that the refcount is 1 when the
297 mutex_unlock(&nfs_callback_mutex
);
300 dprintk("NFS: Couldn't create callback socket or server thread; "
307 * Kill the callback thread if it's no longer being used.
309 void nfs_callback_down(int minorversion
)
311 struct nfs_callback_data
*cb_info
= &nfs_callback_info
[minorversion
];
313 mutex_lock(&nfs_callback_mutex
);
315 if (cb_info
->users
== 0 && cb_info
->task
!= NULL
) {
316 kthread_stop(cb_info
->task
);
317 svc_exit_thread(cb_info
->rqst
);
318 cb_info
->serv
= NULL
;
319 cb_info
->rqst
= NULL
;
320 cb_info
->task
= NULL
;
322 mutex_unlock(&nfs_callback_mutex
);
325 static int check_gss_callback_principal(struct nfs_client
*clp
,
326 struct svc_rqst
*rqstp
)
328 struct rpc_clnt
*r
= clp
->cl_rpcclient
;
329 char *p
= svc_gss_principal(rqstp
);
332 * It might just be a normal user principal, in which case
333 * userspace won't bother to tell us the name at all.
338 /* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
340 if (memcmp(p
, "nfs@", 4) != 0)
343 if (strcmp(p
, r
->cl_server
) != 0)
348 static int nfs_callback_authenticate(struct svc_rqst
*rqstp
)
350 struct nfs_client
*clp
;
351 RPC_IFDEBUG(char buf
[RPC_MAX_ADDRBUFLEN
]);
354 /* Don't talk to strangers */
355 clp
= nfs_find_client(svc_addr(rqstp
), 4);
359 dprintk("%s: %s NFSv4 callback!\n", __func__
,
360 svc_print_addr(rqstp
, buf
, sizeof(buf
)));
362 switch (rqstp
->rq_authop
->flavour
) {
364 if (rqstp
->rq_proc
!= CB_NULL
)
370 ret
= check_gss_callback_principal(clp
, rqstp
);
380 * Define NFS4 callback program
382 static struct svc_version
*nfs4_callback_version
[] = {
383 [1] = &nfs4_callback_version1
,
384 [4] = &nfs4_callback_version4
,
387 static struct svc_stat nfs4_callback_stats
;
389 static struct svc_program nfs4_callback_program
= {
390 .pg_prog
= NFS4_CALLBACK
, /* RPC service number */
391 .pg_nvers
= ARRAY_SIZE(nfs4_callback_version
), /* Number of entries */
392 .pg_vers
= nfs4_callback_version
, /* version table */
393 .pg_name
= "NFSv4 callback", /* service name */
394 .pg_class
= "nfs", /* authentication class */
395 .pg_stats
= &nfs4_callback_stats
,
396 .pg_authenticate
= nfs_callback_authenticate
,