38f240e104ce4f3ed0f0c07947c186649e1fcfaa
[pandora-kernel.git] / fs / lockd / mon.c
1 /*
2  * linux/fs/lockd/mon.c
3  *
4  * The kernel statd client.
5  *
6  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
7  */
8
9 #include <linux/types.h>
10 #include <linux/utsname.h>
11 #include <linux/kernel.h>
12 #include <linux/ktime.h>
13 #include <linux/slab.h>
14
15 #include <linux/sunrpc/clnt.h>
16 #include <linux/sunrpc/xprtsock.h>
17 #include <linux/sunrpc/svc.h>
18 #include <linux/lockd/lockd.h>
19
20 #include <asm/unaligned.h>
21
22 #include "netns.h"
23
24 #define NLMDBG_FACILITY         NLMDBG_MONITOR
25 #define NSM_PROGRAM             100024
26 #define NSM_VERSION             1
27
28 enum {
29         NSMPROC_NULL,
30         NSMPROC_STAT,
31         NSMPROC_MON,
32         NSMPROC_UNMON,
33         NSMPROC_UNMON_ALL,
34         NSMPROC_SIMU_CRASH,
35         NSMPROC_NOTIFY,
36 };
37
38 struct nsm_args {
39         struct nsm_private      *priv;
40         u32                     prog;           /* RPC callback info */
41         u32                     vers;
42         u32                     proc;
43
44         char                    *mon_name;
45 };
46
47 struct nsm_res {
48         u32                     status;
49         u32                     state;
50 };
51
52 static const struct rpc_program nsm_program;
53 static                          LIST_HEAD(nsm_handles);
54 static                          DEFINE_SPINLOCK(nsm_lock);
55
56 /*
57  * Local NSM state
58  */
59 u32     __read_mostly           nsm_local_state;
60 bool    __read_mostly           nsm_use_hostnames;
61
62 static inline struct sockaddr *nsm_addr(const struct nsm_handle *nsm)
63 {
64         return (struct sockaddr *)&nsm->sm_addr;
65 }
66
67 static struct rpc_clnt *nsm_create(struct net *net)
68 {
69         struct sockaddr_in sin = {
70                 .sin_family             = AF_INET,
71                 .sin_addr.s_addr        = htonl(INADDR_LOOPBACK),
72         };
73         struct rpc_create_args args = {
74                 .net                    = net,
75                 .protocol               = XPRT_TRANSPORT_TCP,
76                 .address                = (struct sockaddr *)&sin,
77                 .addrsize               = sizeof(sin),
78                 .servername             = "rpc.statd",
79                 .program                = &nsm_program,
80                 .version                = NSM_VERSION,
81                 .authflavor             = RPC_AUTH_NULL,
82                 .flags                  = RPC_CLNT_CREATE_NOPING,
83         };
84
85         return rpc_create(&args);
86 }
87
88 __maybe_unused static struct rpc_clnt *nsm_client_get(struct net *net)
89 {
90         static DEFINE_MUTEX(nsm_create_mutex);
91         struct rpc_clnt *clnt;
92         struct lockd_net *ln = net_generic(net, lockd_net_id);
93
94         spin_lock(&ln->nsm_clnt_lock);
95         if (ln->nsm_users) {
96                 ln->nsm_users++;
97                 clnt = ln->nsm_clnt;
98                 spin_unlock(&ln->nsm_clnt_lock);
99                 goto out;
100         }
101         spin_unlock(&ln->nsm_clnt_lock);
102
103         mutex_lock(&nsm_create_mutex);
104         clnt = nsm_create(net);
105         if (!IS_ERR(clnt)) {
106                 ln->nsm_clnt = clnt;
107                 smp_wmb();
108                 ln->nsm_users = 1;
109         }
110         mutex_unlock(&nsm_create_mutex);
111 out:
112         return clnt;
113 }
114
115 __maybe_unused static void nsm_client_put(struct net *net)
116 {
117         struct lockd_net *ln = net_generic(net, lockd_net_id);
118         struct rpc_clnt *clnt = ln->nsm_clnt;
119         int shutdown = 0;
120
121         spin_lock(&ln->nsm_clnt_lock);
122         if (ln->nsm_users) {
123                 if (--ln->nsm_users)
124                         ln->nsm_clnt = NULL;
125                 shutdown = !ln->nsm_users;
126         }
127         spin_unlock(&ln->nsm_clnt_lock);
128
129         if (shutdown)
130                 rpc_shutdown_client(clnt);
131 }
132
133 static int nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res,
134                          struct net *net)
135 {
136         struct rpc_clnt *clnt;
137         int             status;
138         struct nsm_args args = {
139                 .priv           = &nsm->sm_priv,
140                 .prog           = NLM_PROGRAM,
141                 .vers           = 3,
142                 .proc           = NLMPROC_NSM_NOTIFY,
143                 .mon_name       = nsm->sm_mon_name,
144         };
145         struct rpc_message msg = {
146                 .rpc_argp       = &args,
147                 .rpc_resp       = res,
148         };
149
150         clnt = nsm_create(net);
151         if (IS_ERR(clnt)) {
152                 status = PTR_ERR(clnt);
153                 dprintk("lockd: failed to create NSM upcall transport, "
154                                 "status=%d\n", status);
155                 goto out;
156         }
157
158         memset(res, 0, sizeof(*res));
159
160         msg.rpc_proc = &clnt->cl_procinfo[proc];
161         status = rpc_call_sync(clnt, &msg, RPC_TASK_SOFTCONN);
162         if (status < 0)
163                 dprintk("lockd: NSM upcall RPC failed, status=%d\n",
164                                 status);
165         else
166                 status = 0;
167         rpc_shutdown_client(clnt);
168  out:
169         return status;
170 }
171
172 /**
173  * nsm_monitor - Notify a peer in case we reboot
174  * @host: pointer to nlm_host of peer to notify
175  *
176  * If this peer is not already monitored, this function sends an
177  * upcall to the local rpc.statd to record the name/address of
178  * the peer to notify in case we reboot.
179  *
180  * Returns zero if the peer is monitored by the local rpc.statd;
181  * otherwise a negative errno value is returned.
182  */
183 int nsm_monitor(const struct nlm_host *host)
184 {
185         struct nsm_handle *nsm = host->h_nsmhandle;
186         struct nsm_res  res;
187         int             status;
188
189         dprintk("lockd: nsm_monitor(%s)\n", nsm->sm_name);
190
191         if (nsm->sm_monitored)
192                 return 0;
193
194         /*
195          * Choose whether to record the caller_name or IP address of
196          * this peer in the local rpc.statd's database.
197          */
198         nsm->sm_mon_name = nsm_use_hostnames ? nsm->sm_name : nsm->sm_addrbuf;
199
200         status = nsm_mon_unmon(nsm, NSMPROC_MON, &res, host->net);
201         if (unlikely(res.status != 0))
202                 status = -EIO;
203         if (unlikely(status < 0)) {
204                 printk(KERN_NOTICE "lockd: cannot monitor %s\n", nsm->sm_name);
205                 return status;
206         }
207
208         nsm->sm_monitored = 1;
209         if (unlikely(nsm_local_state != res.state)) {
210                 nsm_local_state = res.state;
211                 dprintk("lockd: NSM state changed to %d\n", nsm_local_state);
212         }
213         return 0;
214 }
215
216 /**
217  * nsm_unmonitor - Unregister peer notification
218  * @host: pointer to nlm_host of peer to stop monitoring
219  *
220  * If this peer is monitored, this function sends an upcall to
221  * tell the local rpc.statd not to send this peer a notification
222  * when we reboot.
223  */
224 void nsm_unmonitor(const struct nlm_host *host)
225 {
226         struct nsm_handle *nsm = host->h_nsmhandle;
227         struct nsm_res  res;
228         int status;
229
230         if (atomic_read(&nsm->sm_count) == 1
231          && nsm->sm_monitored && !nsm->sm_sticky) {
232                 dprintk("lockd: nsm_unmonitor(%s)\n", nsm->sm_name);
233
234                 status = nsm_mon_unmon(nsm, NSMPROC_UNMON, &res, host->net);
235                 if (res.status != 0)
236                         status = -EIO;
237                 if (status < 0)
238                         printk(KERN_NOTICE "lockd: cannot unmonitor %s\n",
239                                         nsm->sm_name);
240                 else
241                         nsm->sm_monitored = 0;
242         }
243 }
244
245 static struct nsm_handle *nsm_lookup_hostname(const char *hostname,
246                                               const size_t len)
247 {
248         struct nsm_handle *nsm;
249
250         list_for_each_entry(nsm, &nsm_handles, sm_link)
251                 if (strlen(nsm->sm_name) == len &&
252                     memcmp(nsm->sm_name, hostname, len) == 0)
253                         return nsm;
254         return NULL;
255 }
256
257 static struct nsm_handle *nsm_lookup_addr(const struct sockaddr *sap)
258 {
259         struct nsm_handle *nsm;
260
261         list_for_each_entry(nsm, &nsm_handles, sm_link)
262                 if (rpc_cmp_addr(nsm_addr(nsm), sap))
263                         return nsm;
264         return NULL;
265 }
266
267 static struct nsm_handle *nsm_lookup_priv(const struct nsm_private *priv)
268 {
269         struct nsm_handle *nsm;
270
271         list_for_each_entry(nsm, &nsm_handles, sm_link)
272                 if (memcmp(nsm->sm_priv.data, priv->data,
273                                         sizeof(priv->data)) == 0)
274                         return nsm;
275         return NULL;
276 }
277
278 /*
279  * Construct a unique cookie to match this nsm_handle to this monitored
280  * host.  It is passed to the local rpc.statd via NSMPROC_MON, and
281  * returned via NLMPROC_SM_NOTIFY, in the "priv" field of these
282  * requests.
283  *
284  * The NSM protocol requires that these cookies be unique while the
285  * system is running.  We prefer a stronger requirement of making them
286  * unique across reboots.  If user space bugs cause a stale cookie to
287  * be sent to the kernel, it could cause the wrong host to lose its
288  * lock state if cookies were not unique across reboots.
289  *
290  * The cookies are exposed only to local user space via loopback.  They
291  * do not appear on the physical network.  If we want greater security
292  * for some reason, nsm_init_private() could perform a one-way hash to
293  * obscure the contents of the cookie.
294  */
295 static void nsm_init_private(struct nsm_handle *nsm)
296 {
297         u64 *p = (u64 *)&nsm->sm_priv.data;
298         struct timespec ts;
299         s64 ns;
300
301         ktime_get_ts(&ts);
302         ns = timespec_to_ns(&ts);
303         put_unaligned(ns, p);
304         put_unaligned((unsigned long)nsm, p + 1);
305 }
306
307 static struct nsm_handle *nsm_create_handle(const struct sockaddr *sap,
308                                             const size_t salen,
309                                             const char *hostname,
310                                             const size_t hostname_len)
311 {
312         struct nsm_handle *new;
313
314         new = kzalloc(sizeof(*new) + hostname_len + 1, GFP_KERNEL);
315         if (unlikely(new == NULL))
316                 return NULL;
317
318         atomic_set(&new->sm_count, 1);
319         new->sm_name = (char *)(new + 1);
320         memcpy(nsm_addr(new), sap, salen);
321         new->sm_addrlen = salen;
322         nsm_init_private(new);
323
324         if (rpc_ntop(nsm_addr(new), new->sm_addrbuf,
325                                         sizeof(new->sm_addrbuf)) == 0)
326                 (void)snprintf(new->sm_addrbuf, sizeof(new->sm_addrbuf),
327                                 "unsupported address family");
328         memcpy(new->sm_name, hostname, hostname_len);
329         new->sm_name[hostname_len] = '\0';
330
331         return new;
332 }
333
334 /**
335  * nsm_get_handle - Find or create a cached nsm_handle
336  * @sap: pointer to socket address of handle to find
337  * @salen: length of socket address
338  * @hostname: pointer to C string containing hostname to find
339  * @hostname_len: length of C string
340  *
341  * Behavior is modulated by the global nsm_use_hostnames variable.
342  *
343  * Returns a cached nsm_handle after bumping its ref count, or
344  * returns a fresh nsm_handle if a handle that matches @sap and/or
345  * @hostname cannot be found in the handle cache.  Returns NULL if
346  * an error occurs.
347  */
348 struct nsm_handle *nsm_get_handle(const struct sockaddr *sap,
349                                   const size_t salen, const char *hostname,
350                                   const size_t hostname_len)
351 {
352         struct nsm_handle *cached, *new = NULL;
353
354         if (hostname && memchr(hostname, '/', hostname_len) != NULL) {
355                 if (printk_ratelimit()) {
356                         printk(KERN_WARNING "Invalid hostname \"%.*s\" "
357                                             "in NFS lock request\n",
358                                 (int)hostname_len, hostname);
359                 }
360                 return NULL;
361         }
362
363 retry:
364         spin_lock(&nsm_lock);
365
366         if (nsm_use_hostnames && hostname != NULL)
367                 cached = nsm_lookup_hostname(hostname, hostname_len);
368         else
369                 cached = nsm_lookup_addr(sap);
370
371         if (cached != NULL) {
372                 atomic_inc(&cached->sm_count);
373                 spin_unlock(&nsm_lock);
374                 kfree(new);
375                 dprintk("lockd: found nsm_handle for %s (%s), "
376                                 "cnt %d\n", cached->sm_name,
377                                 cached->sm_addrbuf,
378                                 atomic_read(&cached->sm_count));
379                 return cached;
380         }
381
382         if (new != NULL) {
383                 list_add(&new->sm_link, &nsm_handles);
384                 spin_unlock(&nsm_lock);
385                 dprintk("lockd: created nsm_handle for %s (%s)\n",
386                                 new->sm_name, new->sm_addrbuf);
387                 return new;
388         }
389
390         spin_unlock(&nsm_lock);
391
392         new = nsm_create_handle(sap, salen, hostname, hostname_len);
393         if (unlikely(new == NULL))
394                 return NULL;
395         goto retry;
396 }
397
398 /**
399  * nsm_reboot_lookup - match NLMPROC_SM_NOTIFY arguments to an nsm_handle
400  * @info: pointer to NLMPROC_SM_NOTIFY arguments
401  *
402  * Returns a matching nsm_handle if found in the nsm cache. The returned
403  * nsm_handle's reference count is bumped. Otherwise returns NULL if some
404  * error occurred.
405  */
406 struct nsm_handle *nsm_reboot_lookup(const struct nlm_reboot *info)
407 {
408         struct nsm_handle *cached;
409
410         spin_lock(&nsm_lock);
411
412         cached = nsm_lookup_priv(&info->priv);
413         if (unlikely(cached == NULL)) {
414                 spin_unlock(&nsm_lock);
415                 dprintk("lockd: never saw rebooted peer '%.*s' before\n",
416                                 info->len, info->mon);
417                 return cached;
418         }
419
420         atomic_inc(&cached->sm_count);
421         spin_unlock(&nsm_lock);
422
423         dprintk("lockd: host %s (%s) rebooted, cnt %d\n",
424                         cached->sm_name, cached->sm_addrbuf,
425                         atomic_read(&cached->sm_count));
426         return cached;
427 }
428
429 /**
430  * nsm_release - Release an NSM handle
431  * @nsm: pointer to handle to be released
432  *
433  */
434 void nsm_release(struct nsm_handle *nsm)
435 {
436         if (atomic_dec_and_lock(&nsm->sm_count, &nsm_lock)) {
437                 list_del(&nsm->sm_link);
438                 spin_unlock(&nsm_lock);
439                 dprintk("lockd: destroyed nsm_handle for %s (%s)\n",
440                                 nsm->sm_name, nsm->sm_addrbuf);
441                 kfree(nsm);
442         }
443 }
444
445 /*
446  * XDR functions for NSM.
447  *
448  * See http://www.opengroup.org/ for details on the Network
449  * Status Monitor wire protocol.
450  */
451
452 static void encode_nsm_string(struct xdr_stream *xdr, const char *string)
453 {
454         const u32 len = strlen(string);
455         __be32 *p;
456
457         BUG_ON(len > SM_MAXSTRLEN);
458         p = xdr_reserve_space(xdr, 4 + len);
459         xdr_encode_opaque(p, string, len);
460 }
461
462 /*
463  * "mon_name" specifies the host to be monitored.
464  */
465 static void encode_mon_name(struct xdr_stream *xdr, const struct nsm_args *argp)
466 {
467         encode_nsm_string(xdr, argp->mon_name);
468 }
469
470 /*
471  * The "my_id" argument specifies the hostname and RPC procedure
472  * to be called when the status manager receives notification
473  * (via the NLMPROC_SM_NOTIFY call) that the state of host "mon_name"
474  * has changed.
475  */
476 static void encode_my_id(struct xdr_stream *xdr, const struct nsm_args *argp)
477 {
478         __be32 *p;
479
480         encode_nsm_string(xdr, utsname()->nodename);
481         p = xdr_reserve_space(xdr, 4 + 4 + 4);
482         *p++ = cpu_to_be32(argp->prog);
483         *p++ = cpu_to_be32(argp->vers);
484         *p = cpu_to_be32(argp->proc);
485 }
486
487 /*
488  * The "mon_id" argument specifies the non-private arguments
489  * of an NSMPROC_MON or NSMPROC_UNMON call.
490  */
491 static void encode_mon_id(struct xdr_stream *xdr, const struct nsm_args *argp)
492 {
493         encode_mon_name(xdr, argp);
494         encode_my_id(xdr, argp);
495 }
496
497 /*
498  * The "priv" argument may contain private information required
499  * by the NSMPROC_MON call. This information will be supplied in the
500  * NLMPROC_SM_NOTIFY call.
501  */
502 static void encode_priv(struct xdr_stream *xdr, const struct nsm_args *argp)
503 {
504         __be32 *p;
505
506         p = xdr_reserve_space(xdr, SM_PRIV_SIZE);
507         xdr_encode_opaque_fixed(p, argp->priv->data, SM_PRIV_SIZE);
508 }
509
510 static void nsm_xdr_enc_mon(struct rpc_rqst *req, struct xdr_stream *xdr,
511                             const struct nsm_args *argp)
512 {
513         encode_mon_id(xdr, argp);
514         encode_priv(xdr, argp);
515 }
516
517 static void nsm_xdr_enc_unmon(struct rpc_rqst *req, struct xdr_stream *xdr,
518                               const struct nsm_args *argp)
519 {
520         encode_mon_id(xdr, argp);
521 }
522
523 static int nsm_xdr_dec_stat_res(struct rpc_rqst *rqstp,
524                                 struct xdr_stream *xdr,
525                                 struct nsm_res *resp)
526 {
527         __be32 *p;
528
529         p = xdr_inline_decode(xdr, 4 + 4);
530         if (unlikely(p == NULL))
531                 return -EIO;
532         resp->status = be32_to_cpup(p++);
533         resp->state = be32_to_cpup(p);
534
535         dprintk("lockd: %s status %d state %d\n",
536                 __func__, resp->status, resp->state);
537         return 0;
538 }
539
540 static int nsm_xdr_dec_stat(struct rpc_rqst *rqstp,
541                             struct xdr_stream *xdr,
542                             struct nsm_res *resp)
543 {
544         __be32 *p;
545
546         p = xdr_inline_decode(xdr, 4);
547         if (unlikely(p == NULL))
548                 return -EIO;
549         resp->state = be32_to_cpup(p);
550
551         dprintk("lockd: %s state %d\n", __func__, resp->state);
552         return 0;
553 }
554
555 #define SM_my_name_sz   (1+XDR_QUADLEN(SM_MAXSTRLEN))
556 #define SM_my_id_sz     (SM_my_name_sz+3)
557 #define SM_mon_name_sz  (1+XDR_QUADLEN(SM_MAXSTRLEN))
558 #define SM_mon_id_sz    (SM_mon_name_sz+SM_my_id_sz)
559 #define SM_priv_sz      (XDR_QUADLEN(SM_PRIV_SIZE))
560 #define SM_mon_sz       (SM_mon_id_sz+SM_priv_sz)
561 #define SM_monres_sz    2
562 #define SM_unmonres_sz  1
563
564 static struct rpc_procinfo      nsm_procedures[] = {
565 [NSMPROC_MON] = {
566                 .p_proc         = NSMPROC_MON,
567                 .p_encode       = (kxdreproc_t)nsm_xdr_enc_mon,
568                 .p_decode       = (kxdrdproc_t)nsm_xdr_dec_stat_res,
569                 .p_arglen       = SM_mon_sz,
570                 .p_replen       = SM_monres_sz,
571                 .p_statidx      = NSMPROC_MON,
572                 .p_name         = "MONITOR",
573         },
574 [NSMPROC_UNMON] = {
575                 .p_proc         = NSMPROC_UNMON,
576                 .p_encode       = (kxdreproc_t)nsm_xdr_enc_unmon,
577                 .p_decode       = (kxdrdproc_t)nsm_xdr_dec_stat,
578                 .p_arglen       = SM_mon_id_sz,
579                 .p_replen       = SM_unmonres_sz,
580                 .p_statidx      = NSMPROC_UNMON,
581                 .p_name         = "UNMONITOR",
582         },
583 };
584
585 static const struct rpc_version nsm_version1 = {
586                 .number         = 1,
587                 .nrprocs        = ARRAY_SIZE(nsm_procedures),
588                 .procs          = nsm_procedures
589 };
590
591 static const struct rpc_version *nsm_version[] = {
592         [1] = &nsm_version1,
593 };
594
595 static struct rpc_stat          nsm_stats;
596
597 static const struct rpc_program nsm_program = {
598                 .name           = "statd",
599                 .number         = NSM_PROGRAM,
600                 .nrvers         = ARRAY_SIZE(nsm_version),
601                 .version        = nsm_version,
602                 .stats          = &nsm_stats
603 };