NSM: Use sm_name instead of h_name in nsm_monitor() and nsm_unmonitor()
[linux-2.6.git] / fs / lockd / mon.c
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>
12 #include <linux/sunrpc/clnt.h>
13 #include <linux/sunrpc/xprtsock.h>
14 #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
21 static struct rpc_clnt *        nsm_create(void);
22
23 static struct rpc_program       nsm_program;
24
25 /*
26  * Local NSM state
27  */
28 int                             nsm_local_state;
29
30 /*
31  * Common procedure for SM_MON/SM_UNMON calls
32  */
33 static int
34 nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res)
35 {
36         struct rpc_clnt *clnt;
37         int             status;
38         struct nsm_args args = {
39                 .addr           = nsm_addr_in(nsm)->sin_addr.s_addr,
40                 .prog           = NLM_PROGRAM,
41                 .vers           = 3,
42                 .proc           = NLMPROC_NSM_NOTIFY,
43                 .mon_name       = nsm->sm_mon_name,
44         };
45         struct rpc_message msg = {
46                 .rpc_argp       = &args,
47                 .rpc_resp       = res,
48         };
49
50         clnt = nsm_create();
51         if (IS_ERR(clnt)) {
52                 status = PTR_ERR(clnt);
53                 dprintk("lockd: failed to create NSM upcall transport, "
54                                 "status=%d\n", status);
55                 goto out;
56         }
57
58         memset(res, 0, sizeof(*res));
59
60         msg.rpc_proc = &clnt->cl_procinfo[proc];
61         status = rpc_call_sync(clnt, &msg, 0);
62         if (status < 0)
63                 dprintk("lockd: NSM upcall RPC failed, status=%d\n",
64                                 status);
65         else
66                 status = 0;
67         rpc_shutdown_client(clnt);
68  out:
69         return status;
70 }
71
72 /*
73  * Set up monitoring of a remote host
74  */
75 int
76 nsm_monitor(struct nlm_host *host)
77 {
78         struct nsm_handle *nsm = host->h_nsmhandle;
79         struct nsm_res  res;
80         int             status;
81
82         dprintk("lockd: nsm_monitor(%s)\n", nsm->sm_name);
83         BUG_ON(nsm == NULL);
84
85         if (nsm->sm_monitored)
86                 return 0;
87
88         /*
89          * Choose whether to record the caller_name or IP address of
90          * this peer in the local rpc.statd's database.
91          */
92         nsm->sm_mon_name = nsm_use_hostnames ? nsm->sm_name : nsm->sm_addrbuf;
93
94         status = nsm_mon_unmon(nsm, SM_MON, &res);
95
96         if (status < 0 || res.status != 0)
97                 printk(KERN_NOTICE "lockd: cannot monitor %s\n", nsm->sm_name);
98         else
99                 nsm->sm_monitored = 1;
100         return status;
101 }
102
103 /*
104  * Cease to monitor remote host
105  */
106 int
107 nsm_unmonitor(struct nlm_host *host)
108 {
109         struct nsm_handle *nsm = host->h_nsmhandle;
110         struct nsm_res  res;
111         int             status = 0;
112
113         if (nsm == NULL)
114                 return 0;
115         host->h_nsmhandle = NULL;
116
117         if (atomic_read(&nsm->sm_count) == 1
118          && nsm->sm_monitored && !nsm->sm_sticky) {
119                 dprintk("lockd: nsm_unmonitor(%s)\n", nsm->sm_name);
120
121                 status = nsm_mon_unmon(nsm, SM_UNMON, &res);
122                 if (status < 0)
123                         printk(KERN_NOTICE "lockd: cannot unmonitor %s\n",
124                                         nsm->sm_name);
125                 else
126                         nsm->sm_monitored = 0;
127         }
128         nsm_release(nsm);
129         return status;
130 }
131
132 /*
133  * Create NSM client for the local host
134  */
135 static struct rpc_clnt *
136 nsm_create(void)
137 {
138         struct sockaddr_in      sin = {
139                 .sin_family     = AF_INET,
140                 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
141                 .sin_port       = 0,
142         };
143         struct rpc_create_args args = {
144                 .protocol       = XPRT_TRANSPORT_UDP,
145                 .address        = (struct sockaddr *)&sin,
146                 .addrsize       = sizeof(sin),
147                 .servername     = "localhost",
148                 .program        = &nsm_program,
149                 .version        = SM_VERSION,
150                 .authflavor     = RPC_AUTH_NULL,
151         };
152
153         return rpc_create(&args);
154 }
155
156 /*
157  * XDR functions for NSM.
158  *
159  * See http://www.opengroup.org/ for details on the Network
160  * Status Monitor wire protocol.
161  */
162
163 static __be32 *xdr_encode_nsm_string(__be32 *p, char *string)
164 {
165         size_t len = strlen(string);
166
167         if (len > SM_MAXSTRLEN)
168                 len = SM_MAXSTRLEN;
169         return xdr_encode_opaque(p, string, len);
170 }
171
172 /*
173  * "mon_name" specifies the host to be monitored.
174  */
175 static __be32 *xdr_encode_mon_name(__be32 *p, struct nsm_args *argp)
176 {
177         return xdr_encode_nsm_string(p, argp->mon_name);
178 }
179
180 /*
181  * The "my_id" argument specifies the hostname and RPC procedure
182  * to be called when the status manager receives notification
183  * (via the SM_NOTIFY call) that the state of host "mon_name"
184  * has changed.
185  */
186 static __be32 *xdr_encode_my_id(__be32 *p, struct nsm_args *argp)
187 {
188         p = xdr_encode_nsm_string(p, utsname()->nodename);
189         if (!p)
190                 return ERR_PTR(-EIO);
191
192         *p++ = htonl(argp->prog);
193         *p++ = htonl(argp->vers);
194         *p++ = htonl(argp->proc);
195
196         return p;
197 }
198
199 /*
200  * The "mon_id" argument specifies the non-private arguments
201  * of an SM_MON or SM_UNMON call.
202  */
203 static __be32 *xdr_encode_mon_id(__be32 *p, struct nsm_args *argp)
204 {
205         p = xdr_encode_mon_name(p, argp);
206         if (!p)
207                 return ERR_PTR(-EIO);
208
209         return xdr_encode_my_id(p, argp);
210 }
211
212 /*
213  * The "priv" argument may contain private information required
214  * by the SM_MON call. This information will be supplied in the
215  * SM_NOTIFY call.
216  *
217  * Linux provides the raw IP address of the monitored host,
218  * left in network byte order.
219  */
220 static __be32 *xdr_encode_priv(__be32 *p, struct nsm_args *argp)
221 {
222         *p++ = argp->addr;
223         *p++ = 0;
224         *p++ = 0;
225         *p++ = 0;
226
227         return p;
228 }
229
230 static int
231 xdr_encode_mon(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp)
232 {
233         p = xdr_encode_mon_id(p, argp);
234         if (IS_ERR(p))
235                 return PTR_ERR(p);
236
237         p = xdr_encode_priv(p, argp);
238         if (IS_ERR(p))
239                 return PTR_ERR(p);
240
241         rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);
242         return 0;
243 }
244
245 static int
246 xdr_encode_unmon(struct rpc_rqst *rqstp, __be32 *p, struct nsm_args *argp)
247 {
248         p = xdr_encode_mon_id(p, argp);
249         if (IS_ERR(p))
250                 return PTR_ERR(p);
251         rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p);
252         return 0;
253 }
254
255 static int
256 xdr_decode_stat_res(struct rpc_rqst *rqstp, __be32 *p, struct nsm_res *resp)
257 {
258         resp->status = ntohl(*p++);
259         resp->state = ntohl(*p++);
260         dprintk("nsm: xdr_decode_stat_res status %d state %d\n",
261                         resp->status, resp->state);
262         return 0;
263 }
264
265 static int
266 xdr_decode_stat(struct rpc_rqst *rqstp, __be32 *p, struct nsm_res *resp)
267 {
268         resp->state = ntohl(*p++);
269         return 0;
270 }
271
272 #define SM_my_name_sz   (1+XDR_QUADLEN(SM_MAXSTRLEN))
273 #define SM_my_id_sz     (SM_my_name_sz+3)
274 #define SM_mon_name_sz  (1+XDR_QUADLEN(SM_MAXSTRLEN))
275 #define SM_mon_id_sz    (SM_mon_name_sz+SM_my_id_sz)
276 #define SM_priv_sz      (XDR_QUADLEN(SM_PRIV_SIZE))
277 #define SM_mon_sz       (SM_mon_id_sz+SM_priv_sz)
278 #define SM_monres_sz    2
279 #define SM_unmonres_sz  1
280
281 static struct rpc_procinfo      nsm_procedures[] = {
282 [SM_MON] = {
283                 .p_proc         = SM_MON,
284                 .p_encode       = (kxdrproc_t) xdr_encode_mon,
285                 .p_decode       = (kxdrproc_t) xdr_decode_stat_res,
286                 .p_arglen       = SM_mon_sz,
287                 .p_replen       = SM_monres_sz,
288                 .p_statidx      = SM_MON,
289                 .p_name         = "MONITOR",
290         },
291 [SM_UNMON] = {
292                 .p_proc         = SM_UNMON,
293                 .p_encode       = (kxdrproc_t) xdr_encode_unmon,
294                 .p_decode       = (kxdrproc_t) xdr_decode_stat,
295                 .p_arglen       = SM_mon_id_sz,
296                 .p_replen       = SM_unmonres_sz,
297                 .p_statidx      = SM_UNMON,
298                 .p_name         = "UNMONITOR",
299         },
300 };
301
302 static struct rpc_version       nsm_version1 = {
303                 .number         = 1,
304                 .nrprocs        = ARRAY_SIZE(nsm_procedures),
305                 .procs          = nsm_procedures
306 };
307
308 static struct rpc_version *     nsm_version[] = {
309         [1] = &nsm_version1,
310 };
311
312 static struct rpc_stat          nsm_stats;
313
314 static struct rpc_program       nsm_program = {
315                 .name           = "statd",
316                 .number         = SM_PROGRAM,
317                 .nrvers         = ARRAY_SIZE(nsm_version),
318                 .version        = nsm_version,
319                 .stats          = &nsm_stats
320 };