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