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>
| 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>
|
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
49static enum clnt_stat clnt_reconnect_call(CLIENT *, struct rpc_callextra *,
50 rpcproc_t, struct mbuf *, struct mbuf **, struct timeval);
51static void clnt_reconnect_geterr(CLIENT *, struct rpc_err *);
52static bool_t clnt_reconnect_freeres(CLIENT *, xdrproc_t, void *);
53static void clnt_reconnect_abort(CLIENT *);
54static bool_t clnt_reconnect_control(CLIENT *, u_int, void *);
55static void clnt_reconnect_close(CLIENT *);
56static void clnt_reconnect_destroy(CLIENT *);
57
58static 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
68static int fake_wchan;
69
70struct 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
91CLIENT *
92clnt_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
139static enum clnt_stat
140clnt_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 CLIENT *newclient = NULL;
150
151 mtx_lock(&rc->rc_lock);
152 while (rc->rc_connecting) {
153 error = msleep(rc, &rc->rc_lock,
154 rc->rc_intr ? PCATCH : 0, "rpcrecon", 0);
155 if (error) {
156 mtx_unlock(&rc->rc_lock);
157 return (RPC_INTR);
158 }
159 }
160 if (rc->rc_closed) {
161 mtx_unlock(&rc->rc_lock);
162 return (RPC_CANTSEND);
163 }
164 if (rc->rc_client) {
165 mtx_unlock(&rc->rc_lock);
166 return (RPC_SUCCESS);
167 }
168
169 /*
170 * My turn to attempt a connect. The rc_connecting variable
171 * serializes the following code sequence, so it is guaranteed
172 * that rc_client will still be NULL after it is re-locked below,
173 * since that is the only place it is set non-NULL.
174 */
175 rc->rc_connecting = TRUE;
176 mtx_unlock(&rc->rc_lock);
177
| 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
49static enum clnt_stat clnt_reconnect_call(CLIENT *, struct rpc_callextra *,
50 rpcproc_t, struct mbuf *, struct mbuf **, struct timeval);
51static void clnt_reconnect_geterr(CLIENT *, struct rpc_err *);
52static bool_t clnt_reconnect_freeres(CLIENT *, xdrproc_t, void *);
53static void clnt_reconnect_abort(CLIENT *);
54static bool_t clnt_reconnect_control(CLIENT *, u_int, void *);
55static void clnt_reconnect_close(CLIENT *);
56static void clnt_reconnect_destroy(CLIENT *);
57
58static 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
68static int fake_wchan;
69
70struct 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
91CLIENT *
92clnt_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
139static enum clnt_stat
140clnt_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 CLIENT *newclient = NULL;
150
151 mtx_lock(&rc->rc_lock);
152 while (rc->rc_connecting) {
153 error = msleep(rc, &rc->rc_lock,
154 rc->rc_intr ? PCATCH : 0, "rpcrecon", 0);
155 if (error) {
156 mtx_unlock(&rc->rc_lock);
157 return (RPC_INTR);
158 }
159 }
160 if (rc->rc_closed) {
161 mtx_unlock(&rc->rc_lock);
162 return (RPC_CANTSEND);
163 }
164 if (rc->rc_client) {
165 mtx_unlock(&rc->rc_lock);
166 return (RPC_SUCCESS);
167 }
168
169 /*
170 * My turn to attempt a connect. The rc_connecting variable
171 * serializes the following code sequence, so it is guaranteed
172 * that rc_client will still be NULL after it is re-locked below,
173 * since that is the only place it is set non-NULL.
174 */
175 rc->rc_connecting = TRUE;
176 mtx_unlock(&rc->rc_lock);
177
|
187 if (rc->rc_privport)
188 bindresvport(so, NULL);
189
190 if (rc->rc_nconf->nc_semantics == NC_TPI_CLTS)
191 newclient = clnt_dg_create(so,
192 (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers,
193 rc->rc_sendsz, rc->rc_recvsz);
194 else
195 newclient = clnt_vc_create(so,
196 (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers,
197 rc->rc_sendsz, rc->rc_recvsz);
198 td->td_ucred = oldcred;
199
200 if (!newclient) {
201 soclose(so);
202 rc->rc_err = rpc_createerr.cf_error;
203 stat = rpc_createerr.cf_stat;
204 goto out;
205 }
206
207 CLNT_CONTROL(newclient, CLSET_FD_CLOSE, 0);
208 CLNT_CONTROL(newclient, CLSET_CONNECT, &one);
209 CLNT_CONTROL(newclient, CLSET_TIMEOUT, &rc->rc_timeout);
210 CLNT_CONTROL(newclient, CLSET_RETRY_TIMEOUT, &rc->rc_retry);
211 CLNT_CONTROL(newclient, CLSET_WAITCHAN, rc->rc_waitchan);
212 CLNT_CONTROL(newclient, CLSET_INTERRUPTIBLE, &rc->rc_intr);
213 stat = RPC_SUCCESS;
214
215out:
216 mtx_lock(&rc->rc_lock);
217 KASSERT(rc->rc_client == NULL, ("rc_client not null"));
218 if (!rc->rc_closed) {
219 rc->rc_client = newclient;
220 newclient = NULL;
221 }
222 rc->rc_connecting = FALSE;
223 wakeup(rc);
224 mtx_unlock(&rc->rc_lock);
225
226 if (newclient) {
227 /*
228 * It has been closed, so discard the new client.
229 * nb: clnt_[dg|vc]_close()/clnt_[dg|vc]_destroy() cannot
230 * be called with the rc_lock mutex held, since they may
231 * msleep() while holding a different mutex.
232 */
233 CLNT_CLOSE(newclient);
234 CLNT_RELEASE(newclient);
235 }
236
237 return (stat);
238}
239
240static enum clnt_stat
241clnt_reconnect_call(
242 CLIENT *cl, /* client handle */
243 struct rpc_callextra *ext, /* call metadata */
244 rpcproc_t proc, /* procedure number */
245 struct mbuf *args, /* pointer to args */
246 struct mbuf **resultsp, /* pointer to results */
247 struct timeval utimeout)
248{
249 struct rc_data *rc = (struct rc_data *)cl->cl_private;
250 CLIENT *client;
251 enum clnt_stat stat;
252 int tries, error;
253
254 tries = 0;
255 do {
256 mtx_lock(&rc->rc_lock);
257 if (rc->rc_closed) {
258 mtx_unlock(&rc->rc_lock);
259 return (RPC_CANTSEND);
260 }
261
262 if (!rc->rc_client) {
263 mtx_unlock(&rc->rc_lock);
264 stat = clnt_reconnect_connect(cl);
265 if (stat == RPC_SYSTEMERROR) {
266 error = tsleep(&fake_wchan,
267 rc->rc_intr ? PCATCH | PBDRY : 0, "rpccon",
268 hz);
269 if (error == EINTR || error == ERESTART)
270 return (RPC_INTR);
271 tries++;
272 if (tries >= rc->rc_retries)
273 return (stat);
274 continue;
275 }
276 if (stat != RPC_SUCCESS)
277 return (stat);
278 mtx_lock(&rc->rc_lock);
279 }
280
281 if (!rc->rc_client) {
282 mtx_unlock(&rc->rc_lock);
283 stat = RPC_FAILED;
284 continue;
285 }
286 CLNT_ACQUIRE(rc->rc_client);
287 client = rc->rc_client;
288 mtx_unlock(&rc->rc_lock);
289 stat = CLNT_CALL_MBUF(client, ext, proc, args,
290 resultsp, utimeout);
291
292 if (stat != RPC_SUCCESS) {
293 if (!ext)
294 CLNT_GETERR(client, &rc->rc_err);
295 }
296
297 if (stat == RPC_TIMEDOUT) {
298 /*
299 * Check for async send misfeature for NLM
300 * protocol.
301 */
302 if ((rc->rc_timeout.tv_sec == 0
303 && rc->rc_timeout.tv_usec == 0)
304 || (rc->rc_timeout.tv_sec == -1
305 && utimeout.tv_sec == 0
306 && utimeout.tv_usec == 0)) {
307 CLNT_RELEASE(client);
308 break;
309 }
310 }
311
312 if (stat == RPC_TIMEDOUT || stat == RPC_CANTSEND
313 || stat == RPC_CANTRECV) {
314 tries++;
315 if (tries >= rc->rc_retries) {
316 CLNT_RELEASE(client);
317 break;
318 }
319
320 if (ext && ext->rc_feedback)
321 ext->rc_feedback(FEEDBACK_RECONNECT, proc,
322 ext->rc_feedback_arg);
323
324 mtx_lock(&rc->rc_lock);
325 /*
326 * Make sure that someone else hasn't already
327 * reconnected by checking if rc_client has changed.
328 * If not, we are done with the client and must
329 * do CLNT_RELEASE(client) twice to dispose of it,
330 * because there is both an initial refcnt and one
331 * acquired by CLNT_ACQUIRE() above.
332 */
333 if (rc->rc_client == client) {
334 rc->rc_client = NULL;
335 mtx_unlock(&rc->rc_lock);
336 CLNT_RELEASE(client);
337 } else {
338 mtx_unlock(&rc->rc_lock);
339 }
340 CLNT_RELEASE(client);
341 } else {
342 CLNT_RELEASE(client);
343 break;
344 }
345 } while (stat != RPC_SUCCESS);
346
347 KASSERT(stat != RPC_SUCCESS || *resultsp,
348 ("RPC_SUCCESS without reply"));
349
350 return (stat);
351}
352
353static void
354clnt_reconnect_geterr(CLIENT *cl, struct rpc_err *errp)
355{
356 struct rc_data *rc = (struct rc_data *)cl->cl_private;
357
358 *errp = rc->rc_err;
359}
360
361/*
362 * Since this function requires that rc_client be valid, it can
363 * only be called when that is guaranteed to be the case.
364 */
365static bool_t
366clnt_reconnect_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
367{
368 struct rc_data *rc = (struct rc_data *)cl->cl_private;
369
370 return (CLNT_FREERES(rc->rc_client, xdr_res, res_ptr));
371}
372
373/*ARGSUSED*/
374static void
375clnt_reconnect_abort(CLIENT *h)
376{
377}
378
379/*
380 * CLNT_CONTROL() on the client returned by clnt_reconnect_create() must
381 * always be called before CLNT_CALL_MBUF() by a single thread only.
382 */
383static bool_t
384clnt_reconnect_control(CLIENT *cl, u_int request, void *info)
385{
386 struct rc_data *rc = (struct rc_data *)cl->cl_private;
387
388 if (info == NULL) {
389 return (FALSE);
390 }
391 switch (request) {
392 case CLSET_TIMEOUT:
393 rc->rc_timeout = *(struct timeval *)info;
394 if (rc->rc_client)
395 CLNT_CONTROL(rc->rc_client, request, info);
396 break;
397
398 case CLGET_TIMEOUT:
399 *(struct timeval *)info = rc->rc_timeout;
400 break;
401
402 case CLSET_RETRY_TIMEOUT:
403 rc->rc_retry = *(struct timeval *)info;
404 if (rc->rc_client)
405 CLNT_CONTROL(rc->rc_client, request, info);
406 break;
407
408 case CLGET_RETRY_TIMEOUT:
409 *(struct timeval *)info = rc->rc_retry;
410 break;
411
412 case CLGET_VERS:
413 *(uint32_t *)info = rc->rc_vers;
414 break;
415
416 case CLSET_VERS:
417 rc->rc_vers = *(uint32_t *) info;
418 if (rc->rc_client)
419 CLNT_CONTROL(rc->rc_client, CLSET_VERS, info);
420 break;
421
422 case CLGET_PROG:
423 *(uint32_t *)info = rc->rc_prog;
424 break;
425
426 case CLSET_PROG:
427 rc->rc_prog = *(uint32_t *) info;
428 if (rc->rc_client)
429 CLNT_CONTROL(rc->rc_client, request, info);
430 break;
431
432 case CLSET_WAITCHAN:
433 rc->rc_waitchan = (char *)info;
434 if (rc->rc_client)
435 CLNT_CONTROL(rc->rc_client, request, info);
436 break;
437
438 case CLGET_WAITCHAN:
439 *(const char **) info = rc->rc_waitchan;
440 break;
441
442 case CLSET_INTERRUPTIBLE:
443 rc->rc_intr = *(int *) info;
444 if (rc->rc_client)
445 CLNT_CONTROL(rc->rc_client, request, info);
446 break;
447
448 case CLGET_INTERRUPTIBLE:
449 *(int *) info = rc->rc_intr;
450 break;
451
452 case CLSET_RETRIES:
453 rc->rc_retries = *(int *) info;
454 break;
455
456 case CLGET_RETRIES:
457 *(int *) info = rc->rc_retries;
458 break;
459
460 case CLSET_PRIVPORT:
461 rc->rc_privport = *(int *) info;
462 break;
463
464 case CLGET_PRIVPORT:
465 *(int *) info = rc->rc_privport;
466 break;
467
468 default:
469 return (FALSE);
470 }
471
472 return (TRUE);
473}
474
475static void
476clnt_reconnect_close(CLIENT *cl)
477{
478 struct rc_data *rc = (struct rc_data *)cl->cl_private;
479 CLIENT *client;
480
481 mtx_lock(&rc->rc_lock);
482
483 if (rc->rc_closed) {
484 mtx_unlock(&rc->rc_lock);
485 return;
486 }
487
488 rc->rc_closed = TRUE;
489 client = rc->rc_client;
490 rc->rc_client = NULL;
491
492 mtx_unlock(&rc->rc_lock);
493
494 if (client) {
495 CLNT_CLOSE(client);
496 CLNT_RELEASE(client);
497 }
498}
499
500static void
501clnt_reconnect_destroy(CLIENT *cl)
502{
503 struct rc_data *rc = (struct rc_data *)cl->cl_private;
504
505 if (rc->rc_client)
506 CLNT_DESTROY(rc->rc_client);
507 crfree(rc->rc_ucred);
508 mtx_destroy(&rc->rc_lock);
509 mem_free(rc, sizeof(*rc));
510 mem_free(cl, sizeof (CLIENT));
511}
| 188 if (rc->rc_privport)
189 bindresvport(so, NULL);
190
191 if (rc->rc_nconf->nc_semantics == NC_TPI_CLTS)
192 newclient = clnt_dg_create(so,
193 (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers,
194 rc->rc_sendsz, rc->rc_recvsz);
195 else
196 newclient = clnt_vc_create(so,
197 (struct sockaddr *) &rc->rc_addr, rc->rc_prog, rc->rc_vers,
198 rc->rc_sendsz, rc->rc_recvsz);
199 td->td_ucred = oldcred;
200
201 if (!newclient) {
202 soclose(so);
203 rc->rc_err = rpc_createerr.cf_error;
204 stat = rpc_createerr.cf_stat;
205 goto out;
206 }
207
208 CLNT_CONTROL(newclient, CLSET_FD_CLOSE, 0);
209 CLNT_CONTROL(newclient, CLSET_CONNECT, &one);
210 CLNT_CONTROL(newclient, CLSET_TIMEOUT, &rc->rc_timeout);
211 CLNT_CONTROL(newclient, CLSET_RETRY_TIMEOUT, &rc->rc_retry);
212 CLNT_CONTROL(newclient, CLSET_WAITCHAN, rc->rc_waitchan);
213 CLNT_CONTROL(newclient, CLSET_INTERRUPTIBLE, &rc->rc_intr);
214 stat = RPC_SUCCESS;
215
216out:
217 mtx_lock(&rc->rc_lock);
218 KASSERT(rc->rc_client == NULL, ("rc_client not null"));
219 if (!rc->rc_closed) {
220 rc->rc_client = newclient;
221 newclient = NULL;
222 }
223 rc->rc_connecting = FALSE;
224 wakeup(rc);
225 mtx_unlock(&rc->rc_lock);
226
227 if (newclient) {
228 /*
229 * It has been closed, so discard the new client.
230 * nb: clnt_[dg|vc]_close()/clnt_[dg|vc]_destroy() cannot
231 * be called with the rc_lock mutex held, since they may
232 * msleep() while holding a different mutex.
233 */
234 CLNT_CLOSE(newclient);
235 CLNT_RELEASE(newclient);
236 }
237
238 return (stat);
239}
240
241static enum clnt_stat
242clnt_reconnect_call(
243 CLIENT *cl, /* client handle */
244 struct rpc_callextra *ext, /* call metadata */
245 rpcproc_t proc, /* procedure number */
246 struct mbuf *args, /* pointer to args */
247 struct mbuf **resultsp, /* pointer to results */
248 struct timeval utimeout)
249{
250 struct rc_data *rc = (struct rc_data *)cl->cl_private;
251 CLIENT *client;
252 enum clnt_stat stat;
253 int tries, error;
254
255 tries = 0;
256 do {
257 mtx_lock(&rc->rc_lock);
258 if (rc->rc_closed) {
259 mtx_unlock(&rc->rc_lock);
260 return (RPC_CANTSEND);
261 }
262
263 if (!rc->rc_client) {
264 mtx_unlock(&rc->rc_lock);
265 stat = clnt_reconnect_connect(cl);
266 if (stat == RPC_SYSTEMERROR) {
267 error = tsleep(&fake_wchan,
268 rc->rc_intr ? PCATCH | PBDRY : 0, "rpccon",
269 hz);
270 if (error == EINTR || error == ERESTART)
271 return (RPC_INTR);
272 tries++;
273 if (tries >= rc->rc_retries)
274 return (stat);
275 continue;
276 }
277 if (stat != RPC_SUCCESS)
278 return (stat);
279 mtx_lock(&rc->rc_lock);
280 }
281
282 if (!rc->rc_client) {
283 mtx_unlock(&rc->rc_lock);
284 stat = RPC_FAILED;
285 continue;
286 }
287 CLNT_ACQUIRE(rc->rc_client);
288 client = rc->rc_client;
289 mtx_unlock(&rc->rc_lock);
290 stat = CLNT_CALL_MBUF(client, ext, proc, args,
291 resultsp, utimeout);
292
293 if (stat != RPC_SUCCESS) {
294 if (!ext)
295 CLNT_GETERR(client, &rc->rc_err);
296 }
297
298 if (stat == RPC_TIMEDOUT) {
299 /*
300 * Check for async send misfeature for NLM
301 * protocol.
302 */
303 if ((rc->rc_timeout.tv_sec == 0
304 && rc->rc_timeout.tv_usec == 0)
305 || (rc->rc_timeout.tv_sec == -1
306 && utimeout.tv_sec == 0
307 && utimeout.tv_usec == 0)) {
308 CLNT_RELEASE(client);
309 break;
310 }
311 }
312
313 if (stat == RPC_TIMEDOUT || stat == RPC_CANTSEND
314 || stat == RPC_CANTRECV) {
315 tries++;
316 if (tries >= rc->rc_retries) {
317 CLNT_RELEASE(client);
318 break;
319 }
320
321 if (ext && ext->rc_feedback)
322 ext->rc_feedback(FEEDBACK_RECONNECT, proc,
323 ext->rc_feedback_arg);
324
325 mtx_lock(&rc->rc_lock);
326 /*
327 * Make sure that someone else hasn't already
328 * reconnected by checking if rc_client has changed.
329 * If not, we are done with the client and must
330 * do CLNT_RELEASE(client) twice to dispose of it,
331 * because there is both an initial refcnt and one
332 * acquired by CLNT_ACQUIRE() above.
333 */
334 if (rc->rc_client == client) {
335 rc->rc_client = NULL;
336 mtx_unlock(&rc->rc_lock);
337 CLNT_RELEASE(client);
338 } else {
339 mtx_unlock(&rc->rc_lock);
340 }
341 CLNT_RELEASE(client);
342 } else {
343 CLNT_RELEASE(client);
344 break;
345 }
346 } while (stat != RPC_SUCCESS);
347
348 KASSERT(stat != RPC_SUCCESS || *resultsp,
349 ("RPC_SUCCESS without reply"));
350
351 return (stat);
352}
353
354static void
355clnt_reconnect_geterr(CLIENT *cl, struct rpc_err *errp)
356{
357 struct rc_data *rc = (struct rc_data *)cl->cl_private;
358
359 *errp = rc->rc_err;
360}
361
362/*
363 * Since this function requires that rc_client be valid, it can
364 * only be called when that is guaranteed to be the case.
365 */
366static bool_t
367clnt_reconnect_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
368{
369 struct rc_data *rc = (struct rc_data *)cl->cl_private;
370
371 return (CLNT_FREERES(rc->rc_client, xdr_res, res_ptr));
372}
373
374/*ARGSUSED*/
375static void
376clnt_reconnect_abort(CLIENT *h)
377{
378}
379
380/*
381 * CLNT_CONTROL() on the client returned by clnt_reconnect_create() must
382 * always be called before CLNT_CALL_MBUF() by a single thread only.
383 */
384static bool_t
385clnt_reconnect_control(CLIENT *cl, u_int request, void *info)
386{
387 struct rc_data *rc = (struct rc_data *)cl->cl_private;
388
389 if (info == NULL) {
390 return (FALSE);
391 }
392 switch (request) {
393 case CLSET_TIMEOUT:
394 rc->rc_timeout = *(struct timeval *)info;
395 if (rc->rc_client)
396 CLNT_CONTROL(rc->rc_client, request, info);
397 break;
398
399 case CLGET_TIMEOUT:
400 *(struct timeval *)info = rc->rc_timeout;
401 break;
402
403 case CLSET_RETRY_TIMEOUT:
404 rc->rc_retry = *(struct timeval *)info;
405 if (rc->rc_client)
406 CLNT_CONTROL(rc->rc_client, request, info);
407 break;
408
409 case CLGET_RETRY_TIMEOUT:
410 *(struct timeval *)info = rc->rc_retry;
411 break;
412
413 case CLGET_VERS:
414 *(uint32_t *)info = rc->rc_vers;
415 break;
416
417 case CLSET_VERS:
418 rc->rc_vers = *(uint32_t *) info;
419 if (rc->rc_client)
420 CLNT_CONTROL(rc->rc_client, CLSET_VERS, info);
421 break;
422
423 case CLGET_PROG:
424 *(uint32_t *)info = rc->rc_prog;
425 break;
426
427 case CLSET_PROG:
428 rc->rc_prog = *(uint32_t *) info;
429 if (rc->rc_client)
430 CLNT_CONTROL(rc->rc_client, request, info);
431 break;
432
433 case CLSET_WAITCHAN:
434 rc->rc_waitchan = (char *)info;
435 if (rc->rc_client)
436 CLNT_CONTROL(rc->rc_client, request, info);
437 break;
438
439 case CLGET_WAITCHAN:
440 *(const char **) info = rc->rc_waitchan;
441 break;
442
443 case CLSET_INTERRUPTIBLE:
444 rc->rc_intr = *(int *) info;
445 if (rc->rc_client)
446 CLNT_CONTROL(rc->rc_client, request, info);
447 break;
448
449 case CLGET_INTERRUPTIBLE:
450 *(int *) info = rc->rc_intr;
451 break;
452
453 case CLSET_RETRIES:
454 rc->rc_retries = *(int *) info;
455 break;
456
457 case CLGET_RETRIES:
458 *(int *) info = rc->rc_retries;
459 break;
460
461 case CLSET_PRIVPORT:
462 rc->rc_privport = *(int *) info;
463 break;
464
465 case CLGET_PRIVPORT:
466 *(int *) info = rc->rc_privport;
467 break;
468
469 default:
470 return (FALSE);
471 }
472
473 return (TRUE);
474}
475
476static void
477clnt_reconnect_close(CLIENT *cl)
478{
479 struct rc_data *rc = (struct rc_data *)cl->cl_private;
480 CLIENT *client;
481
482 mtx_lock(&rc->rc_lock);
483
484 if (rc->rc_closed) {
485 mtx_unlock(&rc->rc_lock);
486 return;
487 }
488
489 rc->rc_closed = TRUE;
490 client = rc->rc_client;
491 rc->rc_client = NULL;
492
493 mtx_unlock(&rc->rc_lock);
494
495 if (client) {
496 CLNT_CLOSE(client);
497 CLNT_RELEASE(client);
498 }
499}
500
501static void
502clnt_reconnect_destroy(CLIENT *cl)
503{
504 struct rc_data *rc = (struct rc_data *)cl->cl_private;
505
506 if (rc->rc_client)
507 CLNT_DESTROY(rc->rc_client);
508 crfree(rc->rc_ucred);
509 mtx_destroy(&rc->rc_lock);
510 mem_free(rc, sizeof(*rc));
511 mem_free(cl, sizeof (CLIENT));
512}
|