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