FreeBSD/Linux Kernel Cross Reference
sys/rpc/clnt_rc.c
1 /*-
2 * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
3 * Authors: Doug Rabson <dfr@rabson.org>
4 * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD: src/sys/rpc/clnt_rc.c,v 1.6 2008/11/03 10:38:00 dfr Exp $");
30
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/kernel.h>
34 #include <sys/limits.h>
35 #include <sys/lock.h>
36 #include <sys/malloc.h>
37 #include <sys/mbuf.h>
38 #include <sys/mutex.h>
39 #include <sys/pcpu.h>
40 #include <sys/proc.h>
41 #include <sys/socket.h>
42 #include <sys/socketvar.h>
43 #include <sys/time.h>
44 #include <sys/uio.h>
45
46 #include <rpc/rpc.h>
47 #include <rpc/rpc_com.h>
48
49 static enum clnt_stat clnt_reconnect_call(CLIENT *, struct rpc_callextra *,
50 rpcproc_t, struct mbuf *, struct mbuf **, struct timeval);
51 static void clnt_reconnect_geterr(CLIENT *, struct rpc_err *);
52 static bool_t clnt_reconnect_freeres(CLIENT *, xdrproc_t, void *);
53 static void clnt_reconnect_abort(CLIENT *);
54 static bool_t clnt_reconnect_control(CLIENT *, u_int, void *);
55 static void clnt_reconnect_close(CLIENT *);
56 static void clnt_reconnect_destroy(CLIENT *);
57
58 static struct clnt_ops clnt_reconnect_ops = {
59 .cl_call = clnt_reconnect_call,
60 .cl_abort = clnt_reconnect_abort,
61 .cl_geterr = clnt_reconnect_geterr,
62 .cl_freeres = clnt_reconnect_freeres,
63 .cl_close = clnt_reconnect_close,
64 .cl_destroy = clnt_reconnect_destroy,
65 .cl_control = clnt_reconnect_control
66 };
67
68 static int fake_wchan;
69
70 struct rc_data {
71 struct mtx rc_lock;
72 struct sockaddr_storage rc_addr; /* server address */
73 struct netconfig* rc_nconf; /* network type */
74 rpcprog_t rc_prog; /* program number */
75 rpcvers_t rc_vers; /* version number */
76 size_t rc_sendsz;
77 size_t rc_recvsz;
78 struct timeval rc_timeout;
79 struct timeval rc_retry;
80 int rc_retries;
81 int rc_privport;
82 char *rc_waitchan;
83 int rc_intr;
84 int rc_connecting;
85 int rc_closed;
86 struct ucred *rc_ucred;
87 CLIENT* rc_client; /* underlying RPC client */
88 struct rpc_err rc_err;
89 };
90
91 CLIENT *
92 clnt_reconnect_create(
93 struct netconfig *nconf, /* network type */
94 struct sockaddr *svcaddr, /* servers address */
95 rpcprog_t program, /* program number */
96 rpcvers_t version, /* version number */
97 size_t sendsz, /* buffer recv size */
98 size_t recvsz) /* buffer send size */
99 {
100 CLIENT *cl = NULL; /* client handle */
101 struct rc_data *rc = NULL; /* private data */
102
103 if (svcaddr == NULL) {
104 rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
105 return (NULL);
106 }
107
108 cl = mem_alloc(sizeof (CLIENT));
109 rc = mem_alloc(sizeof (*rc));
110 mtx_init(&rc->rc_lock, "rc->rc_lock", NULL, MTX_DEF);
111 (void) memcpy(&rc->rc_addr, svcaddr, (size_t)svcaddr->sa_len);
112 rc->rc_nconf = nconf;
113 rc->rc_prog = program;
114 rc->rc_vers = version;
115 rc->rc_sendsz = sendsz;
116 rc->rc_recvsz = recvsz;
117 rc->rc_timeout.tv_sec = -1;
118 rc->rc_timeout.tv_usec = -1;
119 rc->rc_retry.tv_sec = 3;
120 rc->rc_retry.tv_usec = 0;
121 rc->rc_retries = INT_MAX;
122 rc->rc_privport = FALSE;
123 rc->rc_waitchan = "rpcrecv";
124 rc->rc_intr = 0;
125 rc->rc_connecting = FALSE;
126 rc->rc_closed = FALSE;
127 rc->rc_ucred = crdup(curthread->td_ucred);
128 rc->rc_client = NULL;
129
130 cl->cl_refs = 1;
131 cl->cl_ops = &clnt_reconnect_ops;
132 cl->cl_private = (caddr_t)(void *)rc;
133 cl->cl_auth = authnone_create();
134 cl->cl_tp = NULL;
135 cl->cl_netid = NULL;
136 return (cl);
137 }
138
139 static enum clnt_stat
140 clnt_reconnect_connect(CLIENT *cl)
141 {
142 struct thread *td = curthread;
143 struct rc_data *rc = (struct rc_data *)cl->cl_private;
144 struct socket *so;
145 enum clnt_stat stat;
146 int error;
147 int one = 1;
148 struct ucred *oldcred;
149
150 mtx_lock(&rc->rc_lock);
151 again:
152 if (rc->rc_closed) {
153 mtx_unlock(&rc->rc_lock);
154 return (RPC_CANTSEND);
155 }
156 if (rc->rc_connecting) {
157 while (!rc->rc_closed && !rc->rc_client) {
158 error = msleep(rc, &rc->rc_lock,
159 rc->rc_intr ? PCATCH : 0, "rpcrecon", 0);
160 if (error) {
161 mtx_unlock(&rc->rc_lock);
162 return (RPC_INTR);
163 }
164 }
165 /*
166 * If the other guy failed to connect, we might as
167 * well have another go.
168 */
169 if (!rc->rc_client && !rc->rc_connecting)
170 goto again;
171 mtx_unlock(&rc->rc_lock);
172 return (RPC_SUCCESS);
173 } else {
174 rc->rc_connecting = TRUE;
175 }
176 mtx_unlock(&rc->rc_lock);
177
178 so = __rpc_nconf2socket(rc->rc_nconf);
179 if (!so) {
180 stat = rpc_createerr.cf_stat = RPC_TLIERROR;
181 rpc_createerr.cf_error.re_errno = 0;
182 goto out;
183 }
184 if (rc->rc_privport)
185 bindresvport(so, NULL);
186
187 oldcred = td->td_ucred;
188 td->td_ucred = rc->rc_ucred;
189 if (rc->rc_nconf->nc_semantics == NC_TPI_CLTS)
190 rc->rc_client = clnt_dg_create(so,
191 (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers,
192 rc->rc_sendsz, rc->rc_recvsz);
193 else
194 rc->rc_client = clnt_vc_create(so,
195 (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers,
196 rc->rc_sendsz, rc->rc_recvsz);
197 td->td_ucred = oldcred;
198
199 if (!rc->rc_client) {
200 soclose(so);
201 rc->rc_err = rpc_createerr.cf_error;
202 stat = rpc_createerr.cf_stat;
203 goto out;
204 }
205
206 CLNT_CONTROL(rc->rc_client, CLSET_FD_CLOSE, 0);
207 CLNT_CONTROL(rc->rc_client, CLSET_CONNECT, &one);
208 CLNT_CONTROL(rc->rc_client, CLSET_TIMEOUT, &rc->rc_timeout);
209 CLNT_CONTROL(rc->rc_client, CLSET_RETRY_TIMEOUT, &rc->rc_retry);
210 CLNT_CONTROL(rc->rc_client, CLSET_WAITCHAN, rc->rc_waitchan);
211 CLNT_CONTROL(rc->rc_client, CLSET_INTERRUPTIBLE, &rc->rc_intr);
212 stat = RPC_SUCCESS;
213
214 out:
215 mtx_lock(&rc->rc_lock);
216 if (rc->rc_closed) {
217 if (rc->rc_client) {
218 CLNT_CLOSE(rc->rc_client);
219 CLNT_RELEASE(rc->rc_client);
220 rc->rc_client = NULL;
221 }
222 }
223 rc->rc_connecting = FALSE;
224 wakeup(rc);
225 mtx_unlock(&rc->rc_lock);
226
227 return (stat);
228 }
229
230 static enum clnt_stat
231 clnt_reconnect_call(
232 CLIENT *cl, /* client handle */
233 struct rpc_callextra *ext, /* call metadata */
234 rpcproc_t proc, /* procedure number */
235 struct mbuf *args, /* pointer to args */
236 struct mbuf **resultsp, /* pointer to results */
237 struct timeval utimeout)
238 {
239 struct rc_data *rc = (struct rc_data *)cl->cl_private;
240 CLIENT *client;
241 enum clnt_stat stat;
242 int tries;
243
244 tries = 0;
245 do {
246 if (rc->rc_closed) {
247 return (RPC_CANTSEND);
248 }
249
250 if (!rc->rc_client) {
251 stat = clnt_reconnect_connect(cl);
252 if (stat == RPC_SYSTEMERROR) {
253 (void) tsleep(&fake_wchan, 0,
254 "rpccon", hz);
255 tries++;
256 if (tries >= rc->rc_retries)
257 return (stat);
258 continue;
259 }
260 if (stat != RPC_SUCCESS)
261 return (stat);
262 }
263
264 mtx_lock(&rc->rc_lock);
265 if (!rc->rc_client) {
266 mtx_unlock(&rc->rc_lock);
267 stat = RPC_FAILED;
268 continue;
269 }
270 CLNT_ACQUIRE(rc->rc_client);
271 client = rc->rc_client;
272 mtx_unlock(&rc->rc_lock);
273 stat = CLNT_CALL_MBUF(client, ext, proc, args,
274 resultsp, utimeout);
275
276 if (stat != RPC_SUCCESS) {
277 if (!ext)
278 CLNT_GETERR(client, &rc->rc_err);
279 }
280
281 CLNT_RELEASE(client);
282 if (stat == RPC_TIMEDOUT) {
283 /*
284 * Check for async send misfeature for NLM
285 * protocol.
286 */
287 if ((rc->rc_timeout.tv_sec == 0
288 && rc->rc_timeout.tv_usec == 0)
289 || (rc->rc_timeout.tv_sec == -1
290 && utimeout.tv_sec == 0
291 && utimeout.tv_usec == 0)) {
292 break;
293 }
294 }
295
296 if (stat == RPC_TIMEDOUT || stat == RPC_CANTSEND
297 || stat == RPC_CANTRECV) {
298 tries++;
299 if (tries >= rc->rc_retries)
300 break;
301
302 if (ext && ext->rc_feedback)
303 ext->rc_feedback(FEEDBACK_RECONNECT, proc,
304 ext->rc_feedback_arg);
305
306 mtx_lock(&rc->rc_lock);
307 /*
308 * Make sure that someone else hasn't already
309 * reconnected.
310 */
311 if (rc->rc_client == client) {
312 CLNT_RELEASE(rc->rc_client);
313 rc->rc_client = NULL;
314 }
315 mtx_unlock(&rc->rc_lock);
316 } else {
317 break;
318 }
319 } while (stat != RPC_SUCCESS);
320
321 KASSERT(stat != RPC_SUCCESS || *resultsp,
322 ("RPC_SUCCESS without reply"));
323
324 return (stat);
325 }
326
327 static void
328 clnt_reconnect_geterr(CLIENT *cl, struct rpc_err *errp)
329 {
330 struct rc_data *rc = (struct rc_data *)cl->cl_private;
331
332 *errp = rc->rc_err;
333 }
334
335 static bool_t
336 clnt_reconnect_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
337 {
338 struct rc_data *rc = (struct rc_data *)cl->cl_private;
339
340 return (CLNT_FREERES(rc->rc_client, xdr_res, res_ptr));
341 }
342
343 /*ARGSUSED*/
344 static void
345 clnt_reconnect_abort(CLIENT *h)
346 {
347 }
348
349 static bool_t
350 clnt_reconnect_control(CLIENT *cl, u_int request, void *info)
351 {
352 struct rc_data *rc = (struct rc_data *)cl->cl_private;
353
354 if (info == NULL) {
355 return (FALSE);
356 }
357 switch (request) {
358 case CLSET_TIMEOUT:
359 rc->rc_timeout = *(struct timeval *)info;
360 if (rc->rc_client)
361 CLNT_CONTROL(rc->rc_client, request, info);
362 break;
363
364 case CLGET_TIMEOUT:
365 *(struct timeval *)info = rc->rc_timeout;
366 break;
367
368 case CLSET_RETRY_TIMEOUT:
369 rc->rc_retry = *(struct timeval *)info;
370 if (rc->rc_client)
371 CLNT_CONTROL(rc->rc_client, request, info);
372 break;
373
374 case CLGET_RETRY_TIMEOUT:
375 *(struct timeval *)info = rc->rc_retry;
376 break;
377
378 case CLGET_VERS:
379 *(uint32_t *)info = rc->rc_vers;
380 break;
381
382 case CLSET_VERS:
383 rc->rc_vers = *(uint32_t *) info;
384 if (rc->rc_client)
385 CLNT_CONTROL(rc->rc_client, CLSET_VERS, info);
386 break;
387
388 case CLGET_PROG:
389 *(uint32_t *)info = rc->rc_prog;
390 break;
391
392 case CLSET_PROG:
393 rc->rc_prog = *(uint32_t *) info;
394 if (rc->rc_client)
395 CLNT_CONTROL(rc->rc_client, request, info);
396 break;
397
398 case CLSET_WAITCHAN:
399 rc->rc_waitchan = (char *)info;
400 if (rc->rc_client)
401 CLNT_CONTROL(rc->rc_client, request, info);
402 break;
403
404 case CLGET_WAITCHAN:
405 *(const char **) info = rc->rc_waitchan;
406 break;
407
408 case CLSET_INTERRUPTIBLE:
409 rc->rc_intr = *(int *) info;
410 if (rc->rc_client)
411 CLNT_CONTROL(rc->rc_client, request, info);
412 break;
413
414 case CLGET_INTERRUPTIBLE:
415 *(int *) info = rc->rc_intr;
416 break;
417
418 case CLSET_RETRIES:
419 rc->rc_retries = *(int *) info;
420 break;
421
422 case CLGET_RETRIES:
423 *(int *) info = rc->rc_retries;
424 break;
425
426 case CLSET_PRIVPORT:
427 rc->rc_privport = *(int *) info;
428 break;
429
430 case CLGET_PRIVPORT:
431 *(int *) info = rc->rc_privport;
432 break;
433
434 default:
435 return (FALSE);
436 }
437
438 return (TRUE);
439 }
440
441 static void
442 clnt_reconnect_close(CLIENT *cl)
443 {
444 struct rc_data *rc = (struct rc_data *)cl->cl_private;
445 CLIENT *client;
446
447 mtx_lock(&rc->rc_lock);
448
449 if (rc->rc_closed) {
450 mtx_unlock(&rc->rc_lock);
451 return;
452 }
453
454 rc->rc_closed = TRUE;
455 client = rc->rc_client;
456 rc->rc_client = NULL;
457
458 mtx_unlock(&rc->rc_lock);
459
460 if (client) {
461 CLNT_CLOSE(client);
462 CLNT_RELEASE(client);
463 }
464 }
465
466 static void
467 clnt_reconnect_destroy(CLIENT *cl)
468 {
469 struct rc_data *rc = (struct rc_data *)cl->cl_private;
470
471 if (rc->rc_client)
472 CLNT_DESTROY(rc->rc_client);
473 crfree(rc->rc_ucred);
474 mtx_destroy(&rc->rc_lock);
475 mem_free(rc, sizeof(*rc));
476 mem_free(cl, sizeof (CLIENT));
477 }
478
|