blob: 5e2c4d5ac82774011072c05f5f039ec466fca59e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 Lever94da7662008-12-11 17:56:07 -050012#include <linux/ktime.h>
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/sunrpc/clnt.h>
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -040015#include <linux/sunrpc/xprtsock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/sunrpc/svc.h>
17#include <linux/lockd/lockd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
19#define NLMDBG_FACILITY NLMDBG_MONITOR
Chuck Lever36e8e662008-12-05 19:02:07 -050020#define NSM_PROGRAM 100024
21#define NSM_VERSION 1
22
23enum {
24 NSMPROC_NULL,
25 NSMPROC_STAT,
26 NSMPROC_MON,
27 NSMPROC_UNMON,
28 NSMPROC_UNMON_ALL,
29 NSMPROC_SIMU_CRASH,
30 NSMPROC_NOTIFY,
31};
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Chuck Lever9c1bfd02008-12-05 19:01:59 -050033struct nsm_args {
Chuck Levercab2d3c2008-12-05 19:03:24 -050034 struct nsm_private *priv;
Chuck Lever9c1bfd02008-12-05 19:01:59 -050035 u32 prog; /* RPC callback info */
36 u32 vers;
37 u32 proc;
38
39 char *mon_name;
40};
41
42struct nsm_res {
43 u32 status;
44 u32 state;
45};
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static struct rpc_program nsm_program;
Chuck Lever67c6d102008-12-05 19:02:45 -050048static LIST_HEAD(nsm_handles);
49static DEFINE_SPINLOCK(nsm_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51/*
52 * Local NSM state
53 */
Chuck Leverb7ba5972008-12-11 17:56:29 -050054int __read_mostly nsm_local_state;
55int __read_mostly nsm_use_hostnames;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Chuck Lever8529bc52008-12-11 17:56:22 -050057static inline struct sockaddr *nsm_addr(const struct nsm_handle *nsm)
58{
59 return (struct sockaddr *)&nsm->sm_addr;
60}
61
Chuck Lever67c6d102008-12-05 19:02:45 -050062static void nsm_display_ipv4_address(const struct sockaddr *sap, char *buf,
63 const size_t len)
64{
65 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;
66 snprintf(buf, len, "%pI4", &sin->sin_addr.s_addr);
67}
68
69static void nsm_display_ipv6_address(const struct sockaddr *sap, char *buf,
70 const size_t len)
71{
72 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap;
73
74 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
75 snprintf(buf, len, "%pI4", &sin6->sin6_addr.s6_addr32[3]);
76 else if (sin6->sin6_scope_id != 0)
77 snprintf(buf, len, "%pI6%%%u", &sin6->sin6_addr,
78 sin6->sin6_scope_id);
79 else
80 snprintf(buf, len, "%pI6", &sin6->sin6_addr);
81}
82
83static void nsm_display_address(const struct sockaddr *sap,
84 char *buf, const size_t len)
85{
86 switch (sap->sa_family) {
87 case AF_INET:
88 nsm_display_ipv4_address(sap, buf, len);
89 break;
90 case AF_INET6:
91 nsm_display_ipv6_address(sap, buf, len);
92 break;
93 default:
94 snprintf(buf, len, "unsupported address family");
95 break;
96 }
97}
98
Chuck Lever49b56992008-12-11 17:56:37 -050099static struct rpc_clnt *nsm_create(void)
100{
101 struct sockaddr_in sin = {
102 .sin_family = AF_INET,
103 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
104 };
105 struct rpc_create_args args = {
106 .protocol = XPRT_TRANSPORT_UDP,
107 .address = (struct sockaddr *)&sin,
108 .addrsize = sizeof(sin),
109 .servername = "rpc.statd",
110 .program = &nsm_program,
111 .version = NSM_VERSION,
112 .authflavor = RPC_AUTH_NULL,
113 };
114
115 return rpc_create(&args);
116}
117
118static int nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
120 struct rpc_clnt *clnt;
121 int status;
Chuck Levera4846752008-12-04 14:20:23 -0500122 struct nsm_args args = {
Chuck Levercab2d3c2008-12-05 19:03:24 -0500123 .priv = &nsm->sm_priv,
Chuck Levera4846752008-12-04 14:20:23 -0500124 .prog = NLM_PROGRAM,
125 .vers = 3,
126 .proc = NLMPROC_NSM_NOTIFY,
Chuck Lever29ed1402008-12-04 14:20:46 -0500127 .mon_name = nsm->sm_mon_name,
Chuck Levera4846752008-12-04 14:20:23 -0500128 };
Chuck Leverdead28d2006-03-20 13:44:23 -0500129 struct rpc_message msg = {
130 .rpc_argp = &args,
131 .rpc_resp = res,
132 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
134 clnt = nsm_create();
135 if (IS_ERR(clnt)) {
136 status = PTR_ERR(clnt);
Chuck Lever5acf4312008-12-04 14:20:31 -0500137 dprintk("lockd: failed to create NSM upcall transport, "
138 "status=%d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 goto out;
140 }
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 memset(res, 0, sizeof(*res));
143
Chuck Leverdead28d2006-03-20 13:44:23 -0500144 msg.rpc_proc = &clnt->cl_procinfo[proc];
145 status = rpc_call_sync(clnt, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 if (status < 0)
Chuck Lever5acf4312008-12-04 14:20:31 -0500147 dprintk("lockd: NSM upcall RPC failed, status=%d\n",
148 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 else
150 status = 0;
Trond Myklebust90c57552007-06-09 19:49:36 -0400151 rpc_shutdown_client(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 out:
153 return status;
154}
155
Chuck Lever1e493232008-12-04 14:21:24 -0500156/**
157 * nsm_monitor - Notify a peer in case we reboot
158 * @host: pointer to nlm_host of peer to notify
159 *
160 * If this peer is not already monitored, this function sends an
161 * upcall to the local rpc.statd to record the name/address of
162 * the peer to notify in case we reboot.
163 *
164 * Returns zero if the peer is monitored by the local rpc.statd;
165 * otherwise a negative errno value is returned.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 */
Chuck Lever1e493232008-12-04 14:21:24 -0500167int nsm_monitor(const struct nlm_host *host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700169 struct nsm_handle *nsm = host->h_nsmhandle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 struct nsm_res res;
171 int status;
172
Chuck Lever9fee4902008-12-04 14:20:53 -0500173 dprintk("lockd: nsm_monitor(%s)\n", nsm->sm_name);
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700174
175 if (nsm->sm_monitored)
Olaf Kirch977faf32006-10-04 02:15:51 -0700176 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
Chuck Lever29ed1402008-12-04 14:20:46 -0500178 /*
179 * Choose whether to record the caller_name or IP address of
180 * this peer in the local rpc.statd's database.
181 */
182 nsm->sm_mon_name = nsm_use_hostnames ? nsm->sm_name : nsm->sm_addrbuf;
183
Chuck Lever36e8e662008-12-05 19:02:07 -0500184 status = nsm_mon_unmon(nsm, NSMPROC_MON, &res);
Chuck Lever5d254b12008-12-04 14:21:15 -0500185 if (res.status != 0)
186 status = -EIO;
187 if (status < 0)
Chuck Lever9fee4902008-12-04 14:20:53 -0500188 printk(KERN_NOTICE "lockd: cannot monitor %s\n", nsm->sm_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 else
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700190 nsm->sm_monitored = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 return status;
192}
193
Chuck Lever356c3eb2008-12-04 14:21:38 -0500194/**
195 * nsm_unmonitor - Unregister peer notification
196 * @host: pointer to nlm_host of peer to stop monitoring
197 *
198 * If this peer is monitored, this function sends an upcall to
199 * tell the local rpc.statd not to send this peer a notification
200 * when we reboot.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 */
Chuck Lever356c3eb2008-12-04 14:21:38 -0500202void nsm_unmonitor(const struct nlm_host *host)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203{
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700204 struct nsm_handle *nsm = host->h_nsmhandle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 struct nsm_res res;
Chuck Lever356c3eb2008-12-04 14:21:38 -0500206 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Olaf Kirch9502c522006-10-04 02:15:56 -0700208 if (atomic_read(&nsm->sm_count) == 1
209 && nsm->sm_monitored && !nsm->sm_sticky) {
Chuck Lever9fee4902008-12-04 14:20:53 -0500210 dprintk("lockd: nsm_unmonitor(%s)\n", nsm->sm_name);
Olaf Kirch9502c522006-10-04 02:15:56 -0700211
Chuck Lever36e8e662008-12-05 19:02:07 -0500212 status = nsm_mon_unmon(nsm, NSMPROC_UNMON, &res);
Chuck Lever0c7aef42008-12-04 14:21:46 -0500213 if (res.status != 0)
214 status = -EIO;
Olaf Kirch977faf32006-10-04 02:15:51 -0700215 if (status < 0)
Olaf Kirch9502c522006-10-04 02:15:56 -0700216 printk(KERN_NOTICE "lockd: cannot unmonitor %s\n",
Chuck Lever9fee4902008-12-04 14:20:53 -0500217 nsm->sm_name);
Olaf Kirch9502c522006-10-04 02:15:56 -0700218 else
219 nsm->sm_monitored = 0;
Olaf Kirch977faf32006-10-04 02:15:51 -0700220 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221}
222
Chuck Lever3420a8c2008-12-05 19:03:46 -0500223static struct nsm_handle *nsm_lookup_hostname(const char *hostname,
224 const size_t len)
225{
226 struct nsm_handle *nsm;
227
228 list_for_each_entry(nsm, &nsm_handles, sm_link)
229 if (strlen(nsm->sm_name) == len &&
230 memcmp(nsm->sm_name, hostname, len) == 0)
231 return nsm;
232 return NULL;
233}
234
Chuck Lever77a3ef32008-12-11 17:55:59 -0500235static struct nsm_handle *nsm_lookup_addr(const struct sockaddr *sap)
236{
237 struct nsm_handle *nsm;
238
239 list_for_each_entry(nsm, &nsm_handles, sm_link)
240 if (nlm_cmp_addr(nsm_addr(nsm), sap))
241 return nsm;
242 return NULL;
243}
244
Chuck Lever3420a8c2008-12-05 19:03:46 -0500245static struct nsm_handle *nsm_lookup_priv(const struct nsm_private *priv)
246{
247 struct nsm_handle *nsm;
248
249 list_for_each_entry(nsm, &nsm_handles, sm_link)
250 if (memcmp(nsm->sm_priv.data, priv->data,
251 sizeof(priv->data)) == 0)
252 return nsm;
253 return NULL;
254}
255
Chuck Lever7e44d3b2008-12-05 19:03:16 -0500256/*
257 * Construct a unique cookie to match this nsm_handle to this monitored
258 * host. It is passed to the local rpc.statd via NSMPROC_MON, and
259 * returned via NLMPROC_SM_NOTIFY, in the "priv" field of these
260 * requests.
261 *
Chuck Lever94da7662008-12-11 17:56:07 -0500262 * The NSM protocol requires that these cookies be unique while the
263 * system is running. We prefer a stronger requirement of making them
264 * unique across reboots. If user space bugs cause a stale cookie to
265 * be sent to the kernel, it could cause the wrong host to lose its
266 * lock state if cookies were not unique across reboots.
267 *
268 * The cookies are exposed only to local user space via loopback. They
269 * do not appear on the physical network. If we want greater security
270 * for some reason, nsm_init_private() could perform a one-way hash to
271 * obscure the contents of the cookie.
Chuck Lever7e44d3b2008-12-05 19:03:16 -0500272 */
273static void nsm_init_private(struct nsm_handle *nsm)
274{
Chuck Lever94da7662008-12-11 17:56:07 -0500275 u64 *p = (u64 *)&nsm->sm_priv.data;
276 struct timespec ts;
277
278 ktime_get_ts(&ts);
279 *p++ = timespec_to_ns(&ts);
280 *p = (unsigned long)nsm;
Chuck Lever7e44d3b2008-12-05 19:03:16 -0500281}
282
Chuck Leverb39b8972008-12-11 17:55:52 -0500283static struct nsm_handle *nsm_create_handle(const struct sockaddr *sap,
284 const size_t salen,
285 const char *hostname,
286 const size_t hostname_len)
287{
288 struct nsm_handle *new;
289
290 new = kzalloc(sizeof(*new) + hostname_len + 1, GFP_KERNEL);
291 if (unlikely(new == NULL))
292 return NULL;
293
294 atomic_set(&new->sm_count, 1);
295 new->sm_name = (char *)(new + 1);
296 memcpy(nsm_addr(new), sap, salen);
297 new->sm_addrlen = salen;
298 nsm_init_private(new);
299 nsm_display_address((const struct sockaddr *)&new->sm_addr,
300 new->sm_addrbuf, sizeof(new->sm_addrbuf));
301 memcpy(new->sm_name, hostname, hostname_len);
302 new->sm_name[hostname_len] = '\0';
303
304 return new;
305}
306
Chuck Lever67c6d102008-12-05 19:02:45 -0500307/**
Chuck Lever92fd91b2008-12-05 19:04:01 -0500308 * nsm_get_handle - Find or create a cached nsm_handle
Chuck Lever67c6d102008-12-05 19:02:45 -0500309 * @sap: pointer to socket address of handle to find
310 * @salen: length of socket address
311 * @hostname: pointer to C string containing hostname to find
312 * @hostname_len: length of C string
Chuck Lever67c6d102008-12-05 19:02:45 -0500313 *
Chuck Lever92fd91b2008-12-05 19:04:01 -0500314 * Behavior is modulated by the global nsm_use_hostnames variable.
Chuck Lever67c6d102008-12-05 19:02:45 -0500315 *
Chuck Lever92fd91b2008-12-05 19:04:01 -0500316 * Returns a cached nsm_handle after bumping its ref count, or
317 * returns a fresh nsm_handle if a handle that matches @sap and/or
318 * @hostname cannot be found in the handle cache. Returns NULL if
319 * an error occurs.
Chuck Lever67c6d102008-12-05 19:02:45 -0500320 */
Chuck Lever92fd91b2008-12-05 19:04:01 -0500321struct nsm_handle *nsm_get_handle(const struct sockaddr *sap,
322 const size_t salen, const char *hostname,
323 const size_t hostname_len)
Chuck Lever67c6d102008-12-05 19:02:45 -0500324{
Chuck Lever77a3ef32008-12-11 17:55:59 -0500325 struct nsm_handle *cached, *new = NULL;
Chuck Lever67c6d102008-12-05 19:02:45 -0500326
Chuck Lever67c6d102008-12-05 19:02:45 -0500327 if (hostname && memchr(hostname, '/', hostname_len) != NULL) {
328 if (printk_ratelimit()) {
329 printk(KERN_WARNING "Invalid hostname \"%.*s\" "
330 "in NFS lock request\n",
331 (int)hostname_len, hostname);
332 }
333 return NULL;
334 }
335
336retry:
337 spin_lock(&nsm_lock);
Chuck Lever67c6d102008-12-05 19:02:45 -0500338
Chuck Lever77a3ef32008-12-11 17:55:59 -0500339 if (nsm_use_hostnames && hostname != NULL)
340 cached = nsm_lookup_hostname(hostname, hostname_len);
341 else
342 cached = nsm_lookup_addr(sap);
343
344 if (cached != NULL) {
345 atomic_inc(&cached->sm_count);
346 spin_unlock(&nsm_lock);
347 kfree(new);
348 dprintk("lockd: found nsm_handle for %s (%s), "
349 "cnt %d\n", cached->sm_name,
350 cached->sm_addrbuf,
351 atomic_read(&cached->sm_count));
352 return cached;
Chuck Lever67c6d102008-12-05 19:02:45 -0500353 }
Chuck Lever77a3ef32008-12-11 17:55:59 -0500354
355 if (new != NULL) {
356 list_add(&new->sm_link, &nsm_handles);
357 spin_unlock(&nsm_lock);
Chuck Lever5cf1c4b2008-12-05 19:02:53 -0500358 dprintk("lockd: created nsm_handle for %s (%s)\n",
Chuck Lever77a3ef32008-12-11 17:55:59 -0500359 new->sm_name, new->sm_addrbuf);
360 return new;
Chuck Lever67c6d102008-12-05 19:02:45 -0500361 }
Chuck Lever77a3ef32008-12-11 17:55:59 -0500362
Chuck Lever67c6d102008-12-05 19:02:45 -0500363 spin_unlock(&nsm_lock);
364
Chuck Lever77a3ef32008-12-11 17:55:59 -0500365 new = nsm_create_handle(sap, salen, hostname, hostname_len);
366 if (unlikely(new == NULL))
Chuck Lever67c6d102008-12-05 19:02:45 -0500367 return NULL;
Chuck Lever67c6d102008-12-05 19:02:45 -0500368 goto retry;
Chuck Lever67c6d102008-12-05 19:02:45 -0500369}
370
371/**
Chuck Lever3420a8c2008-12-05 19:03:46 -0500372 * nsm_reboot_lookup - match NLMPROC_SM_NOTIFY arguments to an nsm_handle
373 * @info: pointer to NLMPROC_SM_NOTIFY arguments
374 *
375 * Returns a matching nsm_handle if found in the nsm cache; the returned
376 * nsm_handle's reference count is bumped and sm_monitored is cleared.
377 * Otherwise returns NULL if some error occurred.
378 */
379struct nsm_handle *nsm_reboot_lookup(const struct nlm_reboot *info)
380{
381 struct nsm_handle *cached;
382
383 spin_lock(&nsm_lock);
384
Chuck Lever94da7662008-12-11 17:56:07 -0500385 cached = nsm_lookup_priv(&info->priv);
Chuck Lever3420a8c2008-12-05 19:03:46 -0500386 if (unlikely(cached == NULL)) {
387 spin_unlock(&nsm_lock);
388 dprintk("lockd: never saw rebooted peer '%.*s' before\n",
389 info->len, info->mon);
390 return cached;
391 }
392
393 atomic_inc(&cached->sm_count);
394 spin_unlock(&nsm_lock);
395
396 /*
397 * During subsequent lock activity, force a fresh
398 * notification to be set up for this host.
399 */
400 cached->sm_monitored = 0;
401
402 dprintk("lockd: host %s (%s) rebooted, cnt %d\n",
403 cached->sm_name, cached->sm_addrbuf,
404 atomic_read(&cached->sm_count));
405 return cached;
406}
407
408/**
Chuck Lever67c6d102008-12-05 19:02:45 -0500409 * nsm_release - Release an NSM handle
410 * @nsm: pointer to handle to be released
411 *
412 */
413void nsm_release(struct nsm_handle *nsm)
414{
Chuck Lever67c6d102008-12-05 19:02:45 -0500415 if (atomic_dec_and_lock(&nsm->sm_count, &nsm_lock)) {
416 list_del(&nsm->sm_link);
417 spin_unlock(&nsm_lock);
Chuck Lever5cf1c4b2008-12-05 19:02:53 -0500418 dprintk("lockd: destroyed nsm_handle for %s (%s)\n",
419 nsm->sm_name, nsm->sm_addrbuf);
Chuck Lever67c6d102008-12-05 19:02:45 -0500420 kfree(nsm);
421 }
422}
423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 * XDR functions for NSM.
Chuck Lever2ca77542008-03-14 14:26:01 -0400426 *
427 * See http://www.opengroup.org/ for details on the Network
428 * Status Monitor wire protocol.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 */
430
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500431static int encode_nsm_string(struct xdr_stream *xdr, const char *string)
Chuck Lever099bd052008-03-14 14:25:32 -0400432{
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500433 const u32 len = strlen(string);
434 __be32 *p;
Chuck Lever099bd052008-03-14 14:25:32 -0400435
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500436 if (unlikely(len > SM_MAXSTRLEN))
437 return -EIO;
438 p = xdr_reserve_space(xdr, sizeof(u32) + len);
439 if (unlikely(p == NULL))
440 return -EIO;
441 xdr_encode_opaque(p, string, len);
442 return 0;
Chuck Lever099bd052008-03-14 14:25:32 -0400443}
444
Chuck Lever49695172008-03-14 14:25:39 -0400445/*
446 * "mon_name" specifies the host to be monitored.
Chuck Lever49695172008-03-14 14:25:39 -0400447 */
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500448static int encode_mon_name(struct xdr_stream *xdr, const struct nsm_args *argp)
Chuck Lever49695172008-03-14 14:25:39 -0400449{
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500450 return encode_nsm_string(xdr, argp->mon_name);
Chuck Lever49695172008-03-14 14:25:39 -0400451}
452
Chuck Lever850c95f2008-03-14 14:25:46 -0400453/*
454 * The "my_id" argument specifies the hostname and RPC procedure
455 * to be called when the status manager receives notification
Chuck Lever36e8e662008-12-05 19:02:07 -0500456 * (via the NLMPROC_SM_NOTIFY call) that the state of host "mon_name"
Chuck Lever850c95f2008-03-14 14:25:46 -0400457 * has changed.
458 */
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500459static int encode_my_id(struct xdr_stream *xdr, const struct nsm_args *argp)
Chuck Lever850c95f2008-03-14 14:25:46 -0400460{
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500461 int status;
462 __be32 *p;
Chuck Lever850c95f2008-03-14 14:25:46 -0400463
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500464 status = encode_nsm_string(xdr, utsname()->nodename);
465 if (unlikely(status != 0))
466 return status;
467 p = xdr_reserve_space(xdr, 3 * sizeof(u32));
468 if (unlikely(p == NULL))
469 return -EIO;
Chuck Lever850c95f2008-03-14 14:25:46 -0400470 *p++ = htonl(argp->prog);
471 *p++ = htonl(argp->vers);
472 *p++ = htonl(argp->proc);
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500473 return 0;
Chuck Lever850c95f2008-03-14 14:25:46 -0400474}
475
Chuck Leverea72a7f2008-03-14 14:25:53 -0400476/*
477 * The "mon_id" argument specifies the non-private arguments
Chuck Lever36e8e662008-12-05 19:02:07 -0500478 * of an NSMPROC_MON or NSMPROC_UNMON call.
Chuck Leverea72a7f2008-03-14 14:25:53 -0400479 */
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500480static int encode_mon_id(struct xdr_stream *xdr, const struct nsm_args *argp)
Chuck Leverea72a7f2008-03-14 14:25:53 -0400481{
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500482 int status;
Chuck Leverea72a7f2008-03-14 14:25:53 -0400483
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500484 status = encode_mon_name(xdr, argp);
485 if (unlikely(status != 0))
486 return status;
487 return encode_my_id(xdr, argp);
Chuck Leverea72a7f2008-03-14 14:25:53 -0400488}
489
Chuck Lever0490a542008-03-14 14:26:08 -0400490/*
491 * The "priv" argument may contain private information required
Chuck Lever36e8e662008-12-05 19:02:07 -0500492 * by the NSMPROC_MON call. This information will be supplied in the
493 * NLMPROC_SM_NOTIFY call.
Chuck Lever0490a542008-03-14 14:26:08 -0400494 */
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500495static int encode_priv(struct xdr_stream *xdr, const struct nsm_args *argp)
Chuck Lever0490a542008-03-14 14:26:08 -0400496{
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500497 __be32 *p;
498
499 p = xdr_reserve_space(xdr, SM_PRIV_SIZE);
500 if (unlikely(p == NULL))
501 return -EIO;
Chuck Levercab2d3c2008-12-05 19:03:24 -0500502 xdr_encode_opaque_fixed(p, argp->priv->data, SM_PRIV_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 return 0;
504}
505
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500506static int xdr_enc_mon(struct rpc_rqst *req, __be32 *p,
507 const struct nsm_args *argp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508{
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500509 struct xdr_stream xdr;
510 int status;
511
512 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
513 status = encode_mon_id(&xdr, argp);
514 if (unlikely(status))
515 return status;
516 return encode_priv(&xdr, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517}
518
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500519static int xdr_enc_unmon(struct rpc_rqst *req, __be32 *p,
520 const struct nsm_args *argp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500522 struct xdr_stream xdr;
523
524 xdr_init_encode(&xdr, &req->rq_snd_buf, p);
525 return encode_mon_id(&xdr, argp);
526}
527
528static int xdr_dec_stat_res(struct rpc_rqst *rqstp, __be32 *p,
529 struct nsm_res *resp)
530{
531 struct xdr_stream xdr;
532
533 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
534 p = xdr_inline_decode(&xdr, 2 * sizeof(u32));
535 if (unlikely(p == NULL))
536 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 resp->status = ntohl(*p++);
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500538 resp->state = ntohl(*p);
539
540 dprintk("lockd: xdr_dec_stat_res status %d state %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 resp->status, resp->state);
542 return 0;
543}
544
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500545static int xdr_dec_stat(struct rpc_rqst *rqstp, __be32 *p,
546 struct nsm_res *resp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500548 struct xdr_stream xdr;
549
550 xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
551 p = xdr_inline_decode(&xdr, sizeof(u32));
552 if (unlikely(p == NULL))
553 return -EIO;
554 resp->state = ntohl(*p);
555
556 dprintk("lockd: xdr_dec_stat state %d\n", resp->state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 return 0;
558}
559
560#define SM_my_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
Chuck Lever2ca77542008-03-14 14:26:01 -0400561#define SM_my_id_sz (SM_my_name_sz+3)
562#define SM_mon_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
563#define SM_mon_id_sz (SM_mon_name_sz+SM_my_id_sz)
Chuck Lever0490a542008-03-14 14:26:08 -0400564#define SM_priv_sz (XDR_QUADLEN(SM_PRIV_SIZE))
565#define SM_mon_sz (SM_mon_id_sz+SM_priv_sz)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566#define SM_monres_sz 2
567#define SM_unmonres_sz 1
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569static struct rpc_procinfo nsm_procedures[] = {
Chuck Lever36e8e662008-12-05 19:02:07 -0500570[NSMPROC_MON] = {
571 .p_proc = NSMPROC_MON,
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500572 .p_encode = (kxdrproc_t)xdr_enc_mon,
573 .p_decode = (kxdrproc_t)xdr_dec_stat_res,
Chuck Lever2bea90d2007-03-29 16:47:53 -0400574 .p_arglen = SM_mon_sz,
575 .p_replen = SM_monres_sz,
Chuck Lever36e8e662008-12-05 19:02:07 -0500576 .p_statidx = NSMPROC_MON,
Chuck Levercc0175c2006-03-20 13:44:22 -0500577 .p_name = "MONITOR",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 },
Chuck Lever36e8e662008-12-05 19:02:07 -0500579[NSMPROC_UNMON] = {
580 .p_proc = NSMPROC_UNMON,
Chuck Lever03eb1dc2008-12-05 19:02:15 -0500581 .p_encode = (kxdrproc_t)xdr_enc_unmon,
582 .p_decode = (kxdrproc_t)xdr_dec_stat,
Chuck Lever2bea90d2007-03-29 16:47:53 -0400583 .p_arglen = SM_mon_id_sz,
584 .p_replen = SM_unmonres_sz,
Chuck Lever36e8e662008-12-05 19:02:07 -0500585 .p_statidx = NSMPROC_UNMON,
Chuck Levercc0175c2006-03-20 13:44:22 -0500586 .p_name = "UNMONITOR",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 },
588};
589
590static struct rpc_version nsm_version1 = {
Tobias Klausere8c96f82006-03-24 03:15:34 -0800591 .number = 1,
592 .nrprocs = ARRAY_SIZE(nsm_procedures),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 .procs = nsm_procedures
594};
595
596static struct rpc_version * nsm_version[] = {
597 [1] = &nsm_version1,
598};
599
600static struct rpc_stat nsm_stats;
601
602static struct rpc_program nsm_program = {
603 .name = "statd",
Chuck Lever36e8e662008-12-05 19:02:07 -0500604 .number = NSM_PROGRAM,
Tobias Klausere8c96f82006-03-24 03:15:34 -0800605 .nrvers = ARRAY_SIZE(nsm_version),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 .version = nsm_version,
607 .stats = &nsm_stats
608};