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 };
35
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;
39
nfs4_callback_up_net(struct svc_serv * serv,struct net * net)40 static int nfs4_callback_up_net(struct svc_serv *serv, struct net *net)
41 {
42 int ret;
43 struct nfs_net *nn = net_generic(net, nfs_net_id);
44
45 ret = svc_create_xprt(serv, "tcp", net, PF_INET,
46 nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
47 if (ret <= 0)
48 goto out_err;
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);
52
53 ret = svc_create_xprt(serv, "tcp", net, PF_INET6,
54 nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
55 if (ret > 0) {
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)
60 goto out_err;
61 return 0;
62
63 out_err:
64 return (ret) ? ret : -ENOMEM;
65 }
66
67 /*
68 * This is the NFSv4 callback kernel thread.
69 */
70 static int
nfs4_callback_svc(void * vrqstp)71 nfs4_callback_svc(void *vrqstp)
72 {
73 int err;
74 struct svc_rqst *rqstp = vrqstp;
75
76 set_freezable();
77
78 while (!kthread_freezable_should_stop(NULL)) {
79
80 if (signal_pending(current))
81 flush_signals(current);
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 continue;
88 svc_process(rqstp);
89 }
90 svc_exit_thread(rqstp);
91 module_put_and_exit(0);
92 return 0;
93 }
94
95 #if defined(CONFIG_NFS_V4_1)
96 /*
97 * The callback service for NFSv4.1 callbacks
98 */
99 static int
nfs41_callback_svc(void * vrqstp)100 nfs41_callback_svc(void *vrqstp)
101 {
102 struct svc_rqst *rqstp = vrqstp;
103 struct svc_serv *serv = rqstp->rq_server;
104 struct rpc_rqst *req;
105 int error;
106 DEFINE_WAIT(wq);
107
108 set_freezable();
109
110 while (!kthread_freezable_should_stop(NULL)) {
111
112 if (signal_pending(current))
113 flush_signals(current);
114
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",
126 error);
127 } else {
128 spin_unlock_bh(&serv->sv_cb_lock);
129 if (!kthread_should_stop())
130 schedule();
131 finish_wait(&serv->sv_cb_waitq, &wq);
132 }
133 }
134 svc_exit_thread(rqstp);
135 module_put_and_exit(0);
136 return 0;
137 }
138
nfs_callback_bc_serv(u32 minorversion,struct rpc_xprt * xprt,struct svc_serv * serv)139 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
140 struct svc_serv *serv)
141 {
142 if (minorversion)
143 /*
144 * Save the svc_serv in the transport so that it can
145 * be referenced when the session backchannel is initialized
146 */
147 xprt->bc_serv = serv;
148 }
149 #else
nfs_callback_bc_serv(u32 minorversion,struct rpc_xprt * xprt,struct svc_serv * serv)150 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
151 struct svc_serv *serv)
152 {
153 }
154 #endif /* CONFIG_NFS_V4_1 */
155
nfs_callback_start_svc(int minorversion,struct rpc_xprt * xprt,struct svc_serv * serv)156 static int nfs_callback_start_svc(int minorversion, struct rpc_xprt *xprt,
157 struct svc_serv *serv)
158 {
159 int nrservs = nfs_callback_nr_threads;
160 int ret;
161
162 nfs_callback_bc_serv(minorversion, xprt, serv);
163
164 if (nrservs < NFS4_MIN_NR_CALLBACK_THREADS)
165 nrservs = NFS4_MIN_NR_CALLBACK_THREADS;
166
167 if (serv->sv_nrthreads-1 == nrservs)
168 return 0;
169
170 ret = serv->sv_ops->svo_setup(serv, NULL, nrservs);
171 if (ret) {
172 serv->sv_ops->svo_setup(serv, NULL, 0);
173 return ret;
174 }
175 dprintk("nfs_callback_up: service started\n");
176 return 0;
177 }
178
nfs_callback_down_net(u32 minorversion,struct svc_serv * serv,struct net * net)179 static void nfs_callback_down_net(u32 minorversion, struct svc_serv *serv, struct net *net)
180 {
181 struct nfs_net *nn = net_generic(net, nfs_net_id);
182
183 if (--nn->cb_users[minorversion])
184 return;
185
186 dprintk("NFS: destroy per-net callback data; net=%p\n", net);
187 svc_shutdown_net(serv, net);
188 }
189
nfs_callback_up_net(int minorversion,struct svc_serv * serv,struct net * net,struct rpc_xprt * xprt)190 static int nfs_callback_up_net(int minorversion, struct svc_serv *serv,
191 struct net *net, struct rpc_xprt *xprt)
192 {
193 struct nfs_net *nn = net_generic(net, nfs_net_id);
194 int ret;
195
196 if (nn->cb_users[minorversion]++)
197 return 0;
198
199 dprintk("NFS: create per-net callback data; net=%p\n", net);
200
201 ret = svc_bind(serv, net);
202 if (ret < 0) {
203 printk(KERN_WARNING "NFS: bind callback service failed\n");
204 goto err_bind;
205 }
206
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);
212
213 if (ret < 0) {
214 printk(KERN_ERR "NFS: callback service start failed\n");
215 goto err_socks;
216 }
217 return 0;
218
219 err_socks:
220 svc_rpcb_cleanup(serv, net);
221 err_bind:
222 nn->cb_users[minorversion]--;
223 dprintk("NFS: Couldn't create callback socket: err = %d; "
224 "net = %p\n", ret, net);
225 return ret;
226 }
227
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,
233 };
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,
240 };
241
242 static struct svc_serv_ops *nfs4_cb_sv_ops[] = {
243 [0] = &nfs40_cb_sv_ops,
244 [1] = &nfs41_cb_sv_ops,
245 };
246 #else
247 static struct svc_serv_ops *nfs4_cb_sv_ops[] = {
248 [0] = &nfs40_cb_sv_ops,
249 [1] = NULL,
250 };
251 #endif
252
nfs_callback_create_svc(int minorversion)253 static struct svc_serv *nfs_callback_create_svc(int minorversion)
254 {
255 struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
256 struct svc_serv *serv;
257 struct svc_serv_ops *sv_ops;
258
259 /*
260 * Check whether we're already up and running.
261 */
262 if (cb_info->serv) {
263 /*
264 * Note: increase service usage, because later in case of error
265 * svc_destroy() will be called.
266 */
267 svc_get(cb_info->serv);
268 return cb_info->serv;
269 }
270
271 switch (minorversion) {
272 case 0:
273 sv_ops = nfs4_cb_sv_ops[0];
274 break;
275 default:
276 sv_ops = nfs4_cb_sv_ops[1];
277 }
278
279 if (sv_ops == NULL)
280 return ERR_PTR(-ENOTSUPP);
281
282 /*
283 * Sanity check: if there's no task,
284 * we should be the first user ...
285 */
286 if (cb_info->users)
287 printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n",
288 cb_info->users);
289
290 serv = svc_create_pooled(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, sv_ops);
291 if (!serv) {
292 printk(KERN_ERR "nfs_callback_create_svc: create service failed\n");
293 return ERR_PTR(-ENOMEM);
294 }
295 cb_info->serv = serv;
296 /* As there is only one thread we need to over-ride the
297 * default maximum of 80 connections
298 */
299 serv->sv_maxconn = 1024;
300 dprintk("nfs_callback_create_svc: service created\n");
301 return serv;
302 }
303
304 /*
305 * Bring up the callback thread if it is not already up.
306 */
nfs_callback_up(u32 minorversion,struct rpc_xprt * xprt)307 int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
308 {
309 struct svc_serv *serv;
310 struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
311 int ret;
312 struct net *net = xprt->xprt_net;
313
314 mutex_lock(&nfs_callback_mutex);
315
316 serv = nfs_callback_create_svc(minorversion);
317 if (IS_ERR(serv)) {
318 ret = PTR_ERR(serv);
319 goto err_create;
320 }
321
322 ret = nfs_callback_up_net(minorversion, serv, net, xprt);
323 if (ret < 0)
324 goto err_net;
325
326 ret = nfs_callback_start_svc(minorversion, xprt, serv);
327 if (ret < 0)
328 goto err_start;
329
330 cb_info->users++;
331 /*
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
335 * thread exits.
336 */
337 err_net:
338 if (!cb_info->users)
339 cb_info->serv = NULL;
340 svc_destroy(serv);
341 err_create:
342 mutex_unlock(&nfs_callback_mutex);
343 return ret;
344
345 err_start:
346 nfs_callback_down_net(minorversion, serv, net);
347 dprintk("NFS: Couldn't create server thread; err = %d\n", ret);
348 goto err_net;
349 }
350
351 /*
352 * Kill the callback thread if it's no longer being used.
353 */
nfs_callback_down(int minorversion,struct net * net)354 void nfs_callback_down(int minorversion, struct net *net)
355 {
356 struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
357 struct svc_serv *serv;
358
359 mutex_lock(&nfs_callback_mutex);
360 serv = cb_info->serv;
361 nfs_callback_down_net(minorversion, serv, net);
362 cb_info->users--;
363 if (cb_info->users == 0) {
364 svc_get(serv);
365 serv->sv_ops->svo_setup(serv, NULL, 0);
366 svc_destroy(serv);
367 dprintk("nfs_callback_down: service destroyed\n");
368 cb_info->serv = NULL;
369 }
370 mutex_unlock(&nfs_callback_mutex);
371 }
372
373 /* Boolean check of RPC_AUTH_GSS principal */
374 int
check_gss_callback_principal(struct nfs_client * clp,struct svc_rqst * rqstp)375 check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp)
376 {
377 char *p = rqstp->rq_cred.cr_principal;
378
379 if (rqstp->rq_authop->flavour != RPC_AUTH_GSS)
380 return 1;
381
382 /* No RPC_AUTH_GSS on NFSv4.1 back channel yet */
383 if (clp->cl_minorversion != 0)
384 return 0;
385 /*
386 * It might just be a normal user principal, in which case
387 * userspace won't bother to tell us the name at all.
388 */
389 if (p == NULL)
390 return 0;
391
392 /*
393 * Did we get the acceptor from userland during the SETCLIENID
394 * negotiation?
395 */
396 if (clp->cl_acceptor)
397 return !strcmp(p, clp->cl_acceptor);
398
399 /*
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.
402 */
403
404 /* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
405
406 if (memcmp(p, "nfs@", 4) != 0)
407 return 0;
408 p += 4;
409 if (strcmp(p, clp->cl_hostname) != 0)
410 return 0;
411 return 1;
412 }
413
414 /*
415 * pg_authenticate method for nfsv4 callback threads.
416 *
417 * The authflavor has been negotiated, so an incorrect flavor is a server
418 * bug. Deny packets with incorrect authflavor.
419 *
420 * All other checking done after NFS decoding where the nfs_client can be
421 * found in nfs4_callback_compound
422 */
nfs_callback_authenticate(struct svc_rqst * rqstp)423 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
424 {
425 switch (rqstp->rq_authop->flavour) {
426 case RPC_AUTH_NULL:
427 if (rqstp->rq_proc != CB_NULL)
428 return SVC_DENIED;
429 break;
430 case RPC_AUTH_GSS:
431 /* No RPC_AUTH_GSS support yet in NFSv4.1 */
432 if (svc_is_backchannel(rqstp))
433 return SVC_DENIED;
434 }
435 return SVC_OK;
436 }
437
438 /*
439 * Define NFS4 callback program
440 */
441 static struct svc_version *nfs4_callback_version[] = {
442 [1] = &nfs4_callback_version1,
443 [4] = &nfs4_callback_version4,
444 };
445
446 static struct svc_stat nfs4_callback_stats;
447
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,
456 };
457