xref: /openbmc/linux/fs/nfs/callback.c (revision 7dd65feb)
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/smp_lock.h>
13 #include <linux/sunrpc/svc.h>
14 #include <linux/sunrpc/svcsock.h>
15 #include <linux/nfs_fs.h>
16 #include <linux/mutex.h>
17 #include <linux/freezer.h>
18 #include <linux/kthread.h>
19 #include <linux/sunrpc/svcauth_gss.h>
20 #if defined(CONFIG_NFS_V4_1)
21 #include <linux/sunrpc/bc_xprt.h>
22 #endif
23 
24 #include <net/inet_sock.h>
25 
26 #include "nfs4_fs.h"
27 #include "callback.h"
28 #include "internal.h"
29 
30 #define NFSDBG_FACILITY NFSDBG_CALLBACK
31 
32 struct nfs_callback_data {
33 	unsigned int users;
34 	struct svc_serv *serv;
35 	struct svc_rqst *rqst;
36 	struct task_struct *task;
37 };
38 
39 static struct nfs_callback_data nfs_callback_info[NFS4_MAX_MINOR_VERSION + 1];
40 static DEFINE_MUTEX(nfs_callback_mutex);
41 static struct svc_program nfs4_callback_program;
42 
43 unsigned int nfs_callback_set_tcpport;
44 unsigned short nfs_callback_tcpport;
45 unsigned short nfs_callback_tcpport6;
46 #define NFS_CALLBACK_MAXPORTNR (65535U)
47 
48 static int param_set_portnr(const char *val, struct kernel_param *kp)
49 {
50 	unsigned long num;
51 	int ret;
52 
53 	if (!val)
54 		return -EINVAL;
55 	ret = strict_strtoul(val, 0, &num);
56 	if (ret == -EINVAL || num > NFS_CALLBACK_MAXPORTNR)
57 		return -EINVAL;
58 	*((unsigned int *)kp->arg) = num;
59 	return 0;
60 }
61 
62 static int param_get_portnr(char *buffer, struct kernel_param *kp)
63 {
64 	return param_get_uint(buffer, kp);
65 }
66 #define param_check_portnr(name, p) __param_check(name, p, unsigned int);
67 
68 module_param_named(callback_tcpport, nfs_callback_set_tcpport, portnr, 0644);
69 
70 /*
71  * This is the NFSv4 callback kernel thread.
72  */
73 static int
74 nfs4_callback_svc(void *vrqstp)
75 {
76 	int err, preverr = 0;
77 	struct svc_rqst *rqstp = vrqstp;
78 
79 	set_freezable();
80 
81 	while (!kthread_should_stop()) {
82 		/*
83 		 * Listen for a request on the socket
84 		 */
85 		err = svc_recv(rqstp, MAX_SCHEDULE_TIMEOUT);
86 		if (err == -EAGAIN || err == -EINTR) {
87 			preverr = err;
88 			continue;
89 		}
90 		if (err < 0) {
91 			if (err != preverr) {
92 				printk(KERN_WARNING "%s: unexpected error "
93 					"from svc_recv (%d)\n", __func__, err);
94 				preverr = err;
95 			}
96 			schedule_timeout_uninterruptible(HZ);
97 			continue;
98 		}
99 		preverr = err;
100 		svc_process(rqstp);
101 	}
102 	return 0;
103 }
104 
105 /*
106  * Prepare to bring up the NFSv4 callback service
107  */
108 struct svc_rqst *
109 nfs4_callback_up(struct svc_serv *serv)
110 {
111 	int ret;
112 
113 	ret = svc_create_xprt(serv, "tcp", PF_INET,
114 				nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
115 	if (ret <= 0)
116 		goto out_err;
117 	nfs_callback_tcpport = ret;
118 	dprintk("NFS: Callback listener port = %u (af %u)\n",
119 			nfs_callback_tcpport, PF_INET);
120 
121 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
122 	ret = svc_create_xprt(serv, "tcp", PF_INET6,
123 				nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
124 	if (ret > 0) {
125 		nfs_callback_tcpport6 = ret;
126 		dprintk("NFS: Callback listener port = %u (af %u)\n",
127 				nfs_callback_tcpport6, PF_INET6);
128 	} else if (ret == -EAFNOSUPPORT)
129 		ret = 0;
130 	else
131 		goto out_err;
132 #endif	/* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
133 
134 	return svc_prepare_thread(serv, &serv->sv_pools[0]);
135 
136 out_err:
137 	if (ret == 0)
138 		ret = -ENOMEM;
139 	return ERR_PTR(ret);
140 }
141 
142 #if defined(CONFIG_NFS_V4_1)
143 /*
144  * The callback service for NFSv4.1 callbacks
145  */
146 static int
147 nfs41_callback_svc(void *vrqstp)
148 {
149 	struct svc_rqst *rqstp = vrqstp;
150 	struct svc_serv *serv = rqstp->rq_server;
151 	struct rpc_rqst *req;
152 	int error;
153 	DEFINE_WAIT(wq);
154 
155 	set_freezable();
156 
157 	while (!kthread_should_stop()) {
158 		prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE);
159 		spin_lock_bh(&serv->sv_cb_lock);
160 		if (!list_empty(&serv->sv_cb_list)) {
161 			req = list_first_entry(&serv->sv_cb_list,
162 					struct rpc_rqst, rq_bc_list);
163 			list_del(&req->rq_bc_list);
164 			spin_unlock_bh(&serv->sv_cb_lock);
165 			dprintk("Invoking bc_svc_process()\n");
166 			error = bc_svc_process(serv, req, rqstp);
167 			dprintk("bc_svc_process() returned w/ error code= %d\n",
168 				error);
169 		} else {
170 			spin_unlock_bh(&serv->sv_cb_lock);
171 			schedule();
172 		}
173 		finish_wait(&serv->sv_cb_waitq, &wq);
174 	}
175 	return 0;
176 }
177 
178 /*
179  * Bring up the NFSv4.1 callback service
180  */
181 struct svc_rqst *
182 nfs41_callback_up(struct svc_serv *serv, struct rpc_xprt *xprt)
183 {
184 	struct svc_xprt *bc_xprt;
185 	struct svc_rqst *rqstp = ERR_PTR(-ENOMEM);
186 
187 	dprintk("--> %s\n", __func__);
188 	/* Create a svc_sock for the service */
189 	bc_xprt = svc_sock_create(serv, xprt->prot);
190 	if (!bc_xprt)
191 		goto out;
192 
193 	/*
194 	 * Save the svc_serv in the transport so that it can
195 	 * be referenced when the session backchannel is initialized
196 	 */
197 	serv->bc_xprt = bc_xprt;
198 	xprt->bc_serv = serv;
199 
200 	INIT_LIST_HEAD(&serv->sv_cb_list);
201 	spin_lock_init(&serv->sv_cb_lock);
202 	init_waitqueue_head(&serv->sv_cb_waitq);
203 	rqstp = svc_prepare_thread(serv, &serv->sv_pools[0]);
204 	if (IS_ERR(rqstp))
205 		svc_sock_destroy(bc_xprt);
206 out:
207 	dprintk("--> %s return %p\n", __func__, rqstp);
208 	return rqstp;
209 }
210 
211 static inline int nfs_minorversion_callback_svc_setup(u32 minorversion,
212 		struct svc_serv *serv, struct rpc_xprt *xprt,
213 		struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
214 {
215 	if (minorversion) {
216 		*rqstpp = nfs41_callback_up(serv, xprt);
217 		*callback_svc = nfs41_callback_svc;
218 	}
219 	return minorversion;
220 }
221 
222 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
223 		struct nfs_callback_data *cb_info)
224 {
225 	if (minorversion)
226 		xprt->bc_serv = cb_info->serv;
227 }
228 #else
229 static inline int nfs_minorversion_callback_svc_setup(u32 minorversion,
230 		struct svc_serv *serv, struct rpc_xprt *xprt,
231 		struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
232 {
233 	return 0;
234 }
235 
236 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
237 		struct nfs_callback_data *cb_info)
238 {
239 }
240 #endif /* CONFIG_NFS_V4_1 */
241 
242 /*
243  * Bring up the callback thread if it is not already up.
244  */
245 int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
246 {
247 	struct svc_serv *serv = NULL;
248 	struct svc_rqst *rqstp;
249 	int (*callback_svc)(void *vrqstp);
250 	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
251 	char svc_name[12];
252 	int ret = 0;
253 	int minorversion_setup;
254 
255 	mutex_lock(&nfs_callback_mutex);
256 	if (cb_info->users++ || cb_info->task != NULL) {
257 		nfs_callback_bc_serv(minorversion, xprt, cb_info);
258 		goto out;
259 	}
260 	serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, NULL);
261 	if (!serv) {
262 		ret = -ENOMEM;
263 		goto out_err;
264 	}
265 
266 	minorversion_setup =  nfs_minorversion_callback_svc_setup(minorversion,
267 					serv, xprt, &rqstp, &callback_svc);
268 	if (!minorversion_setup) {
269 		/* v4.0 callback setup */
270 		rqstp = nfs4_callback_up(serv);
271 		callback_svc = nfs4_callback_svc;
272 	}
273 
274 	if (IS_ERR(rqstp)) {
275 		ret = PTR_ERR(rqstp);
276 		goto out_err;
277 	}
278 
279 	svc_sock_update_bufs(serv);
280 
281 	sprintf(svc_name, "nfsv4.%u-svc", minorversion);
282 	cb_info->serv = serv;
283 	cb_info->rqst = rqstp;
284 	cb_info->task = kthread_run(callback_svc, cb_info->rqst, svc_name);
285 	if (IS_ERR(cb_info->task)) {
286 		ret = PTR_ERR(cb_info->task);
287 		svc_exit_thread(cb_info->rqst);
288 		cb_info->rqst = NULL;
289 		cb_info->task = NULL;
290 		goto out_err;
291 	}
292 out:
293 	/*
294 	 * svc_create creates the svc_serv with sv_nrthreads == 1, and then
295 	 * svc_prepare_thread increments that. So we need to call svc_destroy
296 	 * on both success and failure so that the refcount is 1 when the
297 	 * thread exits.
298 	 */
299 	if (serv)
300 		svc_destroy(serv);
301 	mutex_unlock(&nfs_callback_mutex);
302 	return ret;
303 out_err:
304 	dprintk("NFS: Couldn't create callback socket or server thread; "
305 		"err = %d\n", ret);
306 	cb_info->users--;
307 	goto out;
308 }
309 
310 /*
311  * Kill the callback thread if it's no longer being used.
312  */
313 void nfs_callback_down(int minorversion)
314 {
315 	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
316 
317 	mutex_lock(&nfs_callback_mutex);
318 	cb_info->users--;
319 	if (cb_info->users == 0 && cb_info->task != NULL) {
320 		kthread_stop(cb_info->task);
321 		svc_exit_thread(cb_info->rqst);
322 		cb_info->serv = NULL;
323 		cb_info->rqst = NULL;
324 		cb_info->task = NULL;
325 	}
326 	mutex_unlock(&nfs_callback_mutex);
327 }
328 
329 static int check_gss_callback_principal(struct nfs_client *clp,
330 					struct svc_rqst *rqstp)
331 {
332 	struct rpc_clnt *r = clp->cl_rpcclient;
333 	char *p = svc_gss_principal(rqstp);
334 
335 	/*
336 	 * It might just be a normal user principal, in which case
337 	 * userspace won't bother to tell us the name at all.
338 	 */
339 	if (p == NULL)
340 		return SVC_DENIED;
341 
342 	/* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
343 
344 	if (memcmp(p, "nfs@", 4) != 0)
345 		return SVC_DENIED;
346 	p += 4;
347 	if (strcmp(p, r->cl_server) != 0)
348 		return SVC_DENIED;
349 	return SVC_OK;
350 }
351 
352 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
353 {
354 	struct nfs_client *clp;
355 	RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
356 	int ret = SVC_OK;
357 
358 	/* Don't talk to strangers */
359 	clp = nfs_find_client(svc_addr(rqstp), 4);
360 	if (clp == NULL)
361 		return SVC_DROP;
362 
363 	dprintk("%s: %s NFSv4 callback!\n", __func__,
364 			svc_print_addr(rqstp, buf, sizeof(buf)));
365 
366 	switch (rqstp->rq_authop->flavour) {
367 		case RPC_AUTH_NULL:
368 			if (rqstp->rq_proc != CB_NULL)
369 				ret = SVC_DENIED;
370 			break;
371 		case RPC_AUTH_UNIX:
372 			break;
373 		case RPC_AUTH_GSS:
374 			ret = check_gss_callback_principal(clp, rqstp);
375 			break;
376 		default:
377 			ret = SVC_DENIED;
378 	}
379 	nfs_put_client(clp);
380 	return ret;
381 }
382 
383 /*
384  * Define NFS4 callback program
385  */
386 static struct svc_version *nfs4_callback_version[] = {
387 	[1] = &nfs4_callback_version1,
388 	[4] = &nfs4_callback_version4,
389 };
390 
391 static struct svc_stat nfs4_callback_stats;
392 
393 static struct svc_program nfs4_callback_program = {
394 	.pg_prog = NFS4_CALLBACK,			/* RPC service number */
395 	.pg_nvers = ARRAY_SIZE(nfs4_callback_version),	/* Number of entries */
396 	.pg_vers = nfs4_callback_version,		/* version table */
397 	.pg_name = "NFSv4 callback",			/* service name */
398 	.pg_class = "nfs",				/* authentication class */
399 	.pg_stats = &nfs4_callback_stats,
400 	.pg_authenticate = nfs_callback_authenticate,
401 };
402