4 * The kernel statd client.
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
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>
15 #include <linux/sunrpc/clnt.h>
16 #include <linux/sunrpc/xprtsock.h>
17 #include <linux/sunrpc/svc.h>
18 #include <linux/lockd/lockd.h>
20 #include <asm/unaligned.h>
22 #define NLMDBG_FACILITY NLMDBG_MONITOR
23 #define NSM_PROGRAM 100024
37 struct nsm_private
*priv
;
38 u32 prog
; /* RPC callback info */
50 static struct rpc_program nsm_program
;
51 static LIST_HEAD(nsm_handles
);
52 static DEFINE_SPINLOCK(nsm_lock
);
57 u32 __read_mostly nsm_local_state
;
58 int __read_mostly nsm_use_hostnames
;
60 static inline struct sockaddr
*nsm_addr(const struct nsm_handle
*nsm
)
62 return (struct sockaddr
*)&nsm
->sm_addr
;
65 static struct rpc_clnt
*nsm_create(void)
67 struct sockaddr_in sin
= {
68 .sin_family
= AF_INET
,
69 .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
),
71 struct rpc_create_args args
= {
73 .protocol
= XPRT_TRANSPORT_UDP
,
74 .address
= (struct sockaddr
*)&sin
,
75 .addrsize
= sizeof(sin
),
76 .servername
= "rpc.statd",
77 .program
= &nsm_program
,
78 .version
= NSM_VERSION
,
79 .authflavor
= RPC_AUTH_NULL
,
80 .flags
= RPC_CLNT_CREATE_NOPING
,
83 return rpc_create(&args
);
86 static int nsm_mon_unmon(struct nsm_handle
*nsm
, u32 proc
, struct nsm_res
*res
)
88 struct rpc_clnt
*clnt
;
90 struct nsm_args args
= {
91 .priv
= &nsm
->sm_priv
,
94 .proc
= NLMPROC_NSM_NOTIFY
,
95 .mon_name
= nsm
->sm_mon_name
,
97 struct rpc_message msg
= {
104 status
= PTR_ERR(clnt
);
105 dprintk("lockd: failed to create NSM upcall transport, "
106 "status=%d\n", status
);
110 memset(res
, 0, sizeof(*res
));
112 msg
.rpc_proc
= &clnt
->cl_procinfo
[proc
];
113 status
= rpc_call_sync(clnt
, &msg
, 0);
115 dprintk("lockd: NSM upcall RPC failed, status=%d\n",
119 rpc_shutdown_client(clnt
);
125 * nsm_monitor - Notify a peer in case we reboot
126 * @host: pointer to nlm_host of peer to notify
128 * If this peer is not already monitored, this function sends an
129 * upcall to the local rpc.statd to record the name/address of
130 * the peer to notify in case we reboot.
132 * Returns zero if the peer is monitored by the local rpc.statd;
133 * otherwise a negative errno value is returned.
135 int nsm_monitor(const struct nlm_host
*host
)
137 struct nsm_handle
*nsm
= host
->h_nsmhandle
;
141 dprintk("lockd: nsm_monitor(%s)\n", nsm
->sm_name
);
143 if (nsm
->sm_monitored
)
147 * Choose whether to record the caller_name or IP address of
148 * this peer in the local rpc.statd's database.
150 nsm
->sm_mon_name
= nsm_use_hostnames
? nsm
->sm_name
: nsm
->sm_addrbuf
;
152 status
= nsm_mon_unmon(nsm
, NSMPROC_MON
, &res
);
153 if (unlikely(res
.status
!= 0))
155 if (unlikely(status
< 0)) {
156 printk(KERN_NOTICE
"lockd: cannot monitor %s\n", nsm
->sm_name
);
160 nsm
->sm_monitored
= 1;
161 if (unlikely(nsm_local_state
!= res
.state
)) {
162 nsm_local_state
= res
.state
;
163 dprintk("lockd: NSM state changed to %d\n", nsm_local_state
);
169 * nsm_unmonitor - Unregister peer notification
170 * @host: pointer to nlm_host of peer to stop monitoring
172 * If this peer is monitored, this function sends an upcall to
173 * tell the local rpc.statd not to send this peer a notification
176 void nsm_unmonitor(const struct nlm_host
*host
)
178 struct nsm_handle
*nsm
= host
->h_nsmhandle
;
182 if (atomic_read(&nsm
->sm_count
) == 1
183 && nsm
->sm_monitored
&& !nsm
->sm_sticky
) {
184 dprintk("lockd: nsm_unmonitor(%s)\n", nsm
->sm_name
);
186 status
= nsm_mon_unmon(nsm
, NSMPROC_UNMON
, &res
);
190 printk(KERN_NOTICE
"lockd: cannot unmonitor %s\n",
193 nsm
->sm_monitored
= 0;
197 static struct nsm_handle
*nsm_lookup_hostname(const char *hostname
,
200 struct nsm_handle
*nsm
;
202 list_for_each_entry(nsm
, &nsm_handles
, sm_link
)
203 if (strlen(nsm
->sm_name
) == len
&&
204 memcmp(nsm
->sm_name
, hostname
, len
) == 0)
209 static struct nsm_handle
*nsm_lookup_addr(const struct sockaddr
*sap
)
211 struct nsm_handle
*nsm
;
213 list_for_each_entry(nsm
, &nsm_handles
, sm_link
)
214 if (rpc_cmp_addr(nsm_addr(nsm
), sap
))
219 static struct nsm_handle
*nsm_lookup_priv(const struct nsm_private
*priv
)
221 struct nsm_handle
*nsm
;
223 list_for_each_entry(nsm
, &nsm_handles
, sm_link
)
224 if (memcmp(nsm
->sm_priv
.data
, priv
->data
,
225 sizeof(priv
->data
)) == 0)
231 * Construct a unique cookie to match this nsm_handle to this monitored
232 * host. It is passed to the local rpc.statd via NSMPROC_MON, and
233 * returned via NLMPROC_SM_NOTIFY, in the "priv" field of these
236 * The NSM protocol requires that these cookies be unique while the
237 * system is running. We prefer a stronger requirement of making them
238 * unique across reboots. If user space bugs cause a stale cookie to
239 * be sent to the kernel, it could cause the wrong host to lose its
240 * lock state if cookies were not unique across reboots.
242 * The cookies are exposed only to local user space via loopback. They
243 * do not appear on the physical network. If we want greater security
244 * for some reason, nsm_init_private() could perform a one-way hash to
245 * obscure the contents of the cookie.
247 static void nsm_init_private(struct nsm_handle
*nsm
)
249 u64
*p
= (u64
*)&nsm
->sm_priv
.data
;
254 ns
= timespec_to_ns(&ts
);
255 put_unaligned(ns
, p
);
256 put_unaligned((unsigned long)nsm
, p
+ 1);
259 static struct nsm_handle
*nsm_create_handle(const struct sockaddr
*sap
,
261 const char *hostname
,
262 const size_t hostname_len
)
264 struct nsm_handle
*new;
266 new = kzalloc(sizeof(*new) + hostname_len
+ 1, GFP_KERNEL
);
267 if (unlikely(new == NULL
))
270 atomic_set(&new->sm_count
, 1);
271 new->sm_name
= (char *)(new + 1);
272 memcpy(nsm_addr(new), sap
, salen
);
273 new->sm_addrlen
= salen
;
274 nsm_init_private(new);
276 if (rpc_ntop(nsm_addr(new), new->sm_addrbuf
,
277 sizeof(new->sm_addrbuf
)) == 0)
278 (void)snprintf(new->sm_addrbuf
, sizeof(new->sm_addrbuf
),
279 "unsupported address family");
280 memcpy(new->sm_name
, hostname
, hostname_len
);
281 new->sm_name
[hostname_len
] = '\0';
287 * nsm_get_handle - Find or create a cached nsm_handle
288 * @sap: pointer to socket address of handle to find
289 * @salen: length of socket address
290 * @hostname: pointer to C string containing hostname to find
291 * @hostname_len: length of C string
293 * Behavior is modulated by the global nsm_use_hostnames variable.
295 * Returns a cached nsm_handle after bumping its ref count, or
296 * returns a fresh nsm_handle if a handle that matches @sap and/or
297 * @hostname cannot be found in the handle cache. Returns NULL if
300 struct nsm_handle
*nsm_get_handle(const struct sockaddr
*sap
,
301 const size_t salen
, const char *hostname
,
302 const size_t hostname_len
)
304 struct nsm_handle
*cached
, *new = NULL
;
306 if (hostname
&& memchr(hostname
, '/', hostname_len
) != NULL
) {
307 if (printk_ratelimit()) {
308 printk(KERN_WARNING
"Invalid hostname \"%.*s\" "
309 "in NFS lock request\n",
310 (int)hostname_len
, hostname
);
316 spin_lock(&nsm_lock
);
318 if (nsm_use_hostnames
&& hostname
!= NULL
)
319 cached
= nsm_lookup_hostname(hostname
, hostname_len
);
321 cached
= nsm_lookup_addr(sap
);
323 if (cached
!= NULL
) {
324 atomic_inc(&cached
->sm_count
);
325 spin_unlock(&nsm_lock
);
327 dprintk("lockd: found nsm_handle for %s (%s), "
328 "cnt %d\n", cached
->sm_name
,
330 atomic_read(&cached
->sm_count
));
335 list_add(&new->sm_link
, &nsm_handles
);
336 spin_unlock(&nsm_lock
);
337 dprintk("lockd: created nsm_handle for %s (%s)\n",
338 new->sm_name
, new->sm_addrbuf
);
342 spin_unlock(&nsm_lock
);
344 new = nsm_create_handle(sap
, salen
, hostname
, hostname_len
);
345 if (unlikely(new == NULL
))
351 * nsm_reboot_lookup - match NLMPROC_SM_NOTIFY arguments to an nsm_handle
352 * @info: pointer to NLMPROC_SM_NOTIFY arguments
354 * Returns a matching nsm_handle if found in the nsm cache. The returned
355 * nsm_handle's reference count is bumped. Otherwise returns NULL if some
358 struct nsm_handle
*nsm_reboot_lookup(const struct nlm_reboot
*info
)
360 struct nsm_handle
*cached
;
362 spin_lock(&nsm_lock
);
364 cached
= nsm_lookup_priv(&info
->priv
);
365 if (unlikely(cached
== NULL
)) {
366 spin_unlock(&nsm_lock
);
367 dprintk("lockd: never saw rebooted peer '%.*s' before\n",
368 info
->len
, info
->mon
);
372 atomic_inc(&cached
->sm_count
);
373 spin_unlock(&nsm_lock
);
375 dprintk("lockd: host %s (%s) rebooted, cnt %d\n",
376 cached
->sm_name
, cached
->sm_addrbuf
,
377 atomic_read(&cached
->sm_count
));
382 * nsm_release - Release an NSM handle
383 * @nsm: pointer to handle to be released
386 void nsm_release(struct nsm_handle
*nsm
)
388 if (atomic_dec_and_lock(&nsm
->sm_count
, &nsm_lock
)) {
389 list_del(&nsm
->sm_link
);
390 spin_unlock(&nsm_lock
);
391 dprintk("lockd: destroyed nsm_handle for %s (%s)\n",
392 nsm
->sm_name
, nsm
->sm_addrbuf
);
398 * XDR functions for NSM.
400 * See http://www.opengroup.org/ for details on the Network
401 * Status Monitor wire protocol.
404 static int encode_nsm_string(struct xdr_stream
*xdr
, const char *string
)
406 const u32 len
= strlen(string
);
409 if (unlikely(len
> SM_MAXSTRLEN
))
411 p
= xdr_reserve_space(xdr
, sizeof(u32
) + len
);
412 if (unlikely(p
== NULL
))
414 xdr_encode_opaque(p
, string
, len
);
419 * "mon_name" specifies the host to be monitored.
421 static int encode_mon_name(struct xdr_stream
*xdr
, const struct nsm_args
*argp
)
423 return encode_nsm_string(xdr
, argp
->mon_name
);
427 * The "my_id" argument specifies the hostname and RPC procedure
428 * to be called when the status manager receives notification
429 * (via the NLMPROC_SM_NOTIFY call) that the state of host "mon_name"
432 static int encode_my_id(struct xdr_stream
*xdr
, const struct nsm_args
*argp
)
437 status
= encode_nsm_string(xdr
, utsname()->nodename
);
438 if (unlikely(status
!= 0))
440 p
= xdr_reserve_space(xdr
, 3 * sizeof(u32
));
441 if (unlikely(p
== NULL
))
443 *p
++ = htonl(argp
->prog
);
444 *p
++ = htonl(argp
->vers
);
445 *p
++ = htonl(argp
->proc
);
450 * The "mon_id" argument specifies the non-private arguments
451 * of an NSMPROC_MON or NSMPROC_UNMON call.
453 static int encode_mon_id(struct xdr_stream
*xdr
, const struct nsm_args
*argp
)
457 status
= encode_mon_name(xdr
, argp
);
458 if (unlikely(status
!= 0))
460 return encode_my_id(xdr
, argp
);
464 * The "priv" argument may contain private information required
465 * by the NSMPROC_MON call. This information will be supplied in the
466 * NLMPROC_SM_NOTIFY call.
468 static int encode_priv(struct xdr_stream
*xdr
, const struct nsm_args
*argp
)
472 p
= xdr_reserve_space(xdr
, SM_PRIV_SIZE
);
473 if (unlikely(p
== NULL
))
475 xdr_encode_opaque_fixed(p
, argp
->priv
->data
, SM_PRIV_SIZE
);
479 static int xdr_enc_mon(struct rpc_rqst
*req
, __be32
*p
,
480 const struct nsm_args
*argp
)
482 struct xdr_stream xdr
;
485 xdr_init_encode(&xdr
, &req
->rq_snd_buf
, p
);
486 status
= encode_mon_id(&xdr
, argp
);
487 if (unlikely(status
))
489 return encode_priv(&xdr
, argp
);
492 static int xdr_enc_unmon(struct rpc_rqst
*req
, __be32
*p
,
493 const struct nsm_args
*argp
)
495 struct xdr_stream xdr
;
497 xdr_init_encode(&xdr
, &req
->rq_snd_buf
, p
);
498 return encode_mon_id(&xdr
, argp
);
501 static int xdr_dec_stat_res(struct rpc_rqst
*rqstp
, __be32
*p
,
502 struct nsm_res
*resp
)
504 struct xdr_stream xdr
;
506 xdr_init_decode(&xdr
, &rqstp
->rq_rcv_buf
, p
);
507 p
= xdr_inline_decode(&xdr
, 2 * sizeof(u32
));
508 if (unlikely(p
== NULL
))
510 resp
->status
= ntohl(*p
++);
511 resp
->state
= ntohl(*p
);
513 dprintk("lockd: xdr_dec_stat_res status %d state %d\n",
514 resp
->status
, resp
->state
);
518 static int xdr_dec_stat(struct rpc_rqst
*rqstp
, __be32
*p
,
519 struct nsm_res
*resp
)
521 struct xdr_stream xdr
;
523 xdr_init_decode(&xdr
, &rqstp
->rq_rcv_buf
, p
);
524 p
= xdr_inline_decode(&xdr
, sizeof(u32
));
525 if (unlikely(p
== NULL
))
527 resp
->state
= ntohl(*p
);
529 dprintk("lockd: xdr_dec_stat state %d\n", resp
->state
);
533 #define SM_my_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
534 #define SM_my_id_sz (SM_my_name_sz+3)
535 #define SM_mon_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
536 #define SM_mon_id_sz (SM_mon_name_sz+SM_my_id_sz)
537 #define SM_priv_sz (XDR_QUADLEN(SM_PRIV_SIZE))
538 #define SM_mon_sz (SM_mon_id_sz+SM_priv_sz)
539 #define SM_monres_sz 2
540 #define SM_unmonres_sz 1
542 static struct rpc_procinfo nsm_procedures
[] = {
544 .p_proc
= NSMPROC_MON
,
545 .p_encode
= (kxdrproc_t
)xdr_enc_mon
,
546 .p_decode
= (kxdrproc_t
)xdr_dec_stat_res
,
547 .p_arglen
= SM_mon_sz
,
548 .p_replen
= SM_monres_sz
,
549 .p_statidx
= NSMPROC_MON
,
553 .p_proc
= NSMPROC_UNMON
,
554 .p_encode
= (kxdrproc_t
)xdr_enc_unmon
,
555 .p_decode
= (kxdrproc_t
)xdr_dec_stat
,
556 .p_arglen
= SM_mon_id_sz
,
557 .p_replen
= SM_unmonres_sz
,
558 .p_statidx
= NSMPROC_UNMON
,
559 .p_name
= "UNMONITOR",
563 static struct rpc_version nsm_version1
= {
565 .nrprocs
= ARRAY_SIZE(nsm_procedures
),
566 .procs
= nsm_procedures
569 static struct rpc_version
* nsm_version
[] = {
573 static struct rpc_stat nsm_stats
;
575 static struct rpc_program nsm_program
= {
577 .number
= NSM_PROGRAM
,
578 .nrvers
= ARRAY_SIZE(nsm_version
),
579 .version
= nsm_version
,