ARM64: DTS: Add rk3399-firefly uart4 device, node as /dev/ttyS1
[firefly-linux-kernel-4.4.55.git] / fs / nfs / callback.c
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 /*
103  * The callback service for NFSv4.1 callbacks
104  */
105 static int
106 nfs41_callback_svc(void *vrqstp)
107 {
108         struct svc_rqst *rqstp = vrqstp;
109         struct svc_serv *serv = rqstp->rq_server;
110         struct rpc_rqst *req;
111         int error;
112         DEFINE_WAIT(wq);
113
114         set_freezable();
115
116         while (!kthread_should_stop()) {
117                 if (try_to_freeze())
118                         continue;
119
120                 prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE);
121                 spin_lock_bh(&serv->sv_cb_lock);
122                 if (!list_empty(&serv->sv_cb_list)) {
123                         req = list_first_entry(&serv->sv_cb_list,
124                                         struct rpc_rqst, rq_bc_list);
125                         list_del(&req->rq_bc_list);
126                         spin_unlock_bh(&serv->sv_cb_lock);
127                         finish_wait(&serv->sv_cb_waitq, &wq);
128                         dprintk("Invoking bc_svc_process()\n");
129                         error = bc_svc_process(serv, req, rqstp);
130                         dprintk("bc_svc_process() returned w/ error code= %d\n",
131                                 error);
132                 } else {
133                         spin_unlock_bh(&serv->sv_cb_lock);
134                         schedule();
135                         finish_wait(&serv->sv_cb_waitq, &wq);
136                 }
137                 flush_signals(current);
138         }
139         return 0;
140 }
141
142 /*
143  * Bring up the NFSv4.1 callback service
144  */
145 static struct svc_rqst *
146 nfs41_callback_up(struct svc_serv *serv)
147 {
148         struct svc_rqst *rqstp;
149
150         INIT_LIST_HEAD(&serv->sv_cb_list);
151         spin_lock_init(&serv->sv_cb_lock);
152         init_waitqueue_head(&serv->sv_cb_waitq);
153         rqstp = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
154         dprintk("--> %s return %d\n", __func__, PTR_ERR_OR_ZERO(rqstp));
155         return rqstp;
156 }
157
158 static void nfs_minorversion_callback_svc_setup(struct svc_serv *serv,
159                 struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
160 {
161         *rqstpp = nfs41_callback_up(serv);
162         *callback_svc = nfs41_callback_svc;
163 }
164
165 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
166                 struct svc_serv *serv)
167 {
168         if (minorversion)
169                 /*
170                  * Save the svc_serv in the transport so that it can
171                  * be referenced when the session backchannel is initialized
172                  */
173                 xprt->bc_serv = serv;
174 }
175 #else
176 static void nfs_minorversion_callback_svc_setup(struct svc_serv *serv,
177                 struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
178 {
179         *rqstpp = ERR_PTR(-ENOTSUPP);
180         *callback_svc = ERR_PTR(-ENOTSUPP);
181 }
182
183 static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
184                 struct svc_serv *serv)
185 {
186 }
187 #endif /* CONFIG_NFS_V4_1 */
188
189 static int nfs_callback_start_svc(int minorversion, struct rpc_xprt *xprt,
190                                   struct svc_serv *serv)
191 {
192         struct svc_rqst *rqstp;
193         int (*callback_svc)(void *vrqstp);
194         struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
195         int ret;
196
197         nfs_callback_bc_serv(minorversion, xprt, serv);
198
199         if (cb_info->task)
200                 return 0;
201
202         switch (minorversion) {
203         case 0:
204                 /* v4.0 callback setup */
205                 rqstp = nfs4_callback_up(serv);
206                 callback_svc = nfs4_callback_svc;
207                 break;
208         default:
209                 nfs_minorversion_callback_svc_setup(serv,
210                                 &rqstp, &callback_svc);
211         }
212
213         if (IS_ERR(rqstp))
214                 return PTR_ERR(rqstp);
215
216         svc_sock_update_bufs(serv);
217
218         cb_info->serv = serv;
219         cb_info->rqst = rqstp;
220         cb_info->task = kthread_create(callback_svc, cb_info->rqst,
221                                     "nfsv4.%u-svc", minorversion);
222         if (IS_ERR(cb_info->task)) {
223                 ret = PTR_ERR(cb_info->task);
224                 svc_exit_thread(cb_info->rqst);
225                 cb_info->rqst = NULL;
226                 cb_info->task = NULL;
227                 return ret;
228         }
229         rqstp->rq_task = cb_info->task;
230         wake_up_process(cb_info->task);
231         dprintk("nfs_callback_up: service started\n");
232         return 0;
233 }
234
235 static void nfs_callback_down_net(u32 minorversion, struct svc_serv *serv, struct net *net)
236 {
237         struct nfs_net *nn = net_generic(net, nfs_net_id);
238
239         if (--nn->cb_users[minorversion])
240                 return;
241
242         dprintk("NFS: destroy per-net callback data; net=%p\n", net);
243         svc_shutdown_net(serv, net);
244 }
245
246 static int nfs_callback_up_net(int minorversion, struct svc_serv *serv,
247                                struct net *net, struct rpc_xprt *xprt)
248 {
249         struct nfs_net *nn = net_generic(net, nfs_net_id);
250         int ret;
251
252         if (nn->cb_users[minorversion]++)
253                 return 0;
254
255         dprintk("NFS: create per-net callback data; net=%p\n", net);
256
257         ret = svc_bind(serv, net);
258         if (ret < 0) {
259                 printk(KERN_WARNING "NFS: bind callback service failed\n");
260                 goto err_bind;
261         }
262
263         ret = -EPROTONOSUPPORT;
264         if (!IS_ENABLED(CONFIG_NFS_V4_1) || minorversion == 0)
265                 ret = nfs4_callback_up_net(serv, net);
266         else if (xprt->ops->bc_up)
267                 ret = xprt->ops->bc_up(serv, net);
268
269         if (ret < 0) {
270                 printk(KERN_ERR "NFS: callback service start failed\n");
271                 goto err_socks;
272         }
273         return 0;
274
275 err_socks:
276         svc_rpcb_cleanup(serv, net);
277 err_bind:
278         nn->cb_users[minorversion]--;
279         dprintk("NFS: Couldn't create callback socket: err = %d; "
280                         "net = %p\n", ret, net);
281         return ret;
282 }
283
284 static struct svc_serv_ops nfs_cb_sv_ops = {
285         .svo_enqueue_xprt       = svc_xprt_do_enqueue,
286 };
287
288 static struct svc_serv *nfs_callback_create_svc(int minorversion)
289 {
290         struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
291         struct svc_serv *serv;
292
293         /*
294          * Check whether we're already up and running.
295          */
296         if (cb_info->task) {
297                 /*
298                  * Note: increase service usage, because later in case of error
299                  * svc_destroy() will be called.
300                  */
301                 svc_get(cb_info->serv);
302                 return cb_info->serv;
303         }
304
305         /*
306          * Sanity check: if there's no task,
307          * we should be the first user ...
308          */
309         if (cb_info->users)
310                 printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n",
311                         cb_info->users);
312
313         serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, &nfs_cb_sv_ops);
314         if (!serv) {
315                 printk(KERN_ERR "nfs_callback_create_svc: create service failed\n");
316                 return ERR_PTR(-ENOMEM);
317         }
318         /* As there is only one thread we need to over-ride the
319          * default maximum of 80 connections
320          */
321         serv->sv_maxconn = 1024;
322         dprintk("nfs_callback_create_svc: service created\n");
323         return serv;
324 }
325
326 /*
327  * Bring up the callback thread if it is not already up.
328  */
329 int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
330 {
331         struct svc_serv *serv;
332         struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
333         int ret;
334         struct net *net = xprt->xprt_net;
335
336         mutex_lock(&nfs_callback_mutex);
337
338         serv = nfs_callback_create_svc(minorversion);
339         if (IS_ERR(serv)) {
340                 ret = PTR_ERR(serv);
341                 goto err_create;
342         }
343
344         ret = nfs_callback_up_net(minorversion, serv, net, xprt);
345         if (ret < 0)
346                 goto err_net;
347
348         ret = nfs_callback_start_svc(minorversion, xprt, serv);
349         if (ret < 0)
350                 goto err_start;
351
352         cb_info->users++;
353         /*
354          * svc_create creates the svc_serv with sv_nrthreads == 1, and then
355          * svc_prepare_thread increments that. So we need to call svc_destroy
356          * on both success and failure so that the refcount is 1 when the
357          * thread exits.
358          */
359 err_net:
360         svc_destroy(serv);
361 err_create:
362         mutex_unlock(&nfs_callback_mutex);
363         return ret;
364
365 err_start:
366         nfs_callback_down_net(minorversion, serv, net);
367         dprintk("NFS: Couldn't create server thread; err = %d\n", ret);
368         goto err_net;
369 }
370
371 /*
372  * Kill the callback thread if it's no longer being used.
373  */
374 void nfs_callback_down(int minorversion, struct net *net)
375 {
376         struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
377
378         mutex_lock(&nfs_callback_mutex);
379         nfs_callback_down_net(minorversion, cb_info->serv, net);
380         cb_info->users--;
381         if (cb_info->users == 0 && cb_info->task != NULL) {
382                 kthread_stop(cb_info->task);
383                 dprintk("nfs_callback_down: service stopped\n");
384                 svc_exit_thread(cb_info->rqst);
385                 dprintk("nfs_callback_down: service destroyed\n");
386                 cb_info->serv = NULL;
387                 cb_info->rqst = NULL;
388                 cb_info->task = NULL;
389         }
390         mutex_unlock(&nfs_callback_mutex);
391 }
392
393 /* Boolean check of RPC_AUTH_GSS principal */
394 int
395 check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp)
396 {
397         char *p = rqstp->rq_cred.cr_principal;
398
399         if (rqstp->rq_authop->flavour != RPC_AUTH_GSS)
400                 return 1;
401
402         /* No RPC_AUTH_GSS on NFSv4.1 back channel yet */
403         if (clp->cl_minorversion != 0)
404                 return 0;
405         /*
406          * It might just be a normal user principal, in which case
407          * userspace won't bother to tell us the name at all.
408          */
409         if (p == NULL)
410                 return 0;
411
412         /*
413          * Did we get the acceptor from userland during the SETCLIENID
414          * negotiation?
415          */
416         if (clp->cl_acceptor)
417                 return !strcmp(p, clp->cl_acceptor);
418
419         /*
420          * Otherwise try to verify it using the cl_hostname. Note that this
421          * doesn't work if a non-canonical hostname was used in the devname.
422          */
423
424         /* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
425
426         if (memcmp(p, "nfs@", 4) != 0)
427                 return 0;
428         p += 4;
429         if (strcmp(p, clp->cl_hostname) != 0)
430                 return 0;
431         return 1;
432 }
433
434 /*
435  * pg_authenticate method for nfsv4 callback threads.
436  *
437  * The authflavor has been negotiated, so an incorrect flavor is a server
438  * bug. Deny packets with incorrect authflavor.
439  *
440  * All other checking done after NFS decoding where the nfs_client can be
441  * found in nfs4_callback_compound
442  */
443 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
444 {
445         switch (rqstp->rq_authop->flavour) {
446         case RPC_AUTH_NULL:
447                 if (rqstp->rq_proc != CB_NULL)
448                         return SVC_DENIED;
449                 break;
450         case RPC_AUTH_GSS:
451                 /* No RPC_AUTH_GSS support yet in NFSv4.1 */
452                  if (svc_is_backchannel(rqstp))
453                         return SVC_DENIED;
454         }
455         return SVC_OK;
456 }
457
458 /*
459  * Define NFS4 callback program
460  */
461 static struct svc_version *nfs4_callback_version[] = {
462         [1] = &nfs4_callback_version1,
463         [4] = &nfs4_callback_version4,
464 };
465
466 static struct svc_stat nfs4_callback_stats;
467
468 static struct svc_program nfs4_callback_program = {
469         .pg_prog = NFS4_CALLBACK,                       /* RPC service number */
470         .pg_nvers = ARRAY_SIZE(nfs4_callback_version),  /* Number of entries */
471         .pg_vers = nfs4_callback_version,               /* version table */
472         .pg_name = "NFSv4 callback",                    /* service name */
473         .pg_class = "nfs",                              /* authentication class */
474         .pg_stats = &nfs4_callback_stats,
475         .pg_authenticate = nfs_callback_authenticate,
476 };