mon.c 15 KB

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