blob: 87bd4e4d65dde74969285c54d0eff028705a66eb [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>
12#include <linux/sunrpc/clnt.h>
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -040013#include <linux/sunrpc/xprtsock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/sunrpc/svc.h>
15#include <linux/lockd/lockd.h>
16#include <linux/lockd/sm_inter.h>
17
18
19#define NLMDBG_FACILITY NLMDBG_MONITOR
20
Chuck Lever49695172008-03-14 14:25:39 -040021#define XDR_ADDRBUF_LEN (20)
22
Linus Torvalds1da177e2005-04-16 15:20:36 -070023static struct rpc_clnt * nsm_create(void);
24
25static struct rpc_program nsm_program;
26
27/*
28 * Local NSM state
29 */
Olaf Kirch460f5ca2006-10-04 02:16:03 -070030int nsm_local_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32/*
33 * Common procedure for SM_MON/SM_UNMON calls
34 */
35static int
Olaf Kirch9502c522006-10-04 02:15:56 -070036nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037{
38 struct rpc_clnt *clnt;
39 int status;
40 struct nsm_args args;
Chuck Leverdead28d2006-03-20 13:44:23 -050041 struct rpc_message msg = {
42 .rpc_argp = &args,
43 .rpc_resp = res,
44 };
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46 clnt = nsm_create();
47 if (IS_ERR(clnt)) {
48 status = PTR_ERR(clnt);
49 goto out;
50 }
51
Olaf Kirch9502c522006-10-04 02:15:56 -070052 memset(&args, 0, sizeof(args));
Olaf Kirchabd1f502006-10-04 02:16:01 -070053 args.mon_name = nsm->sm_name;
Olaf Kirch9502c522006-10-04 02:15:56 -070054 args.addr = nsm->sm_addr.sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 args.prog = NLM_PROGRAM;
Olaf Kirch9502c522006-10-04 02:15:56 -070056 args.vers = 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 args.proc = NLMPROC_NSM_NOTIFY;
58 memset(res, 0, sizeof(*res));
59
Chuck Leverdead28d2006-03-20 13:44:23 -050060 msg.rpc_proc = &clnt->cl_procinfo[proc];
61 status = rpc_call_sync(clnt, &msg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 if (status < 0)
63 printk(KERN_DEBUG "nsm_mon_unmon: rpc failed, status=%d\n",
64 status);
65 else
66 status = 0;
Trond Myklebust90c57552007-06-09 19:49:36 -040067 rpc_shutdown_client(clnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 out:
69 return status;
70}
71
72/*
73 * Set up monitoring of a remote host
74 */
75int
76nsm_monitor(struct nlm_host *host)
77{
Olaf Kirch8dead0d2006-10-04 02:15:53 -070078 struct nsm_handle *nsm = host->h_nsmhandle;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 struct nsm_res res;
80 int status;
81
82 dprintk("lockd: nsm_monitor(%s)\n", host->h_name);
Olaf Kirch8dead0d2006-10-04 02:15:53 -070083 BUG_ON(nsm == NULL);
84
85 if (nsm->sm_monitored)
Olaf Kirch977faf32006-10-04 02:15:51 -070086 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Olaf Kirch9502c522006-10-04 02:15:56 -070088 status = nsm_mon_unmon(nsm, SM_MON, &res);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
90 if (status < 0 || res.status != 0)
91 printk(KERN_NOTICE "lockd: cannot monitor %s\n", host->h_name);
92 else
Olaf Kirch8dead0d2006-10-04 02:15:53 -070093 nsm->sm_monitored = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 return status;
95}
96
97/*
98 * Cease to monitor remote host
99 */
100int
101nsm_unmonitor(struct nlm_host *host)
102{
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700103 struct nsm_handle *nsm = host->h_nsmhandle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 struct nsm_res res;
Olaf Kirch977faf32006-10-04 02:15:51 -0700105 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700107 if (nsm == NULL)
Olaf Kirch977faf32006-10-04 02:15:51 -0700108 return 0;
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700109 host->h_nsmhandle = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Olaf Kirch9502c522006-10-04 02:15:56 -0700111 if (atomic_read(&nsm->sm_count) == 1
112 && nsm->sm_monitored && !nsm->sm_sticky) {
113 dprintk("lockd: nsm_unmonitor(%s)\n", host->h_name);
114
115 status = nsm_mon_unmon(nsm, SM_UNMON, &res);
Olaf Kirch977faf32006-10-04 02:15:51 -0700116 if (status < 0)
Olaf Kirch9502c522006-10-04 02:15:56 -0700117 printk(KERN_NOTICE "lockd: cannot unmonitor %s\n",
118 host->h_name);
119 else
120 nsm->sm_monitored = 0;
Olaf Kirch977faf32006-10-04 02:15:51 -0700121 }
Olaf Kirch8dead0d2006-10-04 02:15:53 -0700122 nsm_release(nsm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 return status;
124}
125
126/*
127 * Create NSM client for the local host
128 */
129static struct rpc_clnt *
130nsm_create(void)
131{
Chuck Levere1ec7892006-08-22 20:06:20 -0400132 struct sockaddr_in sin = {
133 .sin_family = AF_INET,
134 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
135 .sin_port = 0,
136 };
137 struct rpc_create_args args = {
\"Talpey, Thomas\0896a722007-09-10 13:48:23 -0400138 .protocol = XPRT_TRANSPORT_UDP,
Chuck Levere1ec7892006-08-22 20:06:20 -0400139 .address = (struct sockaddr *)&sin,
140 .addrsize = sizeof(sin),
141 .servername = "localhost",
142 .program = &nsm_program,
143 .version = SM_VERSION,
144 .authflavor = RPC_AUTH_NULL,
Chuck Levere1ec7892006-08-22 20:06:20 -0400145 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
Chuck Levere1ec7892006-08-22 20:06:20 -0400147 return rpc_create(&args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
150/*
151 * XDR functions for NSM.
152 */
153
Chuck Lever099bd052008-03-14 14:25:32 -0400154static __be32 *xdr_encode_nsm_string(__be32 *p, char *string)
155{
156 size_t len = strlen(string);
157
158 if (len > SM_MAXSTRLEN)
159 len = SM_MAXSTRLEN;
160 return xdr_encode_opaque(p, string, len);
161}
162
Chuck Lever49695172008-03-14 14:25:39 -0400163/*
164 * "mon_name" specifies the host to be monitored.
165 *
166 * Linux uses a text version of the IP address of the remote
167 * host as the host identifier (the "mon_name" argument).
168 *
169 * Linux statd always looks up the canonical hostname first for
170 * whatever remote hostname it receives, so this works alright.
171 */
172static __be32 *xdr_encode_mon_name(__be32 *p, struct nsm_args *argp)
173{
174 char buffer[XDR_ADDRBUF_LEN + 1];
175 char *name = argp->mon_name;
176
177 if (!nsm_use_hostnames) {
178 snprintf(buffer, XDR_ADDRBUF_LEN,
179 NIPQUAD_FMT, NIPQUAD(argp->addr));
180 name = buffer;
181 }
182
183 return xdr_encode_nsm_string(p, name);
184}
185
Al Viro52921e02006-10-19 23:28:46 -0700186static __be32 *
187xdr_encode_common(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
Olaf Kirchabd1f502006-10-04 02:16:01 -0700189 char buffer[20], *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191 /*
192 * Use the dotted-quad IP address of the remote host as
193 * identifier. Linux statd always looks up the canonical
194 * hostname first for whatever remote hostname it receives,
195 * so this works alright.
196 */
Olaf Kirchabd1f502006-10-04 02:16:01 -0700197 if (nsm_use_hostnames) {
198 name = argp->mon_name;
199 } else {
200 sprintf(buffer, "%u.%u.%u.%u", NIPQUAD(argp->addr));
201 name = buffer;
202 }
203 if (!(p = xdr_encode_string(p, name))
Serge E. Hallyne9ff3992006-10-02 02:18:11 -0700204 || !(p = xdr_encode_string(p, utsname()->nodename)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 return ERR_PTR(-EIO);
206 *p++ = htonl(argp->prog);
207 *p++ = htonl(argp->vers);
208 *p++ = htonl(argp->proc);
209
210 return p;
211}
212
213static int
Al Viro52921e02006-10-19 23:28:46 -0700214xdr_encode_mon(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
216 p = xdr_encode_common(rqstp, p, argp);
217 if (IS_ERR(p))
218 return PTR_ERR(p);
Olaf Kirch9502c522006-10-04 02:15:56 -0700219
220 /* Surprise - there may even be room for an IPv6 address now */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 *p++ = argp->addr;
Olaf Kirch9502c522006-10-04 02:15:56 -0700222 *p++ = 0;
223 *p++ = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 *p++ = 0;
225 rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);
226 return 0;
227}
228
229static int
Al Viro52921e02006-10-19 23:28:46 -0700230xdr_encode_unmon(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
232 p = xdr_encode_common(rqstp, p, argp);
233 if (IS_ERR(p))
234 return PTR_ERR(p);
235 rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);
236 return 0;
237}
238
239static int
Al Viro52921e02006-10-19 23:28:46 -0700240xdr_decode_stat_res(struct rpc_rqst *rqstp, __be32 *p, struct nsm_res *resp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
242 resp->status = ntohl(*p++);
243 resp->state = ntohl(*p++);
244 dprintk("nsm: xdr_decode_stat_res status %d state %d\n",
245 resp->status, resp->state);
246 return 0;
247}
248
249static int
Al Viro52921e02006-10-19 23:28:46 -0700250xdr_decode_stat(struct rpc_rqst *rqstp, __be32 *p, struct nsm_res *resp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251{
252 resp->state = ntohl(*p++);
253 return 0;
254}
255
256#define SM_my_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
257#define SM_my_id_sz (3+1+SM_my_name_sz)
258#define SM_mon_id_sz (1+XDR_QUADLEN(20)+SM_my_id_sz)
259#define SM_mon_sz (SM_mon_id_sz+4)
260#define SM_monres_sz 2
261#define SM_unmonres_sz 1
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263static struct rpc_procinfo nsm_procedures[] = {
264[SM_MON] = {
265 .p_proc = SM_MON,
266 .p_encode = (kxdrproc_t) xdr_encode_mon,
267 .p_decode = (kxdrproc_t) xdr_decode_stat_res,
Chuck Lever2bea90d2007-03-29 16:47:53 -0400268 .p_arglen = SM_mon_sz,
269 .p_replen = SM_monres_sz,
Chuck Levercc0175c2006-03-20 13:44:22 -0500270 .p_statidx = SM_MON,
271 .p_name = "MONITOR",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 },
273[SM_UNMON] = {
274 .p_proc = SM_UNMON,
275 .p_encode = (kxdrproc_t) xdr_encode_unmon,
276 .p_decode = (kxdrproc_t) xdr_decode_stat,
Chuck Lever2bea90d2007-03-29 16:47:53 -0400277 .p_arglen = SM_mon_id_sz,
278 .p_replen = SM_unmonres_sz,
Chuck Levercc0175c2006-03-20 13:44:22 -0500279 .p_statidx = SM_UNMON,
280 .p_name = "UNMONITOR",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 },
282};
283
284static struct rpc_version nsm_version1 = {
Tobias Klausere8c96f82006-03-24 03:15:34 -0800285 .number = 1,
286 .nrprocs = ARRAY_SIZE(nsm_procedures),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 .procs = nsm_procedures
288};
289
290static struct rpc_version * nsm_version[] = {
291 [1] = &nsm_version1,
292};
293
294static struct rpc_stat nsm_stats;
295
296static struct rpc_program nsm_program = {
297 .name = "statd",
298 .number = SM_PROGRAM,
Tobias Klausere8c96f82006-03-24 03:15:34 -0800299 .nrvers = ARRAY_SIZE(nsm_version),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 .version = nsm_version,
301 .stats = &nsm_stats
302};