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