]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * linux/fs/nfs/callback.c | |
4 | * | |
5 | * Copyright (C) 2004 Trond Myklebust | |
6 | * | |
7 | * NFSv4 callback handling | |
8 | */ | |
9 | ||
1da177e4 LT |
10 | #include <linux/completion.h> |
11 | #include <linux/ip.h> | |
12 | #include <linux/module.h> | |
3f07c014 | 13 | #include <linux/sched/signal.h> |
1da177e4 LT |
14 | #include <linux/sunrpc/svc.h> |
15 | #include <linux/sunrpc/svcsock.h> | |
16 | #include <linux/nfs_fs.h> | |
758201e2 | 17 | #include <linux/errno.h> |
353ab6e9 | 18 | #include <linux/mutex.h> |
83144186 | 19 | #include <linux/freezer.h> |
a277e33c | 20 | #include <linux/kthread.h> |
945b34a7 | 21 | #include <linux/sunrpc/svcauth_gss.h> |
a43cde94 | 22 | #include <linux/sunrpc/bc_xprt.h> |
14c85021 ACM |
23 | |
24 | #include <net/inet_sock.h> | |
25 | ||
4ce79717 | 26 | #include "nfs4_fs.h" |
1da177e4 | 27 | #include "callback.h" |
24c8dbbb | 28 | #include "internal.h" |
bbe0a3aa | 29 | #include "netns.h" |
1da177e4 LT |
30 | |
31 | #define NFSDBG_FACILITY NFSDBG_CALLBACK | |
32 | ||
33 | struct nfs_callback_data { | |
34 | unsigned int users; | |
a43cde94 | 35 | struct svc_serv *serv; |
1da177e4 LT |
36 | }; |
37 | ||
e82dc22d | 38 | static struct nfs_callback_data nfs_callback_info[NFS4_MAX_MINOR_VERSION + 1]; |
353ab6e9 | 39 | static DEFINE_MUTEX(nfs_callback_mutex); |
1da177e4 LT |
40 | static struct svc_program nfs4_callback_program; |
41 | ||
c946556b SK |
42 | static int nfs4_callback_up_net(struct svc_serv *serv, struct net *net) |
43 | { | |
44 | int ret; | |
bbe0a3aa | 45 | struct nfs_net *nn = net_generic(net, nfs_net_id); |
c946556b SK |
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; | |
bbe0a3aa | 51 | nn->nfs_callback_tcpport = ret; |
e4949e4b VA |
52 | dprintk("NFS: Callback listener port = %u (af %u, net %x)\n", |
53 | nn->nfs_callback_tcpport, PF_INET, net->ns.inum); | |
c946556b SK |
54 | |
55 | ret = svc_create_xprt(serv, "tcp", net, PF_INET6, | |
56 | nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS); | |
57 | if (ret > 0) { | |
29dcc16a | 58 | nn->nfs_callback_tcpport6 = ret; |
e4949e4b VA |
59 | dprintk("NFS: Callback listener port = %u (af %u, net %x\n", |
60 | nn->nfs_callback_tcpport6, PF_INET6, net->ns.inum); | |
c946556b SK |
61 | } else if (ret != -EAFNOSUPPORT) |
62 | goto out_err; | |
63 | return 0; | |
64 | ||
65 | out_err: | |
66 | return (ret) ? ret : -ENOMEM; | |
67 | } | |
68 | ||
1da177e4 | 69 | /* |
e82dc22d | 70 | * This is the NFSv4 callback kernel thread. |
1da177e4 | 71 | */ |
a277e33c | 72 | static int |
71468513 | 73 | nfs4_callback_svc(void *vrqstp) |
1da177e4 | 74 | { |
5b444cc9 | 75 | int err; |
a277e33c | 76 | struct svc_rqst *rqstp = vrqstp; |
1da177e4 | 77 | |
83144186 | 78 | set_freezable(); |
1da177e4 | 79 | |
ed6473dd TM |
80 | while (!kthread_freezable_should_stop(NULL)) { |
81 | ||
82 | if (signal_pending(current)) | |
83 | flush_signals(current); | |
1da177e4 LT |
84 | /* |
85 | * Listen for a request on the socket | |
86 | */ | |
6fb2b47f | 87 | err = svc_recv(rqstp, MAX_SCHEDULE_TIMEOUT); |
5b444cc9 | 88 | if (err == -EAGAIN || err == -EINTR) |
1da177e4 | 89 | continue; |
6fb2b47f | 90 | svc_process(rqstp); |
1da177e4 | 91 | } |
ed6473dd TM |
92 | svc_exit_thread(rqstp); |
93 | module_put_and_exit(0); | |
a277e33c | 94 | return 0; |
1da177e4 LT |
95 | } |
96 | ||
a43cde94 RL |
97 | #if defined(CONFIG_NFS_V4_1) |
98 | /* | |
99 | * The callback service for NFSv4.1 callbacks | |
100 | */ | |
101 | static int | |
102 | nfs41_callback_svc(void *vrqstp) | |
103 | { | |
104 | struct svc_rqst *rqstp = vrqstp; | |
105 | struct svc_serv *serv = rqstp->rq_server; | |
106 | struct rpc_rqst *req; | |
107 | int error; | |
108 | DEFINE_WAIT(wq); | |
109 | ||
110 | set_freezable(); | |
111 | ||
ed6473dd TM |
112 | while (!kthread_freezable_should_stop(NULL)) { |
113 | ||
114 | if (signal_pending(current)) | |
115 | flush_signals(current); | |
25d280aa | 116 | |
5d05e54a | 117 | prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE); |
a43cde94 RL |
118 | spin_lock_bh(&serv->sv_cb_lock); |
119 | if (!list_empty(&serv->sv_cb_list)) { | |
120 | req = list_first_entry(&serv->sv_cb_list, | |
121 | struct rpc_rqst, rq_bc_list); | |
122 | list_del(&req->rq_bc_list); | |
123 | spin_unlock_bh(&serv->sv_cb_lock); | |
6ffa30d3 | 124 | finish_wait(&serv->sv_cb_waitq, &wq); |
a43cde94 RL |
125 | dprintk("Invoking bc_svc_process()\n"); |
126 | error = bc_svc_process(serv, req, rqstp); | |
127 | dprintk("bc_svc_process() returned w/ error code= %d\n", | |
128 | error); | |
129 | } else { | |
130 | spin_unlock_bh(&serv->sv_cb_lock); | |
ed6473dd TM |
131 | if (!kthread_should_stop()) |
132 | schedule(); | |
6ffa30d3 | 133 | finish_wait(&serv->sv_cb_waitq, &wq); |
a43cde94 | 134 | } |
a43cde94 | 135 | } |
ed6473dd TM |
136 | svc_exit_thread(rqstp); |
137 | module_put_and_exit(0); | |
a43cde94 RL |
138 | return 0; |
139 | } | |
140 | ||
a43cde94 | 141 | static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt, |
691c457a | 142 | struct svc_serv *serv) |
a43cde94 RL |
143 | { |
144 | if (minorversion) | |
691c457a SK |
145 | /* |
146 | * Save the svc_serv in the transport so that it can | |
147 | * be referenced when the session backchannel is initialized | |
148 | */ | |
149 | xprt->bc_serv = serv; | |
a43cde94 RL |
150 | } |
151 | #else | |
a43cde94 | 152 | static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt, |
691c457a | 153 | struct svc_serv *serv) |
a43cde94 RL |
154 | { |
155 | } | |
156 | #endif /* CONFIG_NFS_V4_1 */ | |
157 | ||
8e246144 SK |
158 | static int nfs_callback_start_svc(int minorversion, struct rpc_xprt *xprt, |
159 | struct svc_serv *serv) | |
160 | { | |
5405fc44 | 161 | int nrservs = nfs_callback_nr_threads; |
8e246144 | 162 | int ret; |
8e246144 SK |
163 | |
164 | nfs_callback_bc_serv(minorversion, xprt, serv); | |
165 | ||
5405fc44 TM |
166 | if (nrservs < NFS4_MIN_NR_CALLBACK_THREADS) |
167 | nrservs = NFS4_MIN_NR_CALLBACK_THREADS; | |
168 | ||
bb6aeba7 | 169 | if (serv->sv_nrthreads-1 == nrservs) |
23c20ecd SK |
170 | return 0; |
171 | ||
bb6aeba7 TM |
172 | ret = serv->sv_ops->svo_setup(serv, NULL, nrservs); |
173 | if (ret) { | |
174 | serv->sv_ops->svo_setup(serv, NULL, 0); | |
e9b7e917 | 175 | return ret; |
8e246144 SK |
176 | } |
177 | dprintk("nfs_callback_up: service started\n"); | |
178 | return 0; | |
179 | } | |
180 | ||
b3d19c51 SK |
181 | static void nfs_callback_down_net(u32 minorversion, struct svc_serv *serv, struct net *net) |
182 | { | |
183 | struct nfs_net *nn = net_generic(net, nfs_net_id); | |
184 | ||
185 | if (--nn->cb_users[minorversion]) | |
186 | return; | |
187 | ||
e4949e4b | 188 | dprintk("NFS: destroy per-net callback data; net=%x\n", net->ns.inum); |
b3d19c51 SK |
189 | svc_shutdown_net(serv, net); |
190 | } | |
191 | ||
76566773 CL |
192 | static int nfs_callback_up_net(int minorversion, struct svc_serv *serv, |
193 | struct net *net, struct rpc_xprt *xprt) | |
c946556b | 194 | { |
b3d19c51 | 195 | struct nfs_net *nn = net_generic(net, nfs_net_id); |
c946556b SK |
196 | int ret; |
197 | ||
b3d19c51 SK |
198 | if (nn->cb_users[minorversion]++) |
199 | return 0; | |
200 | ||
e4949e4b | 201 | dprintk("NFS: create per-net callback data; net=%x\n", net->ns.inum); |
c946556b SK |
202 | |
203 | ret = svc_bind(serv, net); | |
204 | if (ret < 0) { | |
205 | printk(KERN_WARNING "NFS: bind callback service failed\n"); | |
206 | goto err_bind; | |
207 | } | |
208 | ||
a289ce53 | 209 | ret = 0; |
d55b352b | 210 | if (!IS_ENABLED(CONFIG_NFS_V4_1) || minorversion == 0) |
76566773 | 211 | ret = nfs4_callback_up_net(serv, net); |
a289ce53 VA |
212 | else if (xprt->ops->bc_setup) |
213 | serv->sv_bc_enabled = true; | |
214 | else | |
215 | ret = -EPROTONOSUPPORT; | |
c946556b SK |
216 | |
217 | if (ret < 0) { | |
218 | printk(KERN_ERR "NFS: callback service start failed\n"); | |
219 | goto err_socks; | |
220 | } | |
221 | return 0; | |
222 | ||
223 | err_socks: | |
224 | svc_rpcb_cleanup(serv, net); | |
225 | err_bind: | |
98b0f80c | 226 | nn->cb_users[minorversion]--; |
23c20ecd | 227 | dprintk("NFS: Couldn't create callback socket: err = %d; " |
e4949e4b | 228 | "net = %x\n", ret, net->ns.inum); |
c946556b SK |
229 | return ret; |
230 | } | |
231 | ||
afea5657 | 232 | static const struct svc_serv_ops nfs40_cb_sv_ops = { |
f4b52bb0 | 233 | .svo_function = nfs4_callback_svc, |
b9e13cdf | 234 | .svo_enqueue_xprt = svc_xprt_do_enqueue, |
ed6473dd | 235 | .svo_setup = svc_set_num_threads_sync, |
f4b52bb0 TM |
236 | .svo_module = THIS_MODULE, |
237 | }; | |
238 | #if defined(CONFIG_NFS_V4_1) | |
afea5657 | 239 | static const struct svc_serv_ops nfs41_cb_sv_ops = { |
f4b52bb0 TM |
240 | .svo_function = nfs41_callback_svc, |
241 | .svo_enqueue_xprt = svc_xprt_do_enqueue, | |
ed6473dd | 242 | .svo_setup = svc_set_num_threads_sync, |
f4b52bb0 | 243 | .svo_module = THIS_MODULE, |
ea126e74 JL |
244 | }; |
245 | ||
afea5657 | 246 | static const struct svc_serv_ops *nfs4_cb_sv_ops[] = { |
f4b52bb0 TM |
247 | [0] = &nfs40_cb_sv_ops, |
248 | [1] = &nfs41_cb_sv_ops, | |
249 | }; | |
250 | #else | |
afea5657 | 251 | static const struct svc_serv_ops *nfs4_cb_sv_ops[] = { |
f4b52bb0 TM |
252 | [0] = &nfs40_cb_sv_ops, |
253 | [1] = NULL, | |
254 | }; | |
255 | #endif | |
256 | ||
dd018428 SK |
257 | static struct svc_serv *nfs_callback_create_svc(int minorversion) |
258 | { | |
259 | struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion]; | |
afea5657 | 260 | const struct svc_serv_ops *sv_ops; |
dd018428 SK |
261 | struct svc_serv *serv; |
262 | ||
263 | /* | |
264 | * Check whether we're already up and running. | |
265 | */ | |
3b01c11e | 266 | if (cb_info->serv) { |
dd018428 SK |
267 | /* |
268 | * Note: increase service usage, because later in case of error | |
269 | * svc_destroy() will be called. | |
270 | */ | |
271 | svc_get(cb_info->serv); | |
272 | return cb_info->serv; | |
273 | } | |
274 | ||
f4b52bb0 TM |
275 | switch (minorversion) { |
276 | case 0: | |
277 | sv_ops = nfs4_cb_sv_ops[0]; | |
278 | break; | |
279 | default: | |
280 | sv_ops = nfs4_cb_sv_ops[1]; | |
281 | } | |
282 | ||
283 | if (sv_ops == NULL) | |
284 | return ERR_PTR(-ENOTSUPP); | |
285 | ||
dd018428 SK |
286 | /* |
287 | * Sanity check: if there's no task, | |
288 | * we should be the first user ... | |
289 | */ | |
290 | if (cb_info->users) | |
291 | printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n", | |
292 | cb_info->users); | |
293 | ||
df807fff | 294 | serv = svc_create_pooled(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, sv_ops); |
dd018428 SK |
295 | if (!serv) { |
296 | printk(KERN_ERR "nfs_callback_create_svc: create service failed\n"); | |
297 | return ERR_PTR(-ENOMEM); | |
298 | } | |
3b01c11e | 299 | cb_info->serv = serv; |
dd018428 SK |
300 | /* As there is only one thread we need to over-ride the |
301 | * default maximum of 80 connections | |
302 | */ | |
303 | serv->sv_maxconn = 1024; | |
304 | dprintk("nfs_callback_create_svc: service created\n"); | |
305 | return serv; | |
306 | } | |
307 | ||
71468513 BH |
308 | /* |
309 | * Bring up the callback thread if it is not already up. | |
310 | */ | |
311 | int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt) | |
312 | { | |
dd018428 | 313 | struct svc_serv *serv; |
e82dc22d | 314 | struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion]; |
23c20ecd | 315 | int ret; |
c946556b | 316 | struct net *net = xprt->xprt_net; |
71468513 BH |
317 | |
318 | mutex_lock(&nfs_callback_mutex); | |
dd018428 SK |
319 | |
320 | serv = nfs_callback_create_svc(minorversion); | |
321 | if (IS_ERR(serv)) { | |
322 | ret = PTR_ERR(serv); | |
323 | goto err_create; | |
324 | } | |
325 | ||
76566773 | 326 | ret = nfs_callback_up_net(minorversion, serv, net, xprt); |
c946556b SK |
327 | if (ret < 0) |
328 | goto err_net; | |
9793f7c8 | 329 | |
8e246144 SK |
330 | ret = nfs_callback_start_svc(minorversion, xprt, serv); |
331 | if (ret < 0) | |
332 | goto err_start; | |
a277e33c | 333 | |
23c20ecd | 334 | cb_info->users++; |
8e60029f JL |
335 | /* |
336 | * svc_create creates the svc_serv with sv_nrthreads == 1, and then | |
a277e33c | 337 | * svc_prepare_thread increments that. So we need to call svc_destroy |
8e60029f JL |
338 | * on both success and failure so that the refcount is 1 when the |
339 | * thread exits. | |
340 | */ | |
23c20ecd | 341 | err_net: |
3b01c11e TM |
342 | if (!cb_info->users) |
343 | cb_info->serv = NULL; | |
dd018428 SK |
344 | svc_destroy(serv); |
345 | err_create: | |
353ab6e9 | 346 | mutex_unlock(&nfs_callback_mutex); |
1da177e4 | 347 | return ret; |
8e246144 SK |
348 | |
349 | err_start: | |
b3d19c51 | 350 | nfs_callback_down_net(minorversion, serv, net); |
23c20ecd SK |
351 | dprintk("NFS: Couldn't create server thread; err = %d\n", ret); |
352 | goto err_net; | |
1da177e4 LT |
353 | } |
354 | ||
355 | /* | |
5afc597c | 356 | * Kill the callback thread if it's no longer being used. |
1da177e4 | 357 | */ |
c8ceb412 | 358 | void nfs_callback_down(int minorversion, struct net *net) |
1da177e4 | 359 | { |
e82dc22d | 360 | struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion]; |
bb6aeba7 | 361 | struct svc_serv *serv; |
e82dc22d | 362 | |
353ab6e9 | 363 | mutex_lock(&nfs_callback_mutex); |
bb6aeba7 TM |
364 | serv = cb_info->serv; |
365 | nfs_callback_down_net(minorversion, serv, net); | |
e82dc22d | 366 | cb_info->users--; |
3b01c11e | 367 | if (cb_info->users == 0) { |
bb6aeba7 TM |
368 | svc_get(serv); |
369 | serv->sv_ops->svo_setup(serv, NULL, 0); | |
370 | svc_destroy(serv); | |
1dc42e04 | 371 | dprintk("nfs_callback_down: service destroyed\n"); |
e82dc22d | 372 | cb_info->serv = NULL; |
5afc597c | 373 | } |
353ab6e9 | 374 | mutex_unlock(&nfs_callback_mutex); |
1da177e4 LT |
375 | } |
376 | ||
778be232 AA |
377 | /* Boolean check of RPC_AUTH_GSS principal */ |
378 | int | |
379 | check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp) | |
945b34a7 | 380 | { |
03a4e1f6 | 381 | char *p = rqstp->rq_cred.cr_principal; |
945b34a7 | 382 | |
778be232 AA |
383 | if (rqstp->rq_authop->flavour != RPC_AUTH_GSS) |
384 | return 1; | |
385 | ||
ece0de63 AA |
386 | /* No RPC_AUTH_GSS on NFSv4.1 back channel yet */ |
387 | if (clp->cl_minorversion != 0) | |
778be232 | 388 | return 0; |
945b34a7 OK |
389 | /* |
390 | * It might just be a normal user principal, in which case | |
391 | * userspace won't bother to tell us the name at all. | |
392 | */ | |
393 | if (p == NULL) | |
778be232 | 394 | return 0; |
945b34a7 | 395 | |
f11b2a1c JL |
396 | /* |
397 | * Did we get the acceptor from userland during the SETCLIENID | |
398 | * negotiation? | |
399 | */ | |
400 | if (clp->cl_acceptor) | |
401 | return !strcmp(p, clp->cl_acceptor); | |
402 | ||
403 | /* | |
404 | * Otherwise try to verify it using the cl_hostname. Note that this | |
405 | * doesn't work if a non-canonical hostname was used in the devname. | |
406 | */ | |
407 | ||
945b34a7 OK |
408 | /* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */ |
409 | ||
410 | if (memcmp(p, "nfs@", 4) != 0) | |
778be232 | 411 | return 0; |
945b34a7 | 412 | p += 4; |
4e0038b6 | 413 | if (strcmp(p, clp->cl_hostname) != 0) |
778be232 AA |
414 | return 0; |
415 | return 1; | |
945b34a7 OK |
416 | } |
417 | ||
778be232 AA |
418 | /* |
419 | * pg_authenticate method for nfsv4 callback threads. | |
420 | * | |
421 | * The authflavor has been negotiated, so an incorrect flavor is a server | |
6f02dc88 | 422 | * bug. Deny packets with incorrect authflavor. |
778be232 AA |
423 | * |
424 | * All other checking done after NFS decoding where the nfs_client can be | |
425 | * found in nfs4_callback_compound | |
426 | */ | |
1da177e4 LT |
427 | static int nfs_callback_authenticate(struct svc_rqst *rqstp) |
428 | { | |
1da177e4 | 429 | switch (rqstp->rq_authop->flavour) { |
778be232 AA |
430 | case RPC_AUTH_NULL: |
431 | if (rqstp->rq_proc != CB_NULL) | |
6f02dc88 | 432 | return SVC_DENIED; |
778be232 AA |
433 | break; |
434 | case RPC_AUTH_GSS: | |
435 | /* No RPC_AUTH_GSS support yet in NFSv4.1 */ | |
436 | if (svc_is_backchannel(rqstp)) | |
6f02dc88 | 437 | return SVC_DENIED; |
1da177e4 | 438 | } |
778be232 | 439 | return SVC_OK; |
1da177e4 LT |
440 | } |
441 | ||
442 | /* | |
443 | * Define NFS4 callback program | |
444 | */ | |
e9679189 | 445 | static const struct svc_version *nfs4_callback_version[] = { |
1da177e4 | 446 | [1] = &nfs4_callback_version1, |
07bccc2d | 447 | [4] = &nfs4_callback_version4, |
1da177e4 LT |
448 | }; |
449 | ||
450 | static struct svc_stat nfs4_callback_stats; | |
451 | ||
452 | static struct svc_program nfs4_callback_program = { | |
453 | .pg_prog = NFS4_CALLBACK, /* RPC service number */ | |
454 | .pg_nvers = ARRAY_SIZE(nfs4_callback_version), /* Number of entries */ | |
455 | .pg_vers = nfs4_callback_version, /* version table */ | |
456 | .pg_name = "NFSv4 callback", /* service name */ | |
457 | .pg_class = "nfs", /* authentication class */ | |
458 | .pg_stats = &nfs4_callback_stats, | |
459 | .pg_authenticate = nfs_callback_authenticate, | |
460 | }; |