ia64/linux-2.6.18-xen.hg

view net/sunrpc/pmap_clnt.c @ 871:9cbcc9008446

xen/x86: don't initialize cpu_data[]'s apicid field on generic code

Afaict, this is not only redundant with the intialization done in
drivers/xen/core/smpboot.c, but actually results - at least for
secondary CPUs - in the Xen-specific value written to be later
overwritten with whatever the generic code determines (with no
guarantee that the two values are identical).

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu May 14 10:09:15 2009 +0100 (2009-05-14)
parents 831230e53067
children
line source
1 /*
2 * linux/net/sunrpc/pmap.c
3 *
4 * Portmapper client.
5 *
6 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
7 */
9 #include <linux/types.h>
10 #include <linux/socket.h>
11 #include <linux/kernel.h>
12 #include <linux/errno.h>
13 #include <linux/uio.h>
14 #include <linux/in.h>
15 #include <linux/sunrpc/clnt.h>
16 #include <linux/sunrpc/xprt.h>
17 #include <linux/sunrpc/sched.h>
19 #ifdef RPC_DEBUG
20 # define RPCDBG_FACILITY RPCDBG_PMAP
21 #endif
23 #define PMAP_SET 1
24 #define PMAP_UNSET 2
25 #define PMAP_GETPORT 3
27 static struct rpc_procinfo pmap_procedures[];
28 static struct rpc_clnt * pmap_create(char *, struct sockaddr_in *, int, int);
29 static void pmap_getport_done(struct rpc_task *);
30 static struct rpc_program pmap_program;
31 static DEFINE_SPINLOCK(pmap_lock);
33 /*
34 * Obtain the port for a given RPC service on a given host. This one can
35 * be called for an ongoing RPC request.
36 */
37 void
38 rpc_getport(struct rpc_task *task, struct rpc_clnt *clnt)
39 {
40 struct rpc_portmap *map = clnt->cl_pmap;
41 struct sockaddr_in *sap = &clnt->cl_xprt->addr;
42 struct rpc_message msg = {
43 .rpc_proc = &pmap_procedures[PMAP_GETPORT],
44 .rpc_argp = map,
45 .rpc_resp = &clnt->cl_port,
46 .rpc_cred = NULL
47 };
48 struct rpc_clnt *pmap_clnt;
49 struct rpc_task *child;
51 dprintk("RPC: %4d rpc_getport(%s, %d, %d, %d)\n",
52 task->tk_pid, clnt->cl_server,
53 map->pm_prog, map->pm_vers, map->pm_prot);
55 /* Autobind on cloned rpc clients is discouraged */
56 BUG_ON(clnt->cl_parent != clnt);
58 spin_lock(&pmap_lock);
59 if (map->pm_binding) {
60 rpc_sleep_on(&map->pm_bindwait, task, NULL, NULL);
61 spin_unlock(&pmap_lock);
62 return;
63 }
64 map->pm_binding = 1;
65 spin_unlock(&pmap_lock);
67 pmap_clnt = pmap_create(clnt->cl_server, sap, map->pm_prot, 0);
68 if (IS_ERR(pmap_clnt)) {
69 task->tk_status = PTR_ERR(pmap_clnt);
70 goto bailout;
71 }
72 task->tk_status = 0;
74 /*
75 * Note: rpc_new_child will release client after a failure.
76 */
77 if (!(child = rpc_new_child(pmap_clnt, task)))
78 goto bailout;
80 /* Setup the call info struct */
81 rpc_call_setup(child, &msg, 0);
83 /* ... and run the child task */
84 task->tk_xprt->stat.bind_count++;
85 rpc_run_child(task, child, pmap_getport_done);
86 return;
88 bailout:
89 spin_lock(&pmap_lock);
90 map->pm_binding = 0;
91 rpc_wake_up(&map->pm_bindwait);
92 spin_unlock(&pmap_lock);
93 rpc_exit(task, -EIO);
94 }
96 #ifdef CONFIG_ROOT_NFS
97 int
98 rpc_getport_external(struct sockaddr_in *sin, __u32 prog, __u32 vers, int prot)
99 {
100 struct rpc_portmap map = {
101 .pm_prog = prog,
102 .pm_vers = vers,
103 .pm_prot = prot,
104 .pm_port = 0
105 };
106 struct rpc_message msg = {
107 .rpc_proc = &pmap_procedures[PMAP_GETPORT],
108 .rpc_argp = &map,
109 .rpc_resp = &map.pm_port,
110 };
111 struct rpc_clnt *pmap_clnt;
112 char hostname[32];
113 int status;
115 dprintk("RPC: rpc_getport_external(%u.%u.%u.%u, %d, %d, %d)\n",
116 NIPQUAD(sin->sin_addr.s_addr), prog, vers, prot);
118 sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(sin->sin_addr.s_addr));
119 pmap_clnt = pmap_create(hostname, sin, prot, 0);
120 if (IS_ERR(pmap_clnt))
121 return PTR_ERR(pmap_clnt);
123 /* Setup the call info struct */
124 status = rpc_call_sync(pmap_clnt, &msg, 0);
126 if (status >= 0) {
127 if (map.pm_port != 0)
128 return map.pm_port;
129 status = -EACCES;
130 }
131 return status;
132 }
133 #endif
135 static void
136 pmap_getport_done(struct rpc_task *task)
137 {
138 struct rpc_clnt *clnt = task->tk_client;
139 struct rpc_xprt *xprt = task->tk_xprt;
140 struct rpc_portmap *map = clnt->cl_pmap;
142 dprintk("RPC: %4d pmap_getport_done(status %d, port %d)\n",
143 task->tk_pid, task->tk_status, clnt->cl_port);
145 xprt->ops->set_port(xprt, 0);
146 if (task->tk_status < 0) {
147 /* Make the calling task exit with an error */
148 task->tk_action = rpc_exit_task;
149 } else if (clnt->cl_port == 0) {
150 /* Program not registered */
151 rpc_exit(task, -EACCES);
152 } else {
153 xprt->ops->set_port(xprt, clnt->cl_port);
154 clnt->cl_port = htons(clnt->cl_port);
155 }
156 spin_lock(&pmap_lock);
157 map->pm_binding = 0;
158 rpc_wake_up(&map->pm_bindwait);
159 spin_unlock(&pmap_lock);
160 }
162 /*
163 * Set or unset a port registration with the local portmapper.
164 * port == 0 means unregister, port != 0 means register.
165 */
166 int
167 rpc_register(u32 prog, u32 vers, int prot, unsigned short port, int *okay)
168 {
169 struct sockaddr_in sin = {
170 .sin_family = AF_INET,
171 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
172 };
173 struct rpc_portmap map = {
174 .pm_prog = prog,
175 .pm_vers = vers,
176 .pm_prot = prot,
177 .pm_port = port,
178 };
179 struct rpc_message msg = {
180 .rpc_proc = &pmap_procedures[port ? PMAP_SET : PMAP_UNSET],
181 .rpc_argp = &map,
182 .rpc_resp = okay,
183 };
184 struct rpc_clnt *pmap_clnt;
185 int error = 0;
187 dprintk("RPC: registering (%d, %d, %d, %d) with portmapper.\n",
188 prog, vers, prot, port);
190 pmap_clnt = pmap_create("localhost", &sin, IPPROTO_UDP, 1);
191 if (IS_ERR(pmap_clnt)) {
192 error = PTR_ERR(pmap_clnt);
193 dprintk("RPC: couldn't create pmap client. Error = %d\n", error);
194 return error;
195 }
197 error = rpc_call_sync(pmap_clnt, &msg, 0);
199 if (error < 0) {
200 printk(KERN_WARNING
201 "RPC: failed to contact portmap (errno %d).\n",
202 error);
203 }
204 dprintk("RPC: registration status %d/%d\n", error, *okay);
206 /* Client deleted automatically because cl_oneshot == 1 */
207 return error;
208 }
210 static struct rpc_clnt *
211 pmap_create(char *hostname, struct sockaddr_in *srvaddr, int proto, int privileged)
212 {
213 struct rpc_xprt *xprt;
214 struct rpc_clnt *clnt;
216 /* printk("pmap: create xprt\n"); */
217 xprt = xprt_create_proto(proto, srvaddr, NULL);
218 if (IS_ERR(xprt))
219 return (struct rpc_clnt *)xprt;
220 xprt->ops->set_port(xprt, RPC_PMAP_PORT);
221 if (!privileged)
222 xprt->resvport = 0;
224 /* printk("pmap: create clnt\n"); */
225 clnt = rpc_new_client(xprt, hostname,
226 &pmap_program, RPC_PMAP_VERSION,
227 RPC_AUTH_UNIX);
228 if (!IS_ERR(clnt)) {
229 clnt->cl_softrtry = 1;
230 clnt->cl_oneshot = 1;
231 }
232 return clnt;
233 }
235 /*
236 * XDR encode/decode functions for PMAP
237 */
238 static int
239 xdr_encode_mapping(struct rpc_rqst *req, u32 *p, struct rpc_portmap *map)
240 {
241 dprintk("RPC: xdr_encode_mapping(%d, %d, %d, %d)\n",
242 map->pm_prog, map->pm_vers, map->pm_prot, map->pm_port);
243 *p++ = htonl(map->pm_prog);
244 *p++ = htonl(map->pm_vers);
245 *p++ = htonl(map->pm_prot);
246 *p++ = htonl(map->pm_port);
248 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
249 return 0;
250 }
252 static int
253 xdr_decode_port(struct rpc_rqst *req, u32 *p, unsigned short *portp)
254 {
255 *portp = (unsigned short) ntohl(*p++);
256 return 0;
257 }
259 static int
260 xdr_decode_bool(struct rpc_rqst *req, u32 *p, unsigned int *boolp)
261 {
262 *boolp = (unsigned int) ntohl(*p++);
263 return 0;
264 }
266 static struct rpc_procinfo pmap_procedures[] = {
267 [PMAP_SET] = {
268 .p_proc = PMAP_SET,
269 .p_encode = (kxdrproc_t) xdr_encode_mapping,
270 .p_decode = (kxdrproc_t) xdr_decode_bool,
271 .p_bufsiz = 4,
272 .p_count = 1,
273 .p_statidx = PMAP_SET,
274 .p_name = "SET",
275 },
276 [PMAP_UNSET] = {
277 .p_proc = PMAP_UNSET,
278 .p_encode = (kxdrproc_t) xdr_encode_mapping,
279 .p_decode = (kxdrproc_t) xdr_decode_bool,
280 .p_bufsiz = 4,
281 .p_count = 1,
282 .p_statidx = PMAP_UNSET,
283 .p_name = "UNSET",
284 },
285 [PMAP_GETPORT] = {
286 .p_proc = PMAP_GETPORT,
287 .p_encode = (kxdrproc_t) xdr_encode_mapping,
288 .p_decode = (kxdrproc_t) xdr_decode_port,
289 .p_bufsiz = 4,
290 .p_count = 1,
291 .p_statidx = PMAP_GETPORT,
292 .p_name = "GETPORT",
293 },
294 };
296 static struct rpc_version pmap_version2 = {
297 .number = 2,
298 .nrprocs = 4,
299 .procs = pmap_procedures
300 };
302 static struct rpc_version * pmap_version[] = {
303 NULL,
304 NULL,
305 &pmap_version2
306 };
308 static struct rpc_stat pmap_stats;
310 static struct rpc_program pmap_program = {
311 .name = "portmap",
312 .number = RPC_PMAP_PROGRAM,
313 .nrvers = ARRAY_SIZE(pmap_version),
314 .version = pmap_version,
315 .stats = &pmap_stats,
316 };