4 * The kernel statd client.
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
9 #include <linux/types.h>
10 #include <linux/kernel.h>
11 #include <linux/ktime.h>
12 #include <linux/slab.h>
14 #include <linux/sunrpc/clnt.h>
15 #include <linux/sunrpc/xprtsock.h>
16 #include <linux/sunrpc/svc.h>
17 #include <linux/lockd/lockd.h>
19 #include <asm/unaligned.h>
23 #define NLMDBG_FACILITY NLMDBG_MONITOR
24 #define NSM_PROGRAM 100024
38 struct nsm_private
*priv
;
39 u32 prog
; /* RPC callback info */
52 static const struct rpc_program nsm_program
;
53 static LIST_HEAD(nsm_handles
);
54 static DEFINE_SPINLOCK(nsm_lock
);
59 u32 __read_mostly nsm_local_state
;
60 bool __read_mostly nsm_use_hostnames
;
62 static inline struct sockaddr
*nsm_addr(const struct nsm_handle
*nsm
)
64 return (struct sockaddr
*)&nsm
->sm_addr
;
67 static struct rpc_clnt
*nsm_create(struct net
*net
)
69 struct sockaddr_in sin
= {
70 .sin_family
= AF_INET
,
71 .sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
),
73 struct rpc_create_args args
= {
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
,
85 return rpc_create(&args
);
88 static struct rpc_clnt
*nsm_client_set(struct lockd_net
*ln
,
89 struct rpc_clnt
*clnt
)
91 spin_lock(&ln
->nsm_clnt_lock
);
92 if (ln
->nsm_users
== 0) {
100 spin_unlock(&ln
->nsm_clnt_lock
);
104 static struct rpc_clnt
*nsm_client_get(struct net
*net
)
106 struct rpc_clnt
*clnt
, *new;
107 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
109 clnt
= nsm_client_set(ln
, NULL
);
113 clnt
= new = nsm_create(net
);
117 clnt
= nsm_client_set(ln
, new);
119 rpc_shutdown_client(new);
124 static void nsm_client_put(struct net
*net
)
126 struct lockd_net
*ln
= net_generic(net
, lockd_net_id
);
127 struct rpc_clnt
*clnt
= NULL
;
129 spin_lock(&ln
->nsm_clnt_lock
);
131 if (ln
->nsm_users
== 0) {
135 spin_unlock(&ln
->nsm_clnt_lock
);
137 rpc_shutdown_client(clnt
);
140 static int nsm_mon_unmon(struct nsm_handle
*nsm
, u32 proc
, struct nsm_res
*res
,
141 struct rpc_clnt
*clnt
)
144 struct nsm_args args
= {
145 .priv
= &nsm
->sm_priv
,
148 .proc
= NLMPROC_NSM_NOTIFY
,
149 .mon_name
= nsm
->sm_mon_name
,
150 .nodename
= clnt
->cl_nodename
,
152 struct rpc_message msg
= {
157 memset(res
, 0, sizeof(*res
));
159 msg
.rpc_proc
= &clnt
->cl_procinfo
[proc
];
160 status
= rpc_call_sync(clnt
, &msg
, RPC_TASK_SOFTCONN
);
162 dprintk("lockd: NSM upcall RPC failed, status=%d\n",
170 * nsm_monitor - Notify a peer in case we reboot
171 * @host: pointer to nlm_host of peer to notify
173 * If this peer is not already monitored, this function sends an
174 * upcall to the local rpc.statd to record the name/address of
175 * the peer to notify in case we reboot.
177 * Returns zero if the peer is monitored by the local rpc.statd;
178 * otherwise a negative errno value is returned.
180 int nsm_monitor(const struct nlm_host
*host
)
182 struct nsm_handle
*nsm
= host
->h_nsmhandle
;
185 struct rpc_clnt
*clnt
;
187 dprintk("lockd: nsm_monitor(%s)\n", nsm
->sm_name
);
189 if (nsm
->sm_monitored
)
193 * Choose whether to record the caller_name or IP address of
194 * this peer in the local rpc.statd's database.
196 nsm
->sm_mon_name
= nsm_use_hostnames
? nsm
->sm_name
: nsm
->sm_addrbuf
;
198 clnt
= nsm_client_get(host
->net
);
200 status
= PTR_ERR(clnt
);
201 dprintk("lockd: failed to create NSM upcall transport, "
202 "status=%d, net=%p\n", status
, host
->net
);
206 status
= nsm_mon_unmon(nsm
, NSMPROC_MON
, &res
, clnt
);
207 if (unlikely(res
.status
!= 0))
209 if (unlikely(status
< 0)) {
210 printk(KERN_NOTICE
"lockd: cannot monitor %s\n", nsm
->sm_name
);
214 nsm
->sm_monitored
= 1;
215 if (unlikely(nsm_local_state
!= res
.state
)) {
216 nsm_local_state
= res
.state
;
217 dprintk("lockd: NSM state changed to %d\n", nsm_local_state
);
223 * nsm_unmonitor - Unregister peer notification
224 * @host: pointer to nlm_host of peer to stop monitoring
226 * If this peer is monitored, this function sends an upcall to
227 * tell the local rpc.statd not to send this peer a notification
230 void nsm_unmonitor(const struct nlm_host
*host
)
232 struct nsm_handle
*nsm
= host
->h_nsmhandle
;
236 if (atomic_read(&nsm
->sm_count
) == 1
237 && nsm
->sm_monitored
&& !nsm
->sm_sticky
) {
238 struct lockd_net
*ln
= net_generic(host
->net
, lockd_net_id
);
240 dprintk("lockd: nsm_unmonitor(%s)\n", nsm
->sm_name
);
242 status
= nsm_mon_unmon(nsm
, NSMPROC_UNMON
, &res
, ln
->nsm_clnt
);
246 printk(KERN_NOTICE
"lockd: cannot unmonitor %s\n",
249 nsm
->sm_monitored
= 0;
251 nsm_client_put(host
->net
);
255 static struct nsm_handle
*nsm_lookup_hostname(const char *hostname
,
258 struct nsm_handle
*nsm
;
260 list_for_each_entry(nsm
, &nsm_handles
, sm_link
)
261 if (strlen(nsm
->sm_name
) == len
&&
262 memcmp(nsm
->sm_name
, hostname
, len
) == 0)
267 static struct nsm_handle
*nsm_lookup_addr(const struct sockaddr
*sap
)
269 struct nsm_handle
*nsm
;
271 list_for_each_entry(nsm
, &nsm_handles
, sm_link
)
272 if (rpc_cmp_addr(nsm_addr(nsm
), sap
))
277 static struct nsm_handle
*nsm_lookup_priv(const struct nsm_private
*priv
)
279 struct nsm_handle
*nsm
;
281 list_for_each_entry(nsm
, &nsm_handles
, sm_link
)
282 if (memcmp(nsm
->sm_priv
.data
, priv
->data
,
283 sizeof(priv
->data
)) == 0)
289 * Construct a unique cookie to match this nsm_handle to this monitored
290 * host. It is passed to the local rpc.statd via NSMPROC_MON, and
291 * returned via NLMPROC_SM_NOTIFY, in the "priv" field of these
294 * The NSM protocol requires that these cookies be unique while the
295 * system is running. We prefer a stronger requirement of making them
296 * unique across reboots. If user space bugs cause a stale cookie to
297 * be sent to the kernel, it could cause the wrong host to lose its
298 * lock state if cookies were not unique across reboots.
300 * The cookies are exposed only to local user space via loopback. They
301 * do not appear on the physical network. If we want greater security
302 * for some reason, nsm_init_private() could perform a one-way hash to
303 * obscure the contents of the cookie.
305 static void nsm_init_private(struct nsm_handle
*nsm
)
307 u64
*p
= (u64
*)&nsm
->sm_priv
.data
;
312 ns
= timespec_to_ns(&ts
);
313 put_unaligned(ns
, p
);
314 put_unaligned((unsigned long)nsm
, p
+ 1);
317 static struct nsm_handle
*nsm_create_handle(const struct sockaddr
*sap
,
319 const char *hostname
,
320 const size_t hostname_len
)
322 struct nsm_handle
*new;
324 new = kzalloc(sizeof(*new) + hostname_len
+ 1, GFP_KERNEL
);
325 if (unlikely(new == NULL
))
328 atomic_set(&new->sm_count
, 1);
329 new->sm_name
= (char *)(new + 1);
330 memcpy(nsm_addr(new), sap
, salen
);
331 new->sm_addrlen
= salen
;
332 nsm_init_private(new);
334 if (rpc_ntop(nsm_addr(new), new->sm_addrbuf
,
335 sizeof(new->sm_addrbuf
)) == 0)
336 (void)snprintf(new->sm_addrbuf
, sizeof(new->sm_addrbuf
),
337 "unsupported address family");
338 memcpy(new->sm_name
, hostname
, hostname_len
);
339 new->sm_name
[hostname_len
] = '\0';
345 * nsm_get_handle - Find or create a cached nsm_handle
346 * @sap: pointer to socket address of handle to find
347 * @salen: length of socket address
348 * @hostname: pointer to C string containing hostname to find
349 * @hostname_len: length of C string
351 * Behavior is modulated by the global nsm_use_hostnames variable.
353 * Returns a cached nsm_handle after bumping its ref count, or
354 * returns a fresh nsm_handle if a handle that matches @sap and/or
355 * @hostname cannot be found in the handle cache. Returns NULL if
358 struct nsm_handle
*nsm_get_handle(const struct sockaddr
*sap
,
359 const size_t salen
, const char *hostname
,
360 const size_t hostname_len
)
362 struct nsm_handle
*cached
, *new = NULL
;
364 if (hostname
&& memchr(hostname
, '/', hostname_len
) != NULL
) {
365 if (printk_ratelimit()) {
366 printk(KERN_WARNING
"Invalid hostname \"%.*s\" "
367 "in NFS lock request\n",
368 (int)hostname_len
, hostname
);
374 spin_lock(&nsm_lock
);
376 if (nsm_use_hostnames
&& hostname
!= NULL
)
377 cached
= nsm_lookup_hostname(hostname
, hostname_len
);
379 cached
= nsm_lookup_addr(sap
);
381 if (cached
!= NULL
) {
382 atomic_inc(&cached
->sm_count
);
383 spin_unlock(&nsm_lock
);
385 dprintk("lockd: found nsm_handle for %s (%s), "
386 "cnt %d\n", cached
->sm_name
,
388 atomic_read(&cached
->sm_count
));
393 list_add(&new->sm_link
, &nsm_handles
);
394 spin_unlock(&nsm_lock
);
395 dprintk("lockd: created nsm_handle for %s (%s)\n",
396 new->sm_name
, new->sm_addrbuf
);
400 spin_unlock(&nsm_lock
);
402 new = nsm_create_handle(sap
, salen
, hostname
, hostname_len
);
403 if (unlikely(new == NULL
))
409 * nsm_reboot_lookup - match NLMPROC_SM_NOTIFY arguments to an nsm_handle
410 * @info: pointer to NLMPROC_SM_NOTIFY arguments
412 * Returns a matching nsm_handle if found in the nsm cache. The returned
413 * nsm_handle's reference count is bumped. Otherwise returns NULL if some
416 struct nsm_handle
*nsm_reboot_lookup(const struct nlm_reboot
*info
)
418 struct nsm_handle
*cached
;
420 spin_lock(&nsm_lock
);
422 cached
= nsm_lookup_priv(&info
->priv
);
423 if (unlikely(cached
== NULL
)) {
424 spin_unlock(&nsm_lock
);
425 dprintk("lockd: never saw rebooted peer '%.*s' before\n",
426 info
->len
, info
->mon
);
430 atomic_inc(&cached
->sm_count
);
431 spin_unlock(&nsm_lock
);
433 dprintk("lockd: host %s (%s) rebooted, cnt %d\n",
434 cached
->sm_name
, cached
->sm_addrbuf
,
435 atomic_read(&cached
->sm_count
));
440 * nsm_release - Release an NSM handle
441 * @nsm: pointer to handle to be released
444 void nsm_release(struct nsm_handle
*nsm
)
446 if (atomic_dec_and_lock(&nsm
->sm_count
, &nsm_lock
)) {
447 list_del(&nsm
->sm_link
);
448 spin_unlock(&nsm_lock
);
449 dprintk("lockd: destroyed nsm_handle for %s (%s)\n",
450 nsm
->sm_name
, nsm
->sm_addrbuf
);
456 * XDR functions for NSM.
458 * See http://www.opengroup.org/ for details on the Network
459 * Status Monitor wire protocol.
462 static void encode_nsm_string(struct xdr_stream
*xdr
, const char *string
)
464 const u32 len
= strlen(string
);
467 p
= xdr_reserve_space(xdr
, 4 + len
);
468 xdr_encode_opaque(p
, string
, len
);
472 * "mon_name" specifies the host to be monitored.
474 static void encode_mon_name(struct xdr_stream
*xdr
, const struct nsm_args
*argp
)
476 encode_nsm_string(xdr
, argp
->mon_name
);
480 * The "my_id" argument specifies the hostname and RPC procedure
481 * to be called when the status manager receives notification
482 * (via the NLMPROC_SM_NOTIFY call) that the state of host "mon_name"
485 static void encode_my_id(struct xdr_stream
*xdr
, const struct nsm_args
*argp
)
489 encode_nsm_string(xdr
, argp
->nodename
);
490 p
= xdr_reserve_space(xdr
, 4 + 4 + 4);
491 *p
++ = cpu_to_be32(argp
->prog
);
492 *p
++ = cpu_to_be32(argp
->vers
);
493 *p
= cpu_to_be32(argp
->proc
);
497 * The "mon_id" argument specifies the non-private arguments
498 * of an NSMPROC_MON or NSMPROC_UNMON call.
500 static void encode_mon_id(struct xdr_stream
*xdr
, const struct nsm_args
*argp
)
502 encode_mon_name(xdr
, argp
);
503 encode_my_id(xdr
, argp
);
507 * The "priv" argument may contain private information required
508 * by the NSMPROC_MON call. This information will be supplied in the
509 * NLMPROC_SM_NOTIFY call.
511 static void encode_priv(struct xdr_stream
*xdr
, const struct nsm_args
*argp
)
515 p
= xdr_reserve_space(xdr
, SM_PRIV_SIZE
);
516 xdr_encode_opaque_fixed(p
, argp
->priv
->data
, SM_PRIV_SIZE
);
519 static void nsm_xdr_enc_mon(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
520 const struct nsm_args
*argp
)
522 encode_mon_id(xdr
, argp
);
523 encode_priv(xdr
, argp
);
526 static void nsm_xdr_enc_unmon(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
527 const struct nsm_args
*argp
)
529 encode_mon_id(xdr
, argp
);
532 static int nsm_xdr_dec_stat_res(struct rpc_rqst
*rqstp
,
533 struct xdr_stream
*xdr
,
534 struct nsm_res
*resp
)
538 p
= xdr_inline_decode(xdr
, 4 + 4);
539 if (unlikely(p
== NULL
))
541 resp
->status
= be32_to_cpup(p
++);
542 resp
->state
= be32_to_cpup(p
);
544 dprintk("lockd: %s status %d state %d\n",
545 __func__
, resp
->status
, resp
->state
);
549 static int nsm_xdr_dec_stat(struct rpc_rqst
*rqstp
,
550 struct xdr_stream
*xdr
,
551 struct nsm_res
*resp
)
555 p
= xdr_inline_decode(xdr
, 4);
556 if (unlikely(p
== NULL
))
558 resp
->state
= be32_to_cpup(p
);
560 dprintk("lockd: %s state %d\n", __func__
, resp
->state
);
564 #define SM_my_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
565 #define SM_my_id_sz (SM_my_name_sz+3)
566 #define SM_mon_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
567 #define SM_mon_id_sz (SM_mon_name_sz+SM_my_id_sz)
568 #define SM_priv_sz (XDR_QUADLEN(SM_PRIV_SIZE))
569 #define SM_mon_sz (SM_mon_id_sz+SM_priv_sz)
570 #define SM_monres_sz 2
571 #define SM_unmonres_sz 1
573 static struct rpc_procinfo nsm_procedures
[] = {
575 .p_proc
= NSMPROC_MON
,
576 .p_encode
= (kxdreproc_t
)nsm_xdr_enc_mon
,
577 .p_decode
= (kxdrdproc_t
)nsm_xdr_dec_stat_res
,
578 .p_arglen
= SM_mon_sz
,
579 .p_replen
= SM_monres_sz
,
580 .p_statidx
= NSMPROC_MON
,
584 .p_proc
= NSMPROC_UNMON
,
585 .p_encode
= (kxdreproc_t
)nsm_xdr_enc_unmon
,
586 .p_decode
= (kxdrdproc_t
)nsm_xdr_dec_stat
,
587 .p_arglen
= SM_mon_id_sz
,
588 .p_replen
= SM_unmonres_sz
,
589 .p_statidx
= NSMPROC_UNMON
,
590 .p_name
= "UNMONITOR",
594 static const struct rpc_version nsm_version1
= {
596 .nrprocs
= ARRAY_SIZE(nsm_procedures
),
597 .procs
= nsm_procedures
600 static const struct rpc_version
*nsm_version
[] = {
604 static struct rpc_stat nsm_stats
;
606 static const struct rpc_program nsm_program
= {
608 .number
= NSM_PROGRAM
,
609 .nrvers
= ARRAY_SIZE(nsm_version
),
610 .version
= nsm_version
,