xref: /openbmc/linux/fs/nfs/callback.c (revision 609e478b)
1 /*
2  * linux/fs/nfs/callback.c
3  *
4  * Copyright (C) 2004 Trond Myklebust
5  *
6  * NFSv4 callback handling
7  */
8 
9 #include <linux/completion.h>
10 #include <linux/ip.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>
21 
22 #include <net/inet_sock.h>
23 
24 #include "nfs4_fs.h"
25 #include "callback.h"
26 #include "internal.h"
27 #include "netns.h"
28 
29 #define NFSDBG_FACILITY NFSDBG_CALLBACK
30 
31 struct nfs_callback_data {
32 	unsigned int users;
33 	struct svc_serv *serv;
34 	struct svc_rqst *rqst;
35 	struct task_struct *task;
36 };
37 
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;
41 
42 static int nfs4_callback_up_net(struct svc_serv *serv, struct net *net)
43 {
44 	int ret;
45 	struct nfs_net *nn = net_generic(net, nfs_net_id);
46 
47 	ret = svc_create_xprt(serv, "tcp", net, PF_INET,
48 				nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
49 	if (ret <= 0)
50 		goto out_err;
51 	nn->nfs_callback_tcpport = ret;
52 	dprintk("NFS: Callback listener port = %u (af %u, net %p)\n",
53 			nn->nfs_callback_tcpport, PF_INET, net);
54 
55 	ret = svc_create_xprt(serv, "tcp", net, PF_INET6,
56 				nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
57 	if (ret > 0) {
58 		nn->nfs_callback_tcpport6 = ret;
59 		dprintk("NFS: Callback listener port = %u (af %u, net %p)\n",
60 				nn->nfs_callback_tcpport6, PF_INET6, net);
61 	} else if (ret != -EAFNOSUPPORT)
62 		goto out_err;
63 	return 0;
64 
65 out_err:
66 	return (ret) ? ret : -ENOMEM;
67 }
68 
69 /*
70  * This is the NFSv4 callback kernel thread.
71  */
72 static int
73 nfs4_callback_svc(void *vrqstp)
74 {
75 	int err;
76 	struct svc_rqst *rqstp = vrqstp;
77 
78 	set_freezable();
79 
80 	while (!kthread_should_stop()) {
81 		/*
82 		 * Listen for a request on the socket
83 		 */
84 		err = svc_recv(rqstp, MAX_SCHEDULE_TIMEOUT);
85 		if (err == -EAGAIN || err == -EINTR)
86 			continue;
87 		svc_process(rqstp);
88 	}
89 	return 0;
90 }
91 
92 /*
93  * Prepare to bring up the NFSv4 callback service
94  */
95 static struct svc_rqst *
96 nfs4_callback_up(struct svc_serv *serv)
97 {
98 	return svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
99 }
100 
101 #if defined(CONFIG_NFS_V4_1)
102 static int nfs41_callback_up_net(struct svc_serv *serv, struct net *net)
103 {
104 	/*
105 	 * Create an svc_sock for the back channel service that shares the
106 	 * fore channel connection.
107 	 * Returns the input port (0) and sets the svc_serv bc_xprt on success
108 	 */
109 	return svc_create_xprt(serv, "tcp-bc", net, PF_INET, 0,
110 			      SVC_SOCK_ANONYMOUS);
111 }
112 
113 /*
114  * The callback service for NFSv4.1 callbacks
115  */
116 static int
117 nfs41_callback_svc(void *vrqstp)
118 {
119 	struct svc_rqst *rqstp = vrqstp;
120 	struct svc_serv *serv = rqstp->rq_server;
121 	struct rpc_rqst *req;
122 	int error;
123 	DEFINE_WAIT(wq);
124 
125 	set_freezable();
126 
127 	while (!kthread_should_stop()) {
128 		if (try_to_freeze())
129 			continue;
130 
131 		prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE);
132 		spin_lock_bh(&serv->sv_cb_lock);
133 		if (!list_empty(&serv->sv_cb_list)) {
134 			req = list_first_entry(&serv->sv_cb_list,
135 					struct rpc_rqst, rq_bc_list);
136 			list_del(&req->rq_bc_list);
137 			spin_unlock_bh(&serv->sv_cb_lock);
138 			dprintk("Invoking bc_svc_process()\n");
139 			error = bc_svc_process(serv, req, rqstp);
140 			dprintk("bc_svc_process() returned w/ error code= %d\n",
141 				error);
142 		} else {
143 			spin_unlock_bh(&serv->sv_cb_lock);
144 			schedule();
145 		}
146 		finish_wait(&serv->sv_cb_waitq, &wq);
147 	}
148 	return 0;
149 }
150 
151 /*
152  * Bring up the NFSv4.1 callback service
153  */
154 static struct svc_rqst *
155 nfs41_callback_up(struct svc_serv *serv)
156 {
157 	struct svc_rqst *rqstp;
158 
159 	INIT_LIST_HEAD(&serv->sv_cb_list);
160 	spin_lock_init(&serv->sv_cb_lock);
161 	init_waitqueue_head(&serv->sv_cb_waitq);
162 	rqstp = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
163 	if (IS_ERR(rqstp)) {
164 		svc_xprt_put(serv->sv_bc_xprt);
165 		serv->sv_bc_xprt = NULL;
166 	}
167 	dprintk("--> %s return %d\n", __func__, PTR_ERR_OR_ZERO(rqstp));
168 	return rqstp;
169 }
170 
171 static void nfs_minorversion_callback_svc_setup(struct svc_serv *serv,
172 		struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
173 {
174 	*rqstpp = nfs41_callback_up(serv);
175 	*callback_svc = nfs41_callback_svc;
176 }
177 
178 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
179 		struct svc_serv *serv)
180 {
181 	if (minorversion)
182 		/*
183 		 * Save the svc_serv in the transport so that it can
184 		 * be referenced when the session backchannel is initialized
185 		 */
186 		xprt->bc_serv = serv;
187 }
188 #else
189 static int nfs41_callback_up_net(struct svc_serv *serv, struct net *net)
190 {
191 	return 0;
192 }
193 
194 static void nfs_minorversion_callback_svc_setup(struct svc_serv *serv,
195 		struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
196 {
197 	*rqstpp = ERR_PTR(-ENOTSUPP);
198 	*callback_svc = ERR_PTR(-ENOTSUPP);
199 }
200 
201 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
202 		struct svc_serv *serv)
203 {
204 }
205 #endif /* CONFIG_NFS_V4_1 */
206 
207 static int nfs_callback_start_svc(int minorversion, struct rpc_xprt *xprt,
208 				  struct svc_serv *serv)
209 {
210 	struct svc_rqst *rqstp;
211 	int (*callback_svc)(void *vrqstp);
212 	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
213 	int ret;
214 
215 	nfs_callback_bc_serv(minorversion, xprt, serv);
216 
217 	if (cb_info->task)
218 		return 0;
219 
220 	switch (minorversion) {
221 	case 0:
222 		/* v4.0 callback setup */
223 		rqstp = nfs4_callback_up(serv);
224 		callback_svc = nfs4_callback_svc;
225 		break;
226 	default:
227 		nfs_minorversion_callback_svc_setup(serv,
228 				&rqstp, &callback_svc);
229 	}
230 
231 	if (IS_ERR(rqstp))
232 		return PTR_ERR(rqstp);
233 
234 	svc_sock_update_bufs(serv);
235 
236 	cb_info->serv = serv;
237 	cb_info->rqst = rqstp;
238 	cb_info->task = kthread_create(callback_svc, cb_info->rqst,
239 				    "nfsv4.%u-svc", minorversion);
240 	if (IS_ERR(cb_info->task)) {
241 		ret = PTR_ERR(cb_info->task);
242 		svc_exit_thread(cb_info->rqst);
243 		cb_info->rqst = NULL;
244 		cb_info->task = NULL;
245 		return ret;
246 	}
247 	rqstp->rq_task = cb_info->task;
248 	wake_up_process(cb_info->task);
249 	dprintk("nfs_callback_up: service started\n");
250 	return 0;
251 }
252 
253 static void nfs_callback_down_net(u32 minorversion, struct svc_serv *serv, struct net *net)
254 {
255 	struct nfs_net *nn = net_generic(net, nfs_net_id);
256 
257 	if (--nn->cb_users[minorversion])
258 		return;
259 
260 	dprintk("NFS: destroy per-net callback data; net=%p\n", net);
261 	svc_shutdown_net(serv, net);
262 }
263 
264 static int nfs_callback_up_net(int minorversion, struct svc_serv *serv, struct net *net)
265 {
266 	struct nfs_net *nn = net_generic(net, nfs_net_id);
267 	int ret;
268 
269 	if (nn->cb_users[minorversion]++)
270 		return 0;
271 
272 	dprintk("NFS: create per-net callback data; net=%p\n", net);
273 
274 	ret = svc_bind(serv, net);
275 	if (ret < 0) {
276 		printk(KERN_WARNING "NFS: bind callback service failed\n");
277 		goto err_bind;
278 	}
279 
280 	switch (minorversion) {
281 		case 0:
282 			ret = nfs4_callback_up_net(serv, net);
283 			break;
284 		case 1:
285 		case 2:
286 			ret = nfs41_callback_up_net(serv, net);
287 			break;
288 		default:
289 			printk(KERN_ERR "NFS: unknown callback version: %d\n",
290 					minorversion);
291 			ret = -EINVAL;
292 			break;
293 	}
294 
295 	if (ret < 0) {
296 		printk(KERN_ERR "NFS: callback service start failed\n");
297 		goto err_socks;
298 	}
299 	return 0;
300 
301 err_socks:
302 	svc_rpcb_cleanup(serv, net);
303 err_bind:
304 	dprintk("NFS: Couldn't create callback socket: err = %d; "
305 			"net = %p\n", ret, net);
306 	return ret;
307 }
308 
309 static struct svc_serv *nfs_callback_create_svc(int minorversion)
310 {
311 	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
312 	struct svc_serv *serv;
313 
314 	/*
315 	 * Check whether we're already up and running.
316 	 */
317 	if (cb_info->task) {
318 		/*
319 		 * Note: increase service usage, because later in case of error
320 		 * svc_destroy() will be called.
321 		 */
322 		svc_get(cb_info->serv);
323 		return cb_info->serv;
324 	}
325 
326 	/*
327 	 * Sanity check: if there's no task,
328 	 * we should be the first user ...
329 	 */
330 	if (cb_info->users)
331 		printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n",
332 			cb_info->users);
333 
334 	serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, NULL);
335 	if (!serv) {
336 		printk(KERN_ERR "nfs_callback_create_svc: create service failed\n");
337 		return ERR_PTR(-ENOMEM);
338 	}
339 	/* As there is only one thread we need to over-ride the
340 	 * default maximum of 80 connections
341 	 */
342 	serv->sv_maxconn = 1024;
343 	dprintk("nfs_callback_create_svc: service created\n");
344 	return serv;
345 }
346 
347 /*
348  * Bring up the callback thread if it is not already up.
349  */
350 int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
351 {
352 	struct svc_serv *serv;
353 	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
354 	int ret;
355 	struct net *net = xprt->xprt_net;
356 
357 	mutex_lock(&nfs_callback_mutex);
358 
359 	serv = nfs_callback_create_svc(minorversion);
360 	if (IS_ERR(serv)) {
361 		ret = PTR_ERR(serv);
362 		goto err_create;
363 	}
364 
365 	ret = nfs_callback_up_net(minorversion, serv, net);
366 	if (ret < 0)
367 		goto err_net;
368 
369 	ret = nfs_callback_start_svc(minorversion, xprt, serv);
370 	if (ret < 0)
371 		goto err_start;
372 
373 	cb_info->users++;
374 	/*
375 	 * svc_create creates the svc_serv with sv_nrthreads == 1, and then
376 	 * svc_prepare_thread increments that. So we need to call svc_destroy
377 	 * on both success and failure so that the refcount is 1 when the
378 	 * thread exits.
379 	 */
380 err_net:
381 	svc_destroy(serv);
382 err_create:
383 	mutex_unlock(&nfs_callback_mutex);
384 	return ret;
385 
386 err_start:
387 	nfs_callback_down_net(minorversion, serv, net);
388 	dprintk("NFS: Couldn't create server thread; err = %d\n", ret);
389 	goto err_net;
390 }
391 
392 /*
393  * Kill the callback thread if it's no longer being used.
394  */
395 void nfs_callback_down(int minorversion, struct net *net)
396 {
397 	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
398 
399 	mutex_lock(&nfs_callback_mutex);
400 	nfs_callback_down_net(minorversion, cb_info->serv, net);
401 	cb_info->users--;
402 	if (cb_info->users == 0 && cb_info->task != NULL) {
403 		kthread_stop(cb_info->task);
404 		dprintk("nfs_callback_down: service stopped\n");
405 		svc_exit_thread(cb_info->rqst);
406 		dprintk("nfs_callback_down: service destroyed\n");
407 		cb_info->serv = NULL;
408 		cb_info->rqst = NULL;
409 		cb_info->task = NULL;
410 	}
411 	mutex_unlock(&nfs_callback_mutex);
412 }
413 
414 /* Boolean check of RPC_AUTH_GSS principal */
415 int
416 check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp)
417 {
418 	char *p = rqstp->rq_cred.cr_principal;
419 
420 	if (rqstp->rq_authop->flavour != RPC_AUTH_GSS)
421 		return 1;
422 
423 	/* No RPC_AUTH_GSS on NFSv4.1 back channel yet */
424 	if (clp->cl_minorversion != 0)
425 		return 0;
426 	/*
427 	 * It might just be a normal user principal, in which case
428 	 * userspace won't bother to tell us the name at all.
429 	 */
430 	if (p == NULL)
431 		return 0;
432 
433 	/*
434 	 * Did we get the acceptor from userland during the SETCLIENID
435 	 * negotiation?
436 	 */
437 	if (clp->cl_acceptor)
438 		return !strcmp(p, clp->cl_acceptor);
439 
440 	/*
441 	 * Otherwise try to verify it using the cl_hostname. Note that this
442 	 * doesn't work if a non-canonical hostname was used in the devname.
443 	 */
444 
445 	/* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
446 
447 	if (memcmp(p, "nfs@", 4) != 0)
448 		return 0;
449 	p += 4;
450 	if (strcmp(p, clp->cl_hostname) != 0)
451 		return 0;
452 	return 1;
453 }
454 
455 /*
456  * pg_authenticate method for nfsv4 callback threads.
457  *
458  * The authflavor has been negotiated, so an incorrect flavor is a server
459  * bug. Drop packets with incorrect authflavor.
460  *
461  * All other checking done after NFS decoding where the nfs_client can be
462  * found in nfs4_callback_compound
463  */
464 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
465 {
466 	switch (rqstp->rq_authop->flavour) {
467 	case RPC_AUTH_NULL:
468 		if (rqstp->rq_proc != CB_NULL)
469 			return SVC_DROP;
470 		break;
471 	case RPC_AUTH_GSS:
472 		/* No RPC_AUTH_GSS support yet in NFSv4.1 */
473 		 if (svc_is_backchannel(rqstp))
474 			return SVC_DROP;
475 	}
476 	return SVC_OK;
477 }
478 
479 /*
480  * Define NFS4 callback program
481  */
482 static struct svc_version *nfs4_callback_version[] = {
483 	[1] = &nfs4_callback_version1,
484 	[4] = &nfs4_callback_version4,
485 };
486 
487 static struct svc_stat nfs4_callback_stats;
488 
489 static struct svc_program nfs4_callback_program = {
490 	.pg_prog = NFS4_CALLBACK,			/* RPC service number */
491 	.pg_nvers = ARRAY_SIZE(nfs4_callback_version),	/* Number of entries */
492 	.pg_vers = nfs4_callback_version,		/* version table */
493 	.pg_name = "NFSv4 callback",			/* service name */
494 	.pg_class = "nfs",				/* authentication class */
495 	.pg_stats = &nfs4_callback_stats,
496 	.pg_authenticate = nfs_callback_authenticate,
497 };
498