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