blob: e4d563543b11066a1acd17a5beb7d0a8916aa520 [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.
Chuck Lever2ca77542008-03-14 14:26:01 -0400152 *
153 * See http://www.opengroup.org/ for details on the Network
154 * Status Monitor wire protocol.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 */
156
Chuck Lever099bd052008-03-14 14:25:32 -0400157static __be32 *xdr_encode_nsm_string(__be32 *p, char *string)
158{
159 size_t len = strlen(string);
160
161 if (len > SM_MAXSTRLEN)
162 len = SM_MAXSTRLEN;
163 return xdr_encode_opaque(p, string, len);
164}
165
Chuck Lever49695172008-03-14 14:25:39 -0400166/*
167 * "mon_name" specifies the host to be monitored.
168 *
169 * Linux uses a text version of the IP address of the remote
170 * host as the host identifier (the "mon_name" argument).
171 *
172 * Linux statd always looks up the canonical hostname first for
173 * whatever remote hostname it receives, so this works alright.
174 */
175static __be32 *xdr_encode_mon_name(__be32 *p, struct nsm_args *argp)
176{
177 char buffer[XDR_ADDRBUF_LEN + 1];
178 char *name = argp->mon_name;
179
180 if (!nsm_use_hostnames) {
181 snprintf(buffer, XDR_ADDRBUF_LEN,
182 NIPQUAD_FMT, NIPQUAD(argp->addr));
183 name = buffer;
184 }
185
186 return xdr_encode_nsm_string(p, name);
187}
188
Chuck Lever850c95f2008-03-14 14:25:46 -0400189/*
190 * The "my_id" argument specifies the hostname and RPC procedure
191 * to be called when the status manager receives notification
192 * (via the SM_NOTIFY call) that the state of host "mon_name"
193 * has changed.
194 */
195static __be32 *xdr_encode_my_id(__be32 *p, struct nsm_args *argp)
196{
197 p = xdr_encode_nsm_string(p, utsname()->nodename);
198 if (!p)
199 return ERR_PTR(-EIO);
200
201 *p++ = htonl(argp->prog);
202 *p++ = htonl(argp->vers);
203 *p++ = htonl(argp->proc);
204
205 return p;
206}
207
Chuck Leverea72a7f2008-03-14 14:25:53 -0400208/*
209 * The "mon_id" argument specifies the non-private arguments
210 * of an SM_MON or SM_UNMON call.
211 */
212static __be32 *xdr_encode_mon_id(__be32 *p, struct nsm_args *argp)
213{
214 p = xdr_encode_mon_name(p, argp);
215 if (!p)
216 return ERR_PTR(-EIO);
217
218 return xdr_encode_my_id(p, argp);
219}
220
Chuck Lever0490a542008-03-14 14:26:08 -0400221/*
222 * The "priv" argument may contain private information required
223 * by the SM_MON call. This information will be supplied in the
224 * SM_NOTIFY call.
225 *
226 * Linux provides the raw IP address of the monitored host,
227 * left in network byte order.
228 */
229static __be32 *xdr_encode_priv(__be32 *p, struct nsm_args *argp)
230{
231 *p++ = argp->addr;
232 *p++ = 0;
233 *p++ = 0;
234 *p++ = 0;
235
236 return p;
237}
238
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239static int
Al Viro52921e02006-10-19 23:28:46 -0700240xdr_encode_mon(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
Chuck Lever2ca77542008-03-14 14:26:01 -0400242 p = xdr_encode_mon_id(p, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 if (IS_ERR(p))
244 return PTR_ERR(p);
Olaf Kirch9502c522006-10-04 02:15:56 -0700245
Chuck Lever0490a542008-03-14 14:26:08 -0400246 p = xdr_encode_priv(p, argp);
247 if (IS_ERR(p))
248 return PTR_ERR(p);
249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);
251 return 0;
252}
253
254static int
Al Viro52921e02006-10-19 23:28:46 -0700255xdr_encode_unmon(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256{
Chuck Lever2ca77542008-03-14 14:26:01 -0400257 p = xdr_encode_mon_id(p, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 if (IS_ERR(p))
259 return PTR_ERR(p);
260 rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);
261 return 0;
262}
263
264static int
Al Viro52921e02006-10-19 23:28:46 -0700265xdr_decode_stat_res(struct rpc_rqst *rqstp, __be32 *p, struct nsm_res *resp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
267 resp->status = ntohl(*p++);
268 resp->state = ntohl(*p++);
269 dprintk("nsm: xdr_decode_stat_res status %d state %d\n",
270 resp->status, resp->state);
271 return 0;
272}
273
274static int
Al Viro52921e02006-10-19 23:28:46 -0700275xdr_decode_stat(struct rpc_rqst *rqstp, __be32 *p, struct nsm_res *resp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
277 resp->state = ntohl(*p++);
278 return 0;
279}
280
281#define SM_my_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
Chuck Lever2ca77542008-03-14 14:26:01 -0400282#define SM_my_id_sz (SM_my_name_sz+3)
283#define SM_mon_name_sz (1+XDR_QUADLEN(SM_MAXSTRLEN))
284#define SM_mon_id_sz (SM_mon_name_sz+SM_my_id_sz)
Chuck Lever0490a542008-03-14 14:26:08 -0400285#define SM_priv_sz (XDR_QUADLEN(SM_PRIV_SIZE))
286#define SM_mon_sz (SM_mon_id_sz+SM_priv_sz)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287#define SM_monres_sz 2
288#define SM_unmonres_sz 1
289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290static struct rpc_procinfo nsm_procedures[] = {
291[SM_MON] = {
292 .p_proc = SM_MON,
293 .p_encode = (kxdrproc_t) xdr_encode_mon,
294 .p_decode = (kxdrproc_t) xdr_decode_stat_res,
Chuck Lever2bea90d2007-03-29 16:47:53 -0400295 .p_arglen = SM_mon_sz,
296 .p_replen = SM_monres_sz,
Chuck Levercc0175c2006-03-20 13:44:22 -0500297 .p_statidx = SM_MON,
298 .p_name = "MONITOR",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 },
300[SM_UNMON] = {
301 .p_proc = SM_UNMON,
302 .p_encode = (kxdrproc_t) xdr_encode_unmon,
303 .p_decode = (kxdrproc_t) xdr_decode_stat,
Chuck Lever2bea90d2007-03-29 16:47:53 -0400304 .p_arglen = SM_mon_id_sz,
305 .p_replen = SM_unmonres_sz,
Chuck Levercc0175c2006-03-20 13:44:22 -0500306 .p_statidx = SM_UNMON,
307 .p_name = "UNMONITOR",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 },
309};
310
311static struct rpc_version nsm_version1 = {
Tobias Klausere8c96f82006-03-24 03:15:34 -0800312 .number = 1,
313 .nrprocs = ARRAY_SIZE(nsm_procedures),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 .procs = nsm_procedures
315};
316
317static struct rpc_version * nsm_version[] = {
318 [1] = &nsm_version1,
319};
320
321static struct rpc_stat nsm_stats;
322
323static struct rpc_program nsm_program = {
324 .name = "statd",
325 .number = SM_PROGRAM,
Tobias Klausere8c96f82006-03-24 03:15:34 -0800326 .nrvers = ARRAY_SIZE(nsm_version),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 .version = nsm_version,
328 .stats = &nsm_stats
329};