1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T 28 * All Rights Reserved 29 */ 30 31 /* 32 * Portions of this source code were derived from Berkeley 4.3 BSD 33 * under license from the Regents of the University of California. 34 */ 35 36 #pragma ident "%Z%%M% %I% %E% SMI" 37 38 /* 39 * Implements a kernel based, client side RPC over Connection Oriented 40 * Transports (COTS). 41 */ 42 43 /* 44 * Much of this file has been re-written to let NFS work better over slow 45 * transports. A description follows. 46 * 47 * One of the annoying things about kRPC/COTS is that it will temporarily 48 * create more than one connection between a client and server. This 49 * happens because when a connection is made, the end-points entry in the 50 * linked list of connections (headed by cm_hd), is removed so that other 51 * threads don't mess with it. Went ahead and bit the bullet by keeping 52 * the endpoint on the connection list and introducing state bits, 53 * condition variables etc. to the connection entry data structure (struct 54 * cm_xprt). 55 * 56 * Here is a summary of the changes to cm-xprt: 57 * 58 * x_ctime is the timestamp of when the endpoint was last 59 * connected or disconnected. If an end-point is ever disconnected 60 * or re-connected, then any outstanding RPC request is presumed 61 * lost, telling clnt_cots_kcallit that it needs to re-send the 62 * request, not just wait for the original request's reply to 63 * arrive. 64 * 65 * x_thread flag which tells us if a thread is doing a connection attempt. 66 * 67 * x_waitdis flag which tells us we are waiting a disconnect ACK. 68 * 69 * x_needdis flag which tells us we need to send a T_DISCONN_REQ 70 * to kill the connection. 71 * 72 * x_needrel flag which tells us we need to send a T_ORDREL_REQ to 73 * gracefully close the connection. 74 * 75 * #defined bitmasks for the all the b_* bits so that more 76 * efficient (and at times less clumsy) masks can be used to 77 * manipulated state in cases where multiple bits have to 78 * set/cleared/checked in the same critical section. 79 * 80 * x_conn_cv and x_dis-_cv are new condition variables to let 81 * threads knows when the connection attempt is done, and to let 82 * the connecting thread know when the disconnect handshake is 83 * done. 84 * 85 * Added the CONN_HOLD() macro so that all reference holds have the same 86 * look and feel. 87 * 88 * In the private (cku_private) portion of the client handle, 89 * 90 * cku_flags replaces the cku_sent a boolean. cku_flags keeps 91 * track of whether a request as been sent, and whether the 92 * client's handles call record is on the dispatch list (so that 93 * the reply can be matched by XID to the right client handle). 94 * The idea of CKU_ONQUEUE is that we can exit clnt_cots_kcallit() 95 * and still have the response find the right client handle so 96 * that the retry of CLNT_CALL() gets the result. Testing, found 97 * situations where if the timeout was increased, performance 98 * degraded. This was due to us hitting a window where the thread 99 * was back in rfscall() (probably printing server not responding) 100 * while the response came back but no place to put it. 101 * 102 * cku_ctime is just a cache of x_ctime. If they match, 103 * clnt_cots_kcallit() won't to send a retry (unless the maximum 104 * receive count limit as been reached). If the don't match, then 105 * we assume the request has been lost, and a retry of the request 106 * is needed. 107 * 108 * cku_recv_attempts counts the number of receive count attempts 109 * after one try is sent on the wire. 110 * 111 * Added the clnt_delay() routine so that interruptible and 112 * noninterruptible delays are possible. 113 * 114 * CLNT_MIN_TIMEOUT has been bumped to 10 seconds from 3. This is used to 115 * control how long the client delays before returned after getting 116 * ECONNREFUSED. At 3 seconds, 8 client threads per mount really does bash 117 * a server that may be booting and not yet started nfsd. 118 * 119 * CLNT_MAXRECV_WITHOUT_RETRY is a new macro (value of 3) (with a tunable) 120 * Why don't we just wait forever (receive an infinite # of times)? 121 * Because the server may have rebooted. More insidious is that some 122 * servers (ours) will drop NFS/TCP requests in some cases. This is bad, 123 * but it is a reality. 124 * 125 * The case of a server doing orderly release really messes up the 126 * client's recovery, especially if the server's TCP implementation is 127 * buggy. It was found was that the kRPC/COTS client was breaking some 128 * TPI rules, such as not waiting for the acknowledgement of a 129 * T_DISCON_REQ (hence the added case statements T_ERROR_ACK, T_OK_ACK and 130 * T_DISCON_REQ in clnt_dispatch_notifyall()). 131 * 132 * One of things that we've seen is that a kRPC TCP endpoint goes into 133 * TIMEWAIT and a thus a reconnect takes a long time to satisfy because 134 * that the TIMEWAIT state takes a while to finish. If a server sends a 135 * T_ORDREL_IND, there is little point in an RPC client doing a 136 * T_ORDREL_REQ, because the RPC request isn't going to make it (the 137 * server is saying that it won't accept any more data). So kRPC was 138 * changed to send a T_DISCON_REQ when we get a T_ORDREL_IND. So now the 139 * connection skips the TIMEWAIT state and goes straight to a bound state 140 * that kRPC can quickly switch to connected. 141 * 142 * Code that issues TPI request must use waitforack() to wait for the 143 * corresponding ack (assuming there is one) in any future modifications. 144 * This works around problems that may be introduced by breaking TPI rules 145 * (by submitting new calls before earlier requests have been acked) in the 146 * case of a signal or other early return. waitforack() depends on 147 * clnt_dispatch_notifyconn() to issue the wakeup when the ack 148 * arrives, so adding new TPI calls may require corresponding changes 149 * to clnt_dispatch_notifyconn(). Presently, the timeout period is based on 150 * CLNT_MIN_TIMEOUT which is 10 seconds. If you modify this value, be sure 151 * not to set it too low or TPI ACKS will be lost. 152 */ 153 154 #include <sys/param.h> 155 #include <sys/types.h> 156 #include <sys/user.h> 157 #include <sys/systm.h> 158 #include <sys/sysmacros.h> 159 #include <sys/proc.h> 160 #include <sys/socket.h> 161 #include <sys/file.h> 162 #include <sys/stream.h> 163 #include <sys/strsubr.h> 164 #include <sys/stropts.h> 165 #include <sys/strsun.h> 166 #include <sys/timod.h> 167 #include <sys/tiuser.h> 168 #include <sys/tihdr.h> 169 #include <sys/t_kuser.h> 170 #include <sys/fcntl.h> 171 #include <sys/errno.h> 172 #include <sys/kmem.h> 173 #include <sys/debug.h> 174 #include <sys/systm.h> 175 #include <sys/kstat.h> 176 #include <sys/t_lock.h> 177 #include <sys/ddi.h> 178 #include <sys/cmn_err.h> 179 #include <sys/time.h> 180 #include <sys/isa_defs.h> 181 #include <sys/callb.h> 182 #include <sys/sunddi.h> 183 #include <sys/atomic.h> 184 185 #include <netinet/in.h> 186 #include <netinet/tcp.h> 187 188 #include <rpc/types.h> 189 #include <rpc/xdr.h> 190 #include <rpc/auth.h> 191 #include <rpc/clnt.h> 192 #include <rpc/rpc_msg.h> 193 194 #define COTS_DEFAULT_ALLOCSIZE 2048 195 196 #define WIRE_HDR_SIZE 20 /* serialized call header, sans proc number */ 197 #define MSG_OFFSET 128 /* offset of call into the mblk */ 198 199 const char *kinet_ntop6(uchar_t *, char *, size_t); 200 201 static int clnt_cots_ksettimers(CLIENT *, struct rpc_timers *, 202 struct rpc_timers *, int, void(*)(int, int, caddr_t), caddr_t, uint32_t); 203 static enum clnt_stat clnt_cots_kcallit(CLIENT *, rpcproc_t, xdrproc_t, 204 caddr_t, xdrproc_t, caddr_t, struct timeval); 205 static void clnt_cots_kabort(CLIENT *); 206 static void clnt_cots_kerror(CLIENT *, struct rpc_err *); 207 static bool_t clnt_cots_kfreeres(CLIENT *, xdrproc_t, caddr_t); 208 static void clnt_cots_kdestroy(CLIENT *); 209 static bool_t clnt_cots_kcontrol(CLIENT *, int, char *); 210 211 212 /* List of transports managed by the connection manager. */ 213 struct cm_xprt { 214 TIUSER *x_tiptr; /* transport handle */ 215 queue_t *x_wq; /* send queue */ 216 clock_t x_time; /* last time we handed this xprt out */ 217 clock_t x_ctime; /* time we went to CONNECTED */ 218 int x_tidu_size; /* TIDU size of this transport */ 219 union { 220 struct { 221 unsigned int 222 #ifdef _BIT_FIELDS_HTOL 223 b_closing: 1, /* we've sent a ord rel on this conn */ 224 b_dead: 1, /* transport is closed or disconn */ 225 b_doomed: 1, /* too many conns, let this go idle */ 226 b_connected: 1, /* this connection is connected */ 227 228 b_ordrel: 1, /* do an orderly release? */ 229 b_thread: 1, /* thread doing connect */ 230 b_waitdis: 1, /* waiting for disconnect ACK */ 231 b_needdis: 1, /* need T_DISCON_REQ */ 232 233 b_needrel: 1, /* need T_ORDREL_REQ */ 234 b_early_disc: 1, /* got a T_ORDREL_IND or T_DISCON_IND */ 235 /* disconnect during connect */ 236 237 b_pad: 22; 238 239 #endif 240 241 #ifdef _BIT_FIELDS_LTOH 242 b_pad: 22, 243 244 b_early_disc: 1, /* got a T_ORDREL_IND or T_DISCON_IND */ 245 /* disconnect during connect */ 246 b_needrel: 1, /* need T_ORDREL_REQ */ 247 248 b_needdis: 1, /* need T_DISCON_REQ */ 249 b_waitdis: 1, /* waiting for disconnect ACK */ 250 b_thread: 1, /* thread doing connect */ 251 b_ordrel: 1, /* do an orderly release? */ 252 253 b_connected: 1, /* this connection is connected */ 254 b_doomed: 1, /* too many conns, let this go idle */ 255 b_dead: 1, /* transport is closed or disconn */ 256 b_closing: 1; /* we've sent a ord rel on this conn */ 257 #endif 258 } bit; unsigned int word; 259 260 #define x_closing x_state.bit.b_closing 261 #define x_dead x_state.bit.b_dead 262 #define x_doomed x_state.bit.b_doomed 263 #define x_connected x_state.bit.b_connected 264 265 #define x_ordrel x_state.bit.b_ordrel 266 #define x_thread x_state.bit.b_thread 267 #define x_waitdis x_state.bit.b_waitdis 268 #define x_needdis x_state.bit.b_needdis 269 270 #define x_needrel x_state.bit.b_needrel 271 #define x_early_disc x_state.bit.b_early_disc 272 273 #define x_state_flags x_state.word 274 275 #define X_CLOSING 0x80000000 276 #define X_DEAD 0x40000000 277 #define X_DOOMED 0x20000000 278 #define X_CONNECTED 0x10000000 279 280 #define X_ORDREL 0x08000000 281 #define X_THREAD 0x04000000 282 #define X_WAITDIS 0x02000000 283 #define X_NEEDDIS 0x01000000 284 285 #define X_NEEDREL 0x00800000 286 #define X_EARLYDISC 0x00400000 287 288 #define X_BADSTATES (X_CLOSING | X_DEAD | X_DOOMED) 289 290 } x_state; 291 int x_ref; /* number of users of this xprt */ 292 int x_family; /* address family of transport */ 293 dev_t x_rdev; /* device number of transport */ 294 struct cm_xprt *x_next; 295 296 struct netbuf x_server; /* destination address */ 297 struct netbuf x_src; /* src address (for retries) */ 298 kmutex_t x_lock; /* lock on this entry */ 299 kcondvar_t x_cv; /* to signal when can be closed */ 300 kcondvar_t x_conn_cv; /* to signal when connection attempt */ 301 /* is complete */ 302 kstat_t *x_ksp; 303 304 kcondvar_t x_dis_cv; /* to signal when disconnect attempt */ 305 /* is complete */ 306 zoneid_t x_zoneid; /* zone this xprt belongs to */ 307 }; 308 309 typedef struct cm_kstat_xprt { 310 kstat_named_t x_wq; 311 kstat_named_t x_server; 312 kstat_named_t x_family; 313 kstat_named_t x_rdev; 314 kstat_named_t x_time; 315 kstat_named_t x_state; 316 kstat_named_t x_ref; 317 kstat_named_t x_port; 318 } cm_kstat_xprt_t; 319 320 static cm_kstat_xprt_t cm_kstat_template = { 321 { "write_queue", KSTAT_DATA_UINT32 }, 322 { "server", KSTAT_DATA_STRING }, 323 { "addr_family", KSTAT_DATA_UINT32 }, 324 { "device", KSTAT_DATA_UINT32 }, 325 { "time_stamp", KSTAT_DATA_UINT32 }, 326 { "status", KSTAT_DATA_UINT32 }, 327 { "ref_count", KSTAT_DATA_INT32 }, 328 { "port", KSTAT_DATA_UINT32 }, 329 }; 330 331 /* 332 * The inverse of this is connmgr_release(). 333 */ 334 #define CONN_HOLD(Cm_entry) {\ 335 mutex_enter(&(Cm_entry)->x_lock); \ 336 (Cm_entry)->x_ref++; \ 337 mutex_exit(&(Cm_entry)->x_lock); \ 338 } 339 340 341 /* 342 * Private data per rpc handle. This structure is allocated by 343 * clnt_cots_kcreate, and freed by clnt_cots_kdestroy. 344 */ 345 typedef struct cku_private_s { 346 CLIENT cku_client; /* client handle */ 347 calllist_t cku_call; /* for dispatching calls */ 348 struct rpc_err cku_err; /* error status */ 349 350 struct netbuf cku_srcaddr; /* source address for retries */ 351 int cku_addrfmly; /* for binding port */ 352 struct netbuf cku_addr; /* remote address */ 353 dev_t cku_device; /* device to use */ 354 uint_t cku_flags; 355 #define CKU_ONQUEUE 0x1 356 #define CKU_SENT 0x2 357 358 bool_t cku_progress; /* for CLSET_PROGRESS */ 359 uint32_t cku_xid; /* current XID */ 360 clock_t cku_ctime; /* time stamp of when */ 361 /* connection was created */ 362 uint_t cku_recv_attempts; 363 XDR cku_outxdr; /* xdr routine for output */ 364 XDR cku_inxdr; /* xdr routine for input */ 365 char cku_rpchdr[WIRE_HDR_SIZE + 4]; 366 /* pre-serialized rpc header */ 367 368 uint_t cku_outbuflen; /* default output mblk length */ 369 struct cred *cku_cred; /* credentials */ 370 bool_t cku_nodelayonerr; 371 /* for CLSET_NODELAYONERR */ 372 int cku_useresvport; /* Use reserved port */ 373 struct rpc_cots_client *cku_stats; /* stats for zone */ 374 } cku_private_t; 375 376 static struct cm_xprt *connmgr_wrapconnect(struct cm_xprt *, 377 const struct timeval *, struct netbuf *, int, struct netbuf *, 378 struct rpc_err *, bool_t, bool_t); 379 380 static bool_t connmgr_connect(struct cm_xprt *, queue_t *, struct netbuf *, 381 int, calllist_t *, int *, bool_t reconnect, 382 const struct timeval *, bool_t); 383 384 static bool_t connmgr_setopt(queue_t *, int, int, calllist_t *); 385 static void connmgr_sndrel(struct cm_xprt *); 386 static void connmgr_snddis(struct cm_xprt *); 387 static void connmgr_close(struct cm_xprt *); 388 static void connmgr_release(struct cm_xprt *); 389 static struct cm_xprt *connmgr_wrapget(struct netbuf *, const struct timeval *, 390 cku_private_t *); 391 392 static struct cm_xprt *connmgr_get(struct netbuf *, const struct timeval *, 393 struct netbuf *, int, struct netbuf *, struct rpc_err *, dev_t, 394 bool_t, int); 395 396 static void connmgr_cancelconn(struct cm_xprt *); 397 static enum clnt_stat connmgr_cwait(struct cm_xprt *, const struct timeval *, 398 bool_t); 399 static void connmgr_dis_and_wait(struct cm_xprt *); 400 401 static void clnt_dispatch_send(queue_t *, mblk_t *, calllist_t *, uint_t, 402 uint_t); 403 404 static int clnt_delay(clock_t, bool_t); 405 406 static int waitforack(calllist_t *, t_scalar_t, const struct timeval *, bool_t); 407 408 /* 409 * Operations vector for TCP/IP based RPC 410 */ 411 static struct clnt_ops tcp_ops = { 412 clnt_cots_kcallit, /* do rpc call */ 413 clnt_cots_kabort, /* abort call */ 414 clnt_cots_kerror, /* return error status */ 415 clnt_cots_kfreeres, /* free results */ 416 clnt_cots_kdestroy, /* destroy rpc handle */ 417 clnt_cots_kcontrol, /* the ioctl() of rpc */ 418 clnt_cots_ksettimers, /* set retry timers */ 419 }; 420 421 static int rpc_kstat_instance = 0; /* keeps the current instance */ 422 /* number for the next kstat_create */ 423 424 static struct cm_xprt *cm_hd = NULL; 425 static kmutex_t connmgr_lock; /* for connection mngr's list of transports */ 426 427 extern kmutex_t clnt_max_msg_lock; 428 429 static calllist_t *clnt_pending = NULL; 430 extern kmutex_t clnt_pending_lock; 431 432 static int clnt_cots_hash_size = DEFAULT_HASH_SIZE; 433 434 static call_table_t *cots_call_ht; 435 436 static const struct rpc_cots_client { 437 kstat_named_t rccalls; 438 kstat_named_t rcbadcalls; 439 kstat_named_t rcbadxids; 440 kstat_named_t rctimeouts; 441 kstat_named_t rcnewcreds; 442 kstat_named_t rcbadverfs; 443 kstat_named_t rctimers; 444 kstat_named_t rccantconn; 445 kstat_named_t rcnomem; 446 kstat_named_t rcintrs; 447 } cots_rcstat_tmpl = { 448 { "calls", KSTAT_DATA_UINT64 }, 449 { "badcalls", KSTAT_DATA_UINT64 }, 450 { "badxids", KSTAT_DATA_UINT64 }, 451 { "timeouts", KSTAT_DATA_UINT64 }, 452 { "newcreds", KSTAT_DATA_UINT64 }, 453 { "badverfs", KSTAT_DATA_UINT64 }, 454 { "timers", KSTAT_DATA_UINT64 }, 455 { "cantconn", KSTAT_DATA_UINT64 }, 456 { "nomem", KSTAT_DATA_UINT64 }, 457 { "interrupts", KSTAT_DATA_UINT64 } 458 }; 459 460 #define COTSRCSTAT_INCR(p, x) \ 461 atomic_add_64(&(p)->x.value.ui64, 1) 462 463 #define CLNT_MAX_CONNS 1 /* concurrent connections between clnt/srvr */ 464 static int clnt_max_conns = CLNT_MAX_CONNS; 465 466 #define CLNT_MIN_TIMEOUT 10 /* seconds to wait after we get a */ 467 /* connection reset */ 468 #define CLNT_MIN_CONNTIMEOUT 5 /* seconds to wait for a connection */ 469 470 471 static int clnt_cots_min_tout = CLNT_MIN_TIMEOUT; 472 static int clnt_cots_min_conntout = CLNT_MIN_CONNTIMEOUT; 473 474 /* 475 * Limit the number of times we will attempt to receive a reply without 476 * re-sending a response. 477 */ 478 #define CLNT_MAXRECV_WITHOUT_RETRY 3 479 static uint_t clnt_cots_maxrecv = CLNT_MAXRECV_WITHOUT_RETRY; 480 481 uint_t *clnt_max_msg_sizep; 482 void (*clnt_stop_idle)(queue_t *wq); 483 484 #define ptoh(p) (&((p)->cku_client)) 485 #define htop(h) ((cku_private_t *)((h)->cl_private)) 486 487 /* 488 * Times to retry 489 */ 490 #define REFRESHES 2 /* authentication refreshes */ 491 492 /* 493 * The following is used to determine the global default behavior for 494 * COTS when binding to a local port. 495 * 496 * If the value is set to 1 the default will be to select a reserved 497 * (aka privileged) port, if the value is zero the default will be to 498 * use non-reserved ports. Users of kRPC may override this by using 499 * CLNT_CONTROL() and CLSET_BINDRESVPORT. 500 */ 501 static int clnt_cots_do_bindresvport = 1; 502 503 static zone_key_t zone_cots_key; 504 505 /* 506 * We need to do this after all kernel threads in the zone have exited. 507 */ 508 /* ARGSUSED */ 509 static void 510 clnt_zone_destroy(zoneid_t zoneid, void *unused) 511 { 512 struct cm_xprt **cmp; 513 struct cm_xprt *cm_entry; 514 struct cm_xprt *freelist = NULL; 515 516 mutex_enter(&connmgr_lock); 517 cmp = &cm_hd; 518 while ((cm_entry = *cmp) != NULL) { 519 if (cm_entry->x_zoneid == zoneid) { 520 *cmp = cm_entry->x_next; 521 cm_entry->x_next = freelist; 522 freelist = cm_entry; 523 } else { 524 cmp = &cm_entry->x_next; 525 } 526 } 527 mutex_exit(&connmgr_lock); 528 while ((cm_entry = freelist) != NULL) { 529 freelist = cm_entry->x_next; 530 connmgr_close(cm_entry); 531 } 532 } 533 534 int 535 clnt_cots_kcreate(dev_t dev, struct netbuf *addr, int family, rpcprog_t prog, 536 rpcvers_t vers, uint_t max_msgsize, cred_t *cred, CLIENT **ncl) 537 { 538 CLIENT *h; 539 cku_private_t *p; 540 struct rpc_msg call_msg; 541 struct rpcstat *rpcstat; 542 543 RPCLOG(8, "clnt_cots_kcreate: prog %u\n", prog); 544 545 rpcstat = zone_getspecific(rpcstat_zone_key, rpc_zone()); 546 ASSERT(rpcstat != NULL); 547 548 /* Allocate and intialize the client handle. */ 549 p = kmem_zalloc(sizeof (*p), KM_SLEEP); 550 551 h = ptoh(p); 552 553 h->cl_private = (caddr_t)p; 554 h->cl_auth = authkern_create(); 555 h->cl_ops = &tcp_ops; 556 557 cv_init(&p->cku_call.call_cv, NULL, CV_DEFAULT, NULL); 558 mutex_init(&p->cku_call.call_lock, NULL, MUTEX_DEFAULT, NULL); 559 560 /* 561 * If the current sanity check size in rpcmod is smaller 562 * than the size needed, then increase the sanity check. 563 */ 564 if (max_msgsize != 0 && clnt_max_msg_sizep != NULL && 565 max_msgsize > *clnt_max_msg_sizep) { 566 mutex_enter(&clnt_max_msg_lock); 567 if (max_msgsize > *clnt_max_msg_sizep) 568 *clnt_max_msg_sizep = max_msgsize; 569 mutex_exit(&clnt_max_msg_lock); 570 } 571 572 p->cku_outbuflen = COTS_DEFAULT_ALLOCSIZE; 573 574 /* Preserialize the call message header */ 575 576 call_msg.rm_xid = 0; 577 call_msg.rm_direction = CALL; 578 call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; 579 call_msg.rm_call.cb_prog = prog; 580 call_msg.rm_call.cb_vers = vers; 581 582 xdrmem_create(&p->cku_outxdr, p->cku_rpchdr, WIRE_HDR_SIZE, XDR_ENCODE); 583 584 if (!xdr_callhdr(&p->cku_outxdr, &call_msg)) { 585 RPCLOG0(1, "clnt_cots_kcreate - Fatal header serialization " 586 "error\n"); 587 auth_destroy(h->cl_auth); 588 kmem_free(p, sizeof (cku_private_t)); 589 RPCLOG0(1, "clnt_cots_kcreate: create failed error EINVAL\n"); 590 return (EINVAL); /* XXX */ 591 } 592 593 /* 594 * The zalloc initialized the fields below. 595 * p->cku_xid = 0; 596 * p->cku_flags = 0; 597 * p->cku_srcaddr.len = 0; 598 * p->cku_srcaddr.maxlen = 0; 599 */ 600 601 p->cku_cred = cred; 602 p->cku_device = dev; 603 p->cku_addrfmly = family; 604 p->cku_addr.buf = kmem_zalloc(addr->maxlen, KM_SLEEP); 605 p->cku_addr.maxlen = addr->maxlen; 606 p->cku_addr.len = addr->len; 607 bcopy(addr->buf, p->cku_addr.buf, addr->len); 608 p->cku_stats = rpcstat->rpc_cots_client; 609 p->cku_useresvport = -1; /* value is has not been set */ 610 611 *ncl = h; 612 return (0); 613 } 614 615 /*ARGSUSED*/ 616 static void 617 clnt_cots_kabort(CLIENT *h) 618 { 619 } 620 621 /* 622 * Return error info on this handle. 623 */ 624 static void 625 clnt_cots_kerror(CLIENT *h, struct rpc_err *err) 626 { 627 /* LINTED pointer alignment */ 628 cku_private_t *p = htop(h); 629 630 *err = p->cku_err; 631 } 632 633 static bool_t 634 clnt_cots_kfreeres(CLIENT *h, xdrproc_t xdr_res, caddr_t res_ptr) 635 { 636 /* LINTED pointer alignment */ 637 cku_private_t *p = htop(h); 638 XDR *xdrs; 639 640 xdrs = &(p->cku_outxdr); 641 xdrs->x_op = XDR_FREE; 642 return ((*xdr_res)(xdrs, res_ptr)); 643 } 644 645 static bool_t 646 clnt_cots_kcontrol(CLIENT *h, int cmd, char *arg) 647 { 648 cku_private_t *p = htop(h); 649 650 switch (cmd) { 651 case CLSET_PROGRESS: 652 p->cku_progress = TRUE; 653 return (TRUE); 654 655 case CLSET_XID: 656 if (arg == NULL) 657 return (FALSE); 658 659 p->cku_xid = *((uint32_t *)arg); 660 return (TRUE); 661 662 case CLGET_XID: 663 if (arg == NULL) 664 return (FALSE); 665 666 *((uint32_t *)arg) = p->cku_xid; 667 return (TRUE); 668 669 case CLSET_NODELAYONERR: 670 if (arg == NULL) 671 return (FALSE); 672 673 if (*((bool_t *)arg) == TRUE) { 674 p->cku_nodelayonerr = TRUE; 675 return (TRUE); 676 } 677 if (*((bool_t *)arg) == FALSE) { 678 p->cku_nodelayonerr = FALSE; 679 return (TRUE); 680 } 681 return (FALSE); 682 683 case CLGET_NODELAYONERR: 684 if (arg == NULL) 685 return (FALSE); 686 687 *((bool_t *)arg) = p->cku_nodelayonerr; 688 return (TRUE); 689 690 case CLSET_BINDRESVPORT: 691 if (arg == NULL) 692 return (FALSE); 693 694 if (*(int *)arg != 1 && *(int *)arg != 0) 695 return (FALSE); 696 697 p->cku_useresvport = *(int *)arg; 698 699 return (TRUE); 700 701 case CLGET_BINDRESVPORT: 702 if (arg == NULL) 703 return (FALSE); 704 705 *(int *)arg = p->cku_useresvport; 706 707 return (TRUE); 708 709 default: 710 return (FALSE); 711 } 712 } 713 714 /* 715 * Destroy rpc handle. Frees the space used for output buffer, 716 * private data, and handle structure. 717 */ 718 static void 719 clnt_cots_kdestroy(CLIENT *h) 720 { 721 /* LINTED pointer alignment */ 722 cku_private_t *p = htop(h); 723 calllist_t *call = &p->cku_call; 724 725 RPCLOG(8, "clnt_cots_kdestroy h: %p\n", (void *)h); 726 RPCLOG(8, "clnt_cots_kdestroy h: xid=0x%x\n", p->cku_xid); 727 728 if (p->cku_flags & CKU_ONQUEUE) { 729 RPCLOG(64, "clnt_cots_kdestroy h: removing call for xid 0x%x " 730 "from dispatch list\n", p->cku_xid); 731 call_table_remove(call); 732 } 733 734 if (call->call_reply) 735 freemsg(call->call_reply); 736 cv_destroy(&call->call_cv); 737 mutex_destroy(&call->call_lock); 738 739 kmem_free(p->cku_srcaddr.buf, p->cku_srcaddr.maxlen); 740 kmem_free(p->cku_addr.buf, p->cku_addr.maxlen); 741 kmem_free(p, sizeof (*p)); 742 } 743 744 static int clnt_cots_pulls; 745 #define RM_HDR_SIZE 4 /* record mark header size */ 746 747 /* 748 * Call remote procedure. 749 */ 750 static enum clnt_stat 751 clnt_cots_kcallit(CLIENT *h, rpcproc_t procnum, xdrproc_t xdr_args, 752 caddr_t argsp, xdrproc_t xdr_results, caddr_t resultsp, struct timeval wait) 753 { 754 /* LINTED pointer alignment */ 755 cku_private_t *p = htop(h); 756 calllist_t *call = &p->cku_call; 757 XDR *xdrs; 758 struct rpc_msg reply_msg; 759 mblk_t *mp; 760 #ifdef RPCDEBUG 761 clock_t time_sent; 762 #endif 763 struct netbuf *retryaddr; 764 struct cm_xprt *cm_entry = NULL; 765 queue_t *wq; 766 int len; 767 int mpsize; 768 int refreshes = REFRESHES; 769 int interrupted; 770 int tidu_size; 771 enum clnt_stat status; 772 struct timeval cwait; 773 bool_t delay_first = FALSE; 774 clock_t ticks; 775 776 RPCLOG(2, "clnt_cots_kcallit, procnum %u\n", procnum); 777 COTSRCSTAT_INCR(p->cku_stats, rccalls); 778 779 RPCLOG(2, "clnt_cots_kcallit: wait.tv_sec: %ld\n", wait.tv_sec); 780 RPCLOG(2, "clnt_cots_kcallit: wait.tv_usec: %ld\n", wait.tv_usec); 781 782 /* 783 * Bug ID 1240234: 784 * Look out for zero length timeouts. We don't want to 785 * wait zero seconds for a connection to be established. 786 */ 787 if (wait.tv_sec < clnt_cots_min_conntout) { 788 cwait.tv_sec = clnt_cots_min_conntout; 789 cwait.tv_usec = 0; 790 RPCLOG(8, "clnt_cots_kcallit: wait.tv_sec (%ld) too low,", 791 wait.tv_sec); 792 RPCLOG(8, " setting to: %d\n", clnt_cots_min_conntout); 793 } else { 794 cwait = wait; 795 } 796 797 call_again: 798 if (cm_entry) { 799 connmgr_release(cm_entry); 800 cm_entry = NULL; 801 } 802 803 mp = NULL; 804 805 /* 806 * If the call is not a retry, allocate a new xid and cache it 807 * for future retries. 808 * Bug ID 1246045: 809 * Treat call as a retry for purposes of binding the source 810 * port only if we actually attempted to send anything on 811 * the previous call. 812 */ 813 if (p->cku_xid == 0) { 814 p->cku_xid = alloc_xid(); 815 /* 816 * We need to ASSERT here that our xid != 0 because this 817 * determines whether or not our call record gets placed on 818 * the hash table or the linked list. By design, we mandate 819 * that RPC calls over cots must have xid's != 0, so we can 820 * ensure proper management of the hash table. 821 */ 822 ASSERT(p->cku_xid != 0); 823 824 retryaddr = NULL; 825 p->cku_flags &= ~CKU_SENT; 826 827 if (p->cku_flags & CKU_ONQUEUE) { 828 RPCLOG(8, "clnt_cots_kcallit: new call, dequeuing old" 829 " one (%p)\n", (void *)call); 830 call_table_remove(call); 831 p->cku_flags &= ~CKU_ONQUEUE; 832 RPCLOG(64, "clnt_cots_kcallit: removing call from " 833 "dispatch list because xid was zero (now 0x%x)\n", 834 p->cku_xid); 835 } 836 837 if (call->call_reply != NULL) { 838 freemsg(call->call_reply); 839 call->call_reply = NULL; 840 } 841 } else if (p->cku_srcaddr.buf == NULL || p->cku_srcaddr.len == 0) { 842 retryaddr = NULL; 843 844 } else if (p->cku_flags & CKU_SENT) { 845 retryaddr = &p->cku_srcaddr; 846 847 } else { 848 /* 849 * Bug ID 1246045: Nothing was sent, so set retryaddr to 850 * NULL and let connmgr_get() bind to any source port it 851 * can get. 852 */ 853 retryaddr = NULL; 854 } 855 856 RPCLOG(64, "clnt_cots_kcallit: xid = 0x%x", p->cku_xid); 857 RPCLOG(64, " flags = 0x%x\n", p->cku_flags); 858 859 p->cku_err.re_status = RPC_TIMEDOUT; 860 p->cku_err.re_errno = p->cku_err.re_terrno = 0; 861 862 cm_entry = connmgr_wrapget(retryaddr, &cwait, p); 863 864 if (cm_entry == NULL) { 865 RPCLOG(1, "clnt_cots_kcallit: can't connect status %s\n", 866 clnt_sperrno(p->cku_err.re_status)); 867 868 /* 869 * The reasons why we fail to create a connection are 870 * varied. In most cases we don't want the caller to 871 * immediately retry. This could have one or more 872 * bad effects. This includes flooding the net with 873 * connect requests to ports with no listener; a hard 874 * kernel loop due to all the "reserved" TCP ports being 875 * in use. 876 */ 877 delay_first = TRUE; 878 879 /* 880 * Even if we end up returning EINTR, we still count a 881 * a "can't connect", because the connection manager 882 * might have been committed to waiting for or timing out on 883 * a connection. 884 */ 885 COTSRCSTAT_INCR(p->cku_stats, rccantconn); 886 switch (p->cku_err.re_status) { 887 case RPC_INTR: 888 p->cku_err.re_errno = EINTR; 889 890 /* 891 * No need to delay because a UNIX signal(2) 892 * interrupted us. The caller likely won't 893 * retry the CLNT_CALL() and even if it does, 894 * we assume the caller knows what it is doing. 895 */ 896 delay_first = FALSE; 897 break; 898 899 case RPC_TIMEDOUT: 900 p->cku_err.re_errno = ETIMEDOUT; 901 902 /* 903 * No need to delay because timed out already 904 * on the connection request and assume that the 905 * transport time out is longer than our minimum 906 * timeout, or least not too much smaller. 907 */ 908 delay_first = FALSE; 909 break; 910 911 case RPC_SYSTEMERROR: 912 case RPC_TLIERROR: 913 /* 914 * We want to delay here because a transient 915 * system error has a better chance of going away 916 * if we delay a bit. If it's not transient, then 917 * we don't want end up in a hard kernel loop 918 * due to retries. 919 */ 920 ASSERT(p->cku_err.re_errno != 0); 921 break; 922 923 924 case RPC_CANTCONNECT: 925 /* 926 * RPC_CANTCONNECT is set on T_ERROR_ACK which 927 * implies some error down in the TCP layer or 928 * below. If cku_nodelayonerror is set then we 929 * assume the caller knows not to try too hard. 930 */ 931 RPCLOG0(8, "clnt_cots_kcallit: connection failed,"); 932 RPCLOG0(8, " re_status=RPC_CANTCONNECT,"); 933 RPCLOG(8, " re_errno=%d,", p->cku_err.re_errno); 934 RPCLOG(8, " cku_nodelayonerr=%d", p->cku_nodelayonerr); 935 if (p->cku_nodelayonerr == TRUE) 936 delay_first = FALSE; 937 938 p->cku_err.re_errno = EIO; 939 940 break; 941 942 case RPC_XPRTFAILED: 943 /* 944 * We want to delay here because we likely 945 * got a refused connection. 946 */ 947 if (p->cku_err.re_errno != 0) 948 break; 949 950 /* fall thru */ 951 952 default: 953 /* 954 * We delay here because it is better to err 955 * on the side of caution. If we got here then 956 * status could have been RPC_SUCCESS, but we 957 * know that we did not get a connection, so 958 * force the rpc status to RPC_CANTCONNECT. 959 */ 960 p->cku_err.re_status = RPC_CANTCONNECT; 961 p->cku_err.re_errno = EIO; 962 break; 963 } 964 if (delay_first == TRUE) 965 ticks = clnt_cots_min_tout * drv_usectohz(1000000); 966 goto cots_done; 967 } 968 969 /* 970 * If we've never sent any request on this connection (send count 971 * is zero, or the connection has been reset), cache the 972 * the connection's create time and send a request (possibly a retry) 973 */ 974 if ((p->cku_flags & CKU_SENT) == 0 || 975 p->cku_ctime != cm_entry->x_ctime) { 976 p->cku_ctime = cm_entry->x_ctime; 977 978 } else if ((p->cku_flags & CKU_SENT) && (p->cku_flags & CKU_ONQUEUE) && 979 (call->call_reply != NULL || 980 p->cku_recv_attempts < clnt_cots_maxrecv)) { 981 982 /* 983 * If we've sent a request and our call is on the dispatch 984 * queue and we haven't made too many receive attempts, then 985 * don't re-send, just receive. 986 */ 987 p->cku_recv_attempts++; 988 goto read_again; 989 } 990 991 /* 992 * Now we create the RPC request in a STREAMS message. We have to do 993 * this after the call to connmgr_get so that we have the correct 994 * TIDU size for the transport. 995 */ 996 tidu_size = cm_entry->x_tidu_size; 997 len = MSG_OFFSET + MAX(tidu_size, RM_HDR_SIZE + WIRE_HDR_SIZE); 998 999 while ((mp = allocb(len, BPRI_MED)) == NULL) { 1000 if (strwaitbuf(len, BPRI_MED)) { 1001 p->cku_err.re_status = RPC_SYSTEMERROR; 1002 p->cku_err.re_errno = ENOSR; 1003 COTSRCSTAT_INCR(p->cku_stats, rcnomem); 1004 goto cots_done; 1005 } 1006 } 1007 xdrs = &p->cku_outxdr; 1008 xdrmblk_init(xdrs, mp, XDR_ENCODE, tidu_size); 1009 mpsize = MBLKSIZE(mp); 1010 ASSERT(mpsize >= len); 1011 ASSERT(mp->b_rptr == mp->b_datap->db_base); 1012 1013 /* 1014 * If the size of mblk is not appreciably larger than what we 1015 * asked, then resize the mblk to exactly len bytes. The reason for 1016 * this: suppose len is 1600 bytes, the tidu is 1460 bytes 1017 * (from TCP over ethernet), and the arguments to the RPC require 1018 * 2800 bytes. Ideally we want the protocol to render two 1019 * ~1400 byte segments over the wire. However if allocb() gives us a 2k 1020 * mblk, and we allocate a second mblk for the remainder, the protocol 1021 * module may generate 3 segments over the wire: 1022 * 1460 bytes for the first, 448 (2048 - 1600) for the second, and 1023 * 892 for the third. If we "waste" 448 bytes in the first mblk, 1024 * the XDR encoding will generate two ~1400 byte mblks, and the 1025 * protocol module is more likely to produce properly sized segments. 1026 */ 1027 if ((mpsize >> 1) <= len) 1028 mp->b_rptr += (mpsize - len); 1029 1030 /* 1031 * Adjust b_rptr to reserve space for the non-data protocol headers 1032 * any downstream modules might like to add, and for the 1033 * record marking header. 1034 */ 1035 mp->b_rptr += (MSG_OFFSET + RM_HDR_SIZE); 1036 1037 if (h->cl_auth->ah_cred.oa_flavor != RPCSEC_GSS) { 1038 /* Copy in the preserialized RPC header information. */ 1039 bcopy(p->cku_rpchdr, mp->b_rptr, WIRE_HDR_SIZE); 1040 1041 /* Use XDR_SETPOS() to set the b_wptr to past the RPC header. */ 1042 XDR_SETPOS(xdrs, (uint_t)(mp->b_rptr - mp->b_datap->db_base + 1043 WIRE_HDR_SIZE)); 1044 1045 ASSERT((mp->b_wptr - mp->b_rptr) == WIRE_HDR_SIZE); 1046 1047 /* Serialize the procedure number and the arguments. */ 1048 if ((!XDR_PUTINT32(xdrs, (int32_t *)&procnum)) || 1049 (!AUTH_MARSHALL(h->cl_auth, xdrs, p->cku_cred)) || 1050 (!(*xdr_args)(xdrs, argsp))) { 1051 p->cku_err.re_status = RPC_CANTENCODEARGS; 1052 p->cku_err.re_errno = EIO; 1053 goto cots_done; 1054 } 1055 1056 (*(uint32_t *)(mp->b_rptr)) = p->cku_xid; 1057 } else { 1058 uint32_t *uproc = (uint32_t *)&p->cku_rpchdr[WIRE_HDR_SIZE]; 1059 IXDR_PUT_U_INT32(uproc, procnum); 1060 1061 (*(uint32_t *)(&p->cku_rpchdr[0])) = p->cku_xid; 1062 1063 /* Use XDR_SETPOS() to set the b_wptr. */ 1064 XDR_SETPOS(xdrs, (uint_t)(mp->b_rptr - mp->b_datap->db_base)); 1065 1066 /* Serialize the procedure number and the arguments. */ 1067 if (!AUTH_WRAP(h->cl_auth, p->cku_rpchdr, WIRE_HDR_SIZE+4, 1068 xdrs, xdr_args, argsp)) { 1069 p->cku_err.re_status = RPC_CANTENCODEARGS; 1070 p->cku_err.re_errno = EIO; 1071 goto cots_done; 1072 } 1073 } 1074 1075 RPCLOG(2, "clnt_cots_kcallit: connected, sending call, tidu_size %d\n", 1076 tidu_size); 1077 1078 wq = cm_entry->x_wq; 1079 clnt_dispatch_send(wq, mp, call, p->cku_xid, 1080 (p->cku_flags & CKU_ONQUEUE)); 1081 1082 RPCLOG(64, "clnt_cots_kcallit: sent call for xid 0x%x\n", 1083 (uint_t)p->cku_xid); 1084 p->cku_flags = (CKU_ONQUEUE|CKU_SENT); 1085 p->cku_recv_attempts = 1; 1086 1087 #ifdef RPCDEBUG 1088 time_sent = lbolt; 1089 #endif 1090 1091 /* 1092 * Wait for a reply or a timeout. If there is no error or timeout, 1093 * (both indicated by call_status), call->call_reply will contain 1094 * the RPC reply message. 1095 */ 1096 read_again: 1097 mutex_enter(&call->call_lock); 1098 interrupted = 0; 1099 if (call->call_status == RPC_TIMEDOUT) { 1100 /* 1101 * Indicate that the lwp is not to be stopped while waiting 1102 * for this network traffic. This is to avoid deadlock while 1103 * debugging a process via /proc and also to avoid recursive 1104 * mutex_enter()s due to NFS page faults while stopping 1105 * (NFS holds locks when it calls here). 1106 */ 1107 clock_t cv_wait_ret; 1108 clock_t timout; 1109 clock_t oldlbolt; 1110 1111 klwp_t *lwp = ttolwp(curthread); 1112 1113 if (lwp != NULL) 1114 lwp->lwp_nostop++; 1115 1116 oldlbolt = lbolt; 1117 timout = wait.tv_sec * drv_usectohz(1000000) + 1118 drv_usectohz(wait.tv_usec) + oldlbolt; 1119 /* 1120 * Iterate until the call_status is changed to something 1121 * other that RPC_TIMEDOUT, or if cv_timedwait_sig() returns 1122 * something <=0 zero. The latter means that we timed 1123 * out. 1124 */ 1125 if (h->cl_nosignal) 1126 while ((cv_wait_ret = cv_timedwait(&call->call_cv, 1127 &call->call_lock, timout)) > 0 && 1128 call->call_status == RPC_TIMEDOUT); 1129 else 1130 while ((cv_wait_ret = cv_timedwait_sig( 1131 &call->call_cv, 1132 &call->call_lock, timout)) > 0 && 1133 call->call_status == RPC_TIMEDOUT); 1134 1135 switch (cv_wait_ret) { 1136 case 0: 1137 /* 1138 * If we got out of the above loop with 1139 * cv_timedwait_sig() returning 0, then we were 1140 * interrupted regardless what call_status is. 1141 */ 1142 interrupted = 1; 1143 break; 1144 case -1: 1145 /* cv_timedwait_sig() timed out */ 1146 break; 1147 default: 1148 1149 /* 1150 * We were cv_signaled(). If we didn't 1151 * get a successful call_status and returned 1152 * before time expired, delay up to clnt_cots_min_tout 1153 * seconds so that the caller doesn't immediately 1154 * try to call us again and thus force the 1155 * same condition that got us here (such 1156 * as a RPC_XPRTFAILED due to the server not 1157 * listening on the end-point. 1158 */ 1159 if (call->call_status != RPC_SUCCESS) { 1160 clock_t curlbolt; 1161 clock_t diff; 1162 1163 curlbolt = ddi_get_lbolt(); 1164 ticks = clnt_cots_min_tout * 1165 drv_usectohz(1000000); 1166 diff = curlbolt - oldlbolt; 1167 if (diff < ticks) { 1168 delay_first = TRUE; 1169 if (diff > 0) 1170 ticks -= diff; 1171 } 1172 } 1173 break; 1174 } 1175 1176 if (lwp != NULL) 1177 lwp->lwp_nostop--; 1178 } 1179 /* 1180 * Get the reply message, if any. This will be freed at the end 1181 * whether or not an error occurred. 1182 */ 1183 mp = call->call_reply; 1184 call->call_reply = NULL; 1185 1186 /* 1187 * call_err is the error info when the call is on dispatch queue. 1188 * cku_err is the error info returned to the caller. 1189 * Sync cku_err with call_err for local message processing. 1190 */ 1191 1192 status = call->call_status; 1193 p->cku_err = call->call_err; 1194 mutex_exit(&call->call_lock); 1195 1196 if (status != RPC_SUCCESS) { 1197 switch (status) { 1198 case RPC_TIMEDOUT: 1199 if (interrupted) { 1200 COTSRCSTAT_INCR(p->cku_stats, rcintrs); 1201 p->cku_err.re_status = RPC_INTR; 1202 p->cku_err.re_errno = EINTR; 1203 RPCLOG(1, "clnt_cots_kcallit: xid 0x%x", 1204 p->cku_xid); 1205 RPCLOG(1, "signal interrupted at %ld", lbolt); 1206 RPCLOG(1, ", was sent at %ld\n", time_sent); 1207 } else { 1208 COTSRCSTAT_INCR(p->cku_stats, rctimeouts); 1209 p->cku_err.re_errno = ETIMEDOUT; 1210 RPCLOG(1, "clnt_cots_kcallit: timed out at %ld", 1211 lbolt); 1212 RPCLOG(1, ", was sent at %ld\n", time_sent); 1213 } 1214 break; 1215 1216 case RPC_XPRTFAILED: 1217 if (p->cku_err.re_errno == 0) 1218 p->cku_err.re_errno = EIO; 1219 1220 RPCLOG(1, "clnt_cots_kcallit: transport failed: %d\n", 1221 p->cku_err.re_errno); 1222 break; 1223 1224 case RPC_SYSTEMERROR: 1225 ASSERT(p->cku_err.re_errno); 1226 RPCLOG(1, "clnt_cots_kcallit: system error: %d\n", 1227 p->cku_err.re_errno); 1228 break; 1229 1230 default: 1231 p->cku_err.re_status = RPC_SYSTEMERROR; 1232 p->cku_err.re_errno = EIO; 1233 RPCLOG(1, "clnt_cots_kcallit: error: %s\n", 1234 clnt_sperrno(status)); 1235 break; 1236 } 1237 if (p->cku_err.re_status != RPC_TIMEDOUT) { 1238 1239 if (p->cku_flags & CKU_ONQUEUE) { 1240 call_table_remove(call); 1241 p->cku_flags &= ~CKU_ONQUEUE; 1242 } 1243 1244 RPCLOG(64, "clnt_cots_kcallit: non TIMEOUT so xid 0x%x " 1245 "taken off dispatch list\n", p->cku_xid); 1246 if (call->call_reply) { 1247 freemsg(call->call_reply); 1248 call->call_reply = NULL; 1249 } 1250 } else if (wait.tv_sec != 0) { 1251 /* 1252 * We've sent the request over TCP and so we have 1253 * every reason to believe it will get 1254 * delivered. In which case returning a timeout is not 1255 * appropriate. 1256 */ 1257 if (p->cku_progress == TRUE && 1258 p->cku_recv_attempts < clnt_cots_maxrecv) { 1259 p->cku_err.re_status = RPC_INPROGRESS; 1260 } 1261 } 1262 goto cots_done; 1263 } 1264 1265 xdrs = &p->cku_inxdr; 1266 xdrmblk_init(xdrs, mp, XDR_DECODE, 0); 1267 1268 reply_msg.rm_direction = REPLY; 1269 reply_msg.rm_reply.rp_stat = MSG_ACCEPTED; 1270 reply_msg.acpted_rply.ar_stat = SUCCESS; 1271 1272 reply_msg.acpted_rply.ar_verf = _null_auth; 1273 /* 1274 * xdr_results will be done in AUTH_UNWRAP. 1275 */ 1276 reply_msg.acpted_rply.ar_results.where = NULL; 1277 reply_msg.acpted_rply.ar_results.proc = xdr_void; 1278 1279 if (xdr_replymsg(xdrs, &reply_msg)) { 1280 enum clnt_stat re_status; 1281 1282 _seterr_reply(&reply_msg, &p->cku_err); 1283 1284 re_status = p->cku_err.re_status; 1285 if (re_status == RPC_SUCCESS) { 1286 /* 1287 * Reply is good, check auth. 1288 */ 1289 if (!AUTH_VALIDATE(h->cl_auth, 1290 &reply_msg.acpted_rply.ar_verf)) { 1291 COTSRCSTAT_INCR(p->cku_stats, rcbadverfs); 1292 RPCLOG0(1, "clnt_cots_kcallit: validation " 1293 "failure\n"); 1294 freemsg(mp); 1295 (void) xdr_rpc_free_verifier(xdrs, &reply_msg); 1296 mutex_enter(&call->call_lock); 1297 if (call->call_reply == NULL) 1298 call->call_status = RPC_TIMEDOUT; 1299 mutex_exit(&call->call_lock); 1300 goto read_again; 1301 } else if (!AUTH_UNWRAP(h->cl_auth, xdrs, 1302 xdr_results, resultsp)) { 1303 RPCLOG0(1, "clnt_cots_kcallit: validation " 1304 "failure (unwrap)\n"); 1305 p->cku_err.re_status = RPC_CANTDECODERES; 1306 p->cku_err.re_errno = EIO; 1307 } 1308 } else { 1309 /* set errno in case we can't recover */ 1310 if (re_status != RPC_VERSMISMATCH && 1311 re_status != RPC_AUTHERROR && 1312 re_status != RPC_PROGVERSMISMATCH) 1313 p->cku_err.re_errno = EIO; 1314 1315 if (re_status == RPC_AUTHERROR) { 1316 /* 1317 * Maybe our credential need to be refreshed 1318 */ 1319 if (cm_entry) { 1320 /* 1321 * There is the potential that the 1322 * cm_entry has/will be marked dead, 1323 * so drop the connection altogether, 1324 * force REFRESH to establish new 1325 * connection. 1326 */ 1327 connmgr_cancelconn(cm_entry); 1328 cm_entry = NULL; 1329 } 1330 1331 if ((refreshes > 0) && 1332 AUTH_REFRESH(h->cl_auth, &reply_msg, 1333 p->cku_cred)) { 1334 refreshes--; 1335 (void) xdr_rpc_free_verifier(xdrs, 1336 &reply_msg); 1337 freemsg(mp); 1338 mp = NULL; 1339 1340 if (p->cku_flags & CKU_ONQUEUE) { 1341 call_table_remove(call); 1342 p->cku_flags &= ~CKU_ONQUEUE; 1343 } 1344 1345 RPCLOG(64, 1346 "clnt_cots_kcallit: AUTH_ERROR, xid" 1347 " 0x%x removed off dispatch list\n", 1348 p->cku_xid); 1349 if (call->call_reply) { 1350 freemsg(call->call_reply); 1351 call->call_reply = NULL; 1352 } 1353 1354 COTSRCSTAT_INCR(p->cku_stats, 1355 rcbadcalls); 1356 COTSRCSTAT_INCR(p->cku_stats, 1357 rcnewcreds); 1358 goto call_again; 1359 } 1360 1361 /* 1362 * We have used the client handle to 1363 * do an AUTH_REFRESH and the RPC status may 1364 * be set to RPC_SUCCESS; Let's make sure to 1365 * set it to RPC_AUTHERROR. 1366 */ 1367 p->cku_err.re_status = RPC_AUTHERROR; 1368 1369 /* 1370 * Map recoverable and unrecoverable 1371 * authentication errors to appropriate errno 1372 */ 1373 switch (p->cku_err.re_why) { 1374 case AUTH_TOOWEAK: 1375 /* 1376 * This could be a failure where the 1377 * server requires use of a reserved 1378 * port, check and optionally set the 1379 * client handle useresvport trying 1380 * one more time. Next go round we 1381 * fall out with the tooweak error. 1382 */ 1383 if (p->cku_useresvport != 1) { 1384 p->cku_useresvport = 1; 1385 p->cku_xid = 0; 1386 (void) xdr_rpc_free_verifier 1387 (xdrs, &reply_msg); 1388 freemsg(mp); 1389 goto call_again; 1390 } 1391 /* FALLTHRU */ 1392 case AUTH_BADCRED: 1393 case AUTH_BADVERF: 1394 case AUTH_INVALIDRESP: 1395 case AUTH_FAILED: 1396 case RPCSEC_GSS_NOCRED: 1397 case RPCSEC_GSS_FAILED: 1398 p->cku_err.re_errno = EACCES; 1399 break; 1400 case AUTH_REJECTEDCRED: 1401 case AUTH_REJECTEDVERF: 1402 default: p->cku_err.re_errno = EIO; 1403 break; 1404 } 1405 RPCLOG(1, "clnt_cots_kcallit : authentication" 1406 " failed with RPC_AUTHERROR of type %d\n", 1407 (int)p->cku_err.re_why); 1408 } 1409 } 1410 } else { 1411 /* reply didn't decode properly. */ 1412 p->cku_err.re_status = RPC_CANTDECODERES; 1413 p->cku_err.re_errno = EIO; 1414 RPCLOG0(1, "clnt_cots_kcallit: decode failure\n"); 1415 } 1416 1417 (void) xdr_rpc_free_verifier(xdrs, &reply_msg); 1418 1419 if (p->cku_flags & CKU_ONQUEUE) { 1420 call_table_remove(call); 1421 p->cku_flags &= ~CKU_ONQUEUE; 1422 } 1423 1424 RPCLOG(64, "clnt_cots_kcallit: xid 0x%x taken off dispatch list", 1425 p->cku_xid); 1426 RPCLOG(64, " status is %s\n", clnt_sperrno(p->cku_err.re_status)); 1427 cots_done: 1428 if (cm_entry) 1429 connmgr_release(cm_entry); 1430 1431 if (mp != NULL) 1432 freemsg(mp); 1433 if ((p->cku_flags & CKU_ONQUEUE) == 0 && call->call_reply) { 1434 freemsg(call->call_reply); 1435 call->call_reply = NULL; 1436 } 1437 if (p->cku_err.re_status != RPC_SUCCESS) { 1438 RPCLOG0(1, "clnt_cots_kcallit: tail-end failure\n"); 1439 COTSRCSTAT_INCR(p->cku_stats, rcbadcalls); 1440 } 1441 1442 /* 1443 * No point in delaying if the zone is going away. 1444 */ 1445 if (delay_first == TRUE && 1446 !(zone_status_get(curproc->p_zone) >= ZONE_IS_SHUTTING_DOWN)) { 1447 if (clnt_delay(ticks, h->cl_nosignal) == EINTR) { 1448 p->cku_err.re_errno = EINTR; 1449 p->cku_err.re_status = RPC_INTR; 1450 } 1451 } 1452 return (p->cku_err.re_status); 1453 } 1454 1455 /* 1456 * Kinit routine for cots. This sets up the correct operations in 1457 * the client handle, as the handle may have previously been a clts 1458 * handle, and clears the xid field so there is no way a new call 1459 * could be mistaken for a retry. It also sets in the handle the 1460 * information that is passed at create/kinit time but needed at 1461 * call time, as cots creates the transport at call time - device, 1462 * address of the server, protocol family. 1463 */ 1464 void 1465 clnt_cots_kinit(CLIENT *h, dev_t dev, int family, struct netbuf *addr, 1466 int max_msgsize, cred_t *cred) 1467 { 1468 /* LINTED pointer alignment */ 1469 cku_private_t *p = htop(h); 1470 calllist_t *call = &p->cku_call; 1471 1472 h->cl_ops = &tcp_ops; 1473 if (p->cku_flags & CKU_ONQUEUE) { 1474 call_table_remove(call); 1475 p->cku_flags &= ~CKU_ONQUEUE; 1476 RPCLOG(64, "clnt_cots_kinit: removing call for xid 0x%x from" 1477 " dispatch list\n", p->cku_xid); 1478 } 1479 1480 if (call->call_reply != NULL) { 1481 freemsg(call->call_reply); 1482 call->call_reply = NULL; 1483 } 1484 1485 call->call_bucket = NULL; 1486 call->call_hash = 0; 1487 1488 /* 1489 * We don't clear cku_flags here, because clnt_cots_kcallit() 1490 * takes care of handling the cku_flags reset. 1491 */ 1492 p->cku_xid = 0; 1493 p->cku_device = dev; 1494 p->cku_addrfmly = family; 1495 p->cku_cred = cred; 1496 1497 if (p->cku_addr.maxlen < addr->len) { 1498 if (p->cku_addr.maxlen != 0 && p->cku_addr.buf != NULL) 1499 kmem_free(p->cku_addr.buf, p->cku_addr.maxlen); 1500 p->cku_addr.buf = kmem_zalloc(addr->maxlen, KM_SLEEP); 1501 p->cku_addr.maxlen = addr->maxlen; 1502 } 1503 1504 p->cku_addr.len = addr->len; 1505 bcopy(addr->buf, p->cku_addr.buf, addr->len); 1506 1507 /* 1508 * If the current sanity check size in rpcmod is smaller 1509 * than the size needed, then increase the sanity check. 1510 */ 1511 if (max_msgsize != 0 && clnt_max_msg_sizep != NULL && 1512 max_msgsize > *clnt_max_msg_sizep) { 1513 mutex_enter(&clnt_max_msg_lock); 1514 if (max_msgsize > *clnt_max_msg_sizep) 1515 *clnt_max_msg_sizep = max_msgsize; 1516 mutex_exit(&clnt_max_msg_lock); 1517 } 1518 } 1519 1520 /* 1521 * ksettimers is a no-op for cots, with the exception of setting the xid. 1522 */ 1523 /* ARGSUSED */ 1524 static int 1525 clnt_cots_ksettimers(CLIENT *h, struct rpc_timers *t, struct rpc_timers *all, 1526 int minimum, void (*feedback)(int, int, caddr_t), caddr_t arg, 1527 uint32_t xid) 1528 { 1529 /* LINTED pointer alignment */ 1530 cku_private_t *p = htop(h); 1531 1532 if (xid) 1533 p->cku_xid = xid; 1534 COTSRCSTAT_INCR(p->cku_stats, rctimers); 1535 return (0); 1536 } 1537 1538 extern void rpc_poptimod(struct vnode *); 1539 extern int kstr_push(struct vnode *, char *); 1540 1541 int 1542 conn_kstat_update(kstat_t *ksp, int rw) 1543 { 1544 struct cm_xprt *cm_entry; 1545 struct cm_kstat_xprt *cm_ksp_data; 1546 uchar_t *b; 1547 char *fbuf; 1548 1549 if (rw == KSTAT_WRITE) 1550 return (EACCES); 1551 if (ksp == NULL || ksp->ks_private == NULL) 1552 return (EIO); 1553 cm_entry = (struct cm_xprt *)ksp->ks_private; 1554 cm_ksp_data = (struct cm_kstat_xprt *)ksp->ks_data; 1555 1556 cm_ksp_data->x_wq.value.ui32 = (uint32_t)(uintptr_t)cm_entry->x_wq; 1557 cm_ksp_data->x_family.value.ui32 = cm_entry->x_family; 1558 cm_ksp_data->x_rdev.value.ui32 = (uint32_t)cm_entry->x_rdev; 1559 cm_ksp_data->x_time.value.ui32 = cm_entry->x_time; 1560 cm_ksp_data->x_ref.value.ui32 = cm_entry->x_ref; 1561 cm_ksp_data->x_state.value.ui32 = cm_entry->x_state_flags; 1562 1563 if (cm_entry->x_server.buf) { 1564 fbuf = cm_ksp_data->x_server.value.str.addr.ptr; 1565 if (cm_entry->x_family == AF_INET && 1566 cm_entry->x_server.len == 1567 sizeof (struct sockaddr_in)) { 1568 struct sockaddr_in *sa; 1569 sa = (struct sockaddr_in *) 1570 cm_entry->x_server.buf; 1571 b = (uchar_t *)&sa->sin_addr; 1572 (void) sprintf(fbuf, 1573 "%03d.%03d.%03d.%03d", b[0] & 0xFF, b[1] & 0xFF, 1574 b[2] & 0xFF, b[3] & 0xFF); 1575 cm_ksp_data->x_port.value.ui32 = 1576 (uint32_t)sa->sin_port; 1577 } else if (cm_entry->x_family == AF_INET6 && 1578 cm_entry->x_server.len >= 1579 sizeof (struct sockaddr_in6)) { 1580 /* extract server IP address & port */ 1581 struct sockaddr_in6 *sin6; 1582 sin6 = (struct sockaddr_in6 *)cm_entry->x_server.buf; 1583 (void) kinet_ntop6((uchar_t *)&sin6->sin6_addr, fbuf, 1584 INET6_ADDRSTRLEN); 1585 cm_ksp_data->x_port.value.ui32 = sin6->sin6_port; 1586 } else { 1587 struct sockaddr_in *sa; 1588 1589 sa = (struct sockaddr_in *)cm_entry->x_server.buf; 1590 b = (uchar_t *)&sa->sin_addr; 1591 (void) sprintf(fbuf, 1592 "%03d.%03d.%03d.%03d", b[0] & 0xFF, b[1] & 0xFF, 1593 b[2] & 0xFF, b[3] & 0xFF); 1594 } 1595 KSTAT_NAMED_STR_BUFLEN(&cm_ksp_data->x_server) = 1596 strlen(fbuf) + 1; 1597 } 1598 1599 return (0); 1600 } 1601 1602 1603 /* 1604 * We want a version of delay which is interruptible by a UNIX signal 1605 * Return EINTR if an interrupt occured. 1606 */ 1607 static int 1608 clnt_delay(clock_t ticks, bool_t nosignal) 1609 { 1610 if (nosignal == TRUE) { 1611 delay(ticks); 1612 return (0); 1613 } 1614 return (delay_sig(ticks)); 1615 } 1616 1617 /* 1618 * Wait for a connection until a timeout, or until we are 1619 * signalled that there has been a connection state change. 1620 */ 1621 static enum clnt_stat 1622 connmgr_cwait(struct cm_xprt *cm_entry, const struct timeval *waitp, 1623 bool_t nosignal) 1624 { 1625 bool_t interrupted; 1626 clock_t timout, cv_stat; 1627 enum clnt_stat clstat; 1628 unsigned int old_state; 1629 1630 ASSERT(MUTEX_HELD(&connmgr_lock)); 1631 /* 1632 * We wait for the transport connection to be made, or an 1633 * indication that it could not be made. 1634 */ 1635 clstat = RPC_TIMEDOUT; 1636 interrupted = FALSE; 1637 1638 old_state = cm_entry->x_state_flags; 1639 /* 1640 * Now loop until cv_timedwait{_sig} returns because of 1641 * a signal(0) or timeout(-1) or cv_signal(>0). But it may be 1642 * cv_signalled for various other reasons too. So loop 1643 * until there is a state change on the connection. 1644 */ 1645 1646 timout = waitp->tv_sec * drv_usectohz(1000000) + 1647 drv_usectohz(waitp->tv_usec) + lbolt; 1648 1649 if (nosignal) { 1650 while ((cv_stat = cv_timedwait(&cm_entry->x_conn_cv, 1651 &connmgr_lock, timout)) > 0 && 1652 cm_entry->x_state_flags == old_state) 1653 ; 1654 } else { 1655 while ((cv_stat = cv_timedwait_sig(&cm_entry->x_conn_cv, 1656 &connmgr_lock, timout)) > 0 && 1657 cm_entry->x_state_flags == old_state) 1658 ; 1659 1660 if (cv_stat == 0) /* got intr signal? */ 1661 interrupted = TRUE; 1662 } 1663 1664 if ((cm_entry->x_state_flags & (X_BADSTATES|X_CONNECTED)) == 1665 X_CONNECTED) { 1666 clstat = RPC_SUCCESS; 1667 } else { 1668 if (interrupted == TRUE) 1669 clstat = RPC_INTR; 1670 RPCLOG(1, "connmgr_cwait: can't connect, error: %s\n", 1671 clnt_sperrno(clstat)); 1672 } 1673 1674 return (clstat); 1675 } 1676 1677 /* 1678 * Primary interface for how RPC grabs a connection. 1679 */ 1680 static struct cm_xprt * 1681 connmgr_wrapget( 1682 struct netbuf *retryaddr, 1683 const struct timeval *waitp, 1684 cku_private_t *p) 1685 { 1686 struct cm_xprt *cm_entry; 1687 1688 cm_entry = connmgr_get(retryaddr, waitp, &p->cku_addr, p->cku_addrfmly, 1689 &p->cku_srcaddr, &p->cku_err, p->cku_device, 1690 p->cku_client.cl_nosignal, p->cku_useresvport); 1691 1692 if (cm_entry == NULL) { 1693 /* 1694 * Re-map the call status to RPC_INTR if the err code is 1695 * EINTR. This can happen if calls status is RPC_TLIERROR. 1696 * However, don't re-map if signalling has been turned off. 1697 * XXX Really need to create a separate thread whenever 1698 * there isn't an existing connection. 1699 */ 1700 if (p->cku_err.re_errno == EINTR) { 1701 if (p->cku_client.cl_nosignal == TRUE) 1702 p->cku_err.re_errno = EIO; 1703 else 1704 p->cku_err.re_status = RPC_INTR; 1705 } 1706 } 1707 1708 return (cm_entry); 1709 } 1710 1711 /* 1712 * Obtains a transport to the server specified in addr. If a suitable transport 1713 * does not already exist in the list of cached transports, a new connection 1714 * is created, connected, and added to the list. The connection is for sending 1715 * only - the reply message may come back on another transport connection. 1716 */ 1717 static struct cm_xprt * 1718 connmgr_get( 1719 struct netbuf *retryaddr, 1720 const struct timeval *waitp, /* changed to a ptr to converse stack */ 1721 struct netbuf *destaddr, 1722 int addrfmly, 1723 struct netbuf *srcaddr, 1724 struct rpc_err *rpcerr, 1725 dev_t device, 1726 bool_t nosignal, 1727 int useresvport) 1728 { 1729 struct cm_xprt *cm_entry; 1730 struct cm_xprt *lru_entry; 1731 struct cm_xprt **cmp; 1732 queue_t *wq; 1733 TIUSER *tiptr; 1734 int i; 1735 int retval; 1736 clock_t prev_time; 1737 int tidu_size; 1738 bool_t connected; 1739 zoneid_t zoneid = rpc_zoneid(); 1740 1741 /* 1742 * If the call is not a retry, look for a transport entry that 1743 * goes to the server of interest. 1744 */ 1745 mutex_enter(&connmgr_lock); 1746 1747 if (retryaddr == NULL) { 1748 use_new_conn: 1749 i = 0; 1750 cm_entry = lru_entry = NULL; 1751 prev_time = lbolt; 1752 1753 cmp = &cm_hd; 1754 while ((cm_entry = *cmp) != NULL) { 1755 ASSERT(cm_entry != cm_entry->x_next); 1756 /* 1757 * Garbage collect conections that are marked 1758 * for needs disconnect. 1759 */ 1760 if (cm_entry->x_needdis) { 1761 CONN_HOLD(cm_entry); 1762 connmgr_dis_and_wait(cm_entry); 1763 connmgr_release(cm_entry); 1764 /* 1765 * connmgr_lock could have been 1766 * dropped for the disconnect 1767 * processing so start over. 1768 */ 1769 goto use_new_conn; 1770 } 1771 1772 /* 1773 * Garbage collect the dead connections that have 1774 * no threads working on them. 1775 */ 1776 if ((cm_entry->x_state_flags & (X_DEAD|X_THREAD)) == 1777 X_DEAD) { 1778 *cmp = cm_entry->x_next; 1779 mutex_exit(&connmgr_lock); 1780 connmgr_close(cm_entry); 1781 mutex_enter(&connmgr_lock); 1782 goto use_new_conn; 1783 } 1784 1785 1786 if ((cm_entry->x_state_flags & X_BADSTATES) == 0 && 1787 cm_entry->x_zoneid == zoneid && 1788 cm_entry->x_rdev == device && 1789 destaddr->len == cm_entry->x_server.len && 1790 bcmp(destaddr->buf, cm_entry->x_server.buf, 1791 destaddr->len) == 0) { 1792 /* 1793 * If the matching entry isn't connected, 1794 * attempt to reconnect it. 1795 */ 1796 if (cm_entry->x_connected == FALSE) { 1797 /* 1798 * We don't go through trying 1799 * to find the least recently 1800 * used connected because 1801 * connmgr_reconnect() briefly 1802 * dropped the connmgr_lock, 1803 * allowing a window for our 1804 * accounting to be messed up. 1805 * In any case, a re-connected 1806 * connection is as good as 1807 * a LRU connection. 1808 */ 1809 return (connmgr_wrapconnect(cm_entry, 1810 waitp, destaddr, addrfmly, srcaddr, 1811 rpcerr, TRUE, nosignal)); 1812 } 1813 i++; 1814 if (cm_entry->x_time - prev_time <= 0 || 1815 lru_entry == NULL) { 1816 prev_time = cm_entry->x_time; 1817 lru_entry = cm_entry; 1818 } 1819 } 1820 cmp = &cm_entry->x_next; 1821 } 1822 1823 if (i > clnt_max_conns) { 1824 RPCLOG(8, "connmgr_get: too many conns, dooming entry" 1825 " %p\n", (void *)lru_entry->x_tiptr); 1826 lru_entry->x_doomed = TRUE; 1827 goto use_new_conn; 1828 } 1829 1830 /* 1831 * If we are at the maximum number of connections to 1832 * the server, hand back the least recently used one. 1833 */ 1834 if (i == clnt_max_conns) { 1835 /* 1836 * Copy into the handle the source address of 1837 * the connection, which we will use in case of 1838 * a later retry. 1839 */ 1840 if (srcaddr->len != lru_entry->x_src.len) { 1841 if (srcaddr->len > 0) 1842 kmem_free(srcaddr->buf, 1843 srcaddr->maxlen); 1844 srcaddr->buf = kmem_zalloc( 1845 lru_entry->x_src.len, KM_SLEEP); 1846 srcaddr->maxlen = srcaddr->len = 1847 lru_entry->x_src.len; 1848 } 1849 bcopy(lru_entry->x_src.buf, srcaddr->buf, srcaddr->len); 1850 RPCLOG(2, "connmgr_get: call going out on %p\n", 1851 (void *)lru_entry); 1852 lru_entry->x_time = lbolt; 1853 CONN_HOLD(lru_entry); 1854 mutex_exit(&connmgr_lock); 1855 return (lru_entry); 1856 } 1857 1858 } else { 1859 /* 1860 * This is the retry case (retryaddr != NULL). Retries must 1861 * be sent on the same source port as the original call. 1862 */ 1863 1864 /* 1865 * Walk the list looking for a connection with a source address 1866 * that matches the retry address. 1867 */ 1868 cmp = &cm_hd; 1869 while ((cm_entry = *cmp) != NULL) { 1870 ASSERT(cm_entry != cm_entry->x_next); 1871 if (zoneid != cm_entry->x_zoneid || 1872 device != cm_entry->x_rdev || 1873 retryaddr->len != cm_entry->x_src.len || 1874 bcmp(retryaddr->buf, cm_entry->x_src.buf, 1875 retryaddr->len) != 0) { 1876 cmp = &cm_entry->x_next; 1877 continue; 1878 } 1879 1880 /* 1881 * Sanity check: if the connection with our source 1882 * port is going to some other server, something went 1883 * wrong, as we never delete connections (i.e. release 1884 * ports) unless they have been idle. In this case, 1885 * it is probably better to send the call out using 1886 * a new source address than to fail it altogether, 1887 * since that port may never be released. 1888 */ 1889 if (destaddr->len != cm_entry->x_server.len || 1890 bcmp(destaddr->buf, cm_entry->x_server.buf, 1891 destaddr->len) != 0) { 1892 RPCLOG(1, "connmgr_get: tiptr %p" 1893 " is going to a different server" 1894 " with the port that belongs" 1895 " to us!\n", (void *)cm_entry->x_tiptr); 1896 retryaddr = NULL; 1897 goto use_new_conn; 1898 } 1899 1900 /* 1901 * If the connection of interest is not connected and we 1902 * can't reconnect it, then the server is probably 1903 * still down. Return NULL to the caller and let it 1904 * retry later if it wants to. We have a delay so the 1905 * machine doesn't go into a tight retry loop. If the 1906 * entry was already connected, or the reconnected was 1907 * successful, return this entry. 1908 */ 1909 if (cm_entry->x_connected == FALSE) { 1910 return (connmgr_wrapconnect(cm_entry, 1911 waitp, destaddr, addrfmly, NULL, 1912 rpcerr, TRUE, nosignal)); 1913 } else { 1914 CONN_HOLD(cm_entry); 1915 1916 cm_entry->x_time = lbolt; 1917 mutex_exit(&connmgr_lock); 1918 RPCLOG(2, "connmgr_get: found old " 1919 "transport %p for retry\n", 1920 (void *)cm_entry); 1921 return (cm_entry); 1922 } 1923 } 1924 1925 /* 1926 * We cannot find an entry in the list for this retry. 1927 * Either the entry has been removed temporarily to be 1928 * reconnected by another thread, or the original call 1929 * got a port but never got connected, 1930 * and hence the transport never got put in the 1931 * list. Fall through to the "create new connection" code - 1932 * the former case will fail there trying to rebind the port, 1933 * and the later case (and any other pathological cases) will 1934 * rebind and reconnect and not hang the client machine. 1935 */ 1936 RPCLOG0(8, "connmgr_get: no entry in list for retry\n"); 1937 } 1938 /* 1939 * Set up a transport entry in the connection manager's list. 1940 */ 1941 cm_entry = (struct cm_xprt *) 1942 kmem_zalloc(sizeof (struct cm_xprt), KM_SLEEP); 1943 1944 cm_entry->x_server.buf = kmem_zalloc(destaddr->len, KM_SLEEP); 1945 bcopy(destaddr->buf, cm_entry->x_server.buf, destaddr->len); 1946 cm_entry->x_server.len = cm_entry->x_server.maxlen = destaddr->len; 1947 1948 cm_entry->x_state_flags = X_THREAD; 1949 cm_entry->x_ref = 1; 1950 cm_entry->x_family = addrfmly; 1951 cm_entry->x_rdev = device; 1952 cm_entry->x_zoneid = zoneid; 1953 mutex_init(&cm_entry->x_lock, NULL, MUTEX_DEFAULT, NULL); 1954 cv_init(&cm_entry->x_cv, NULL, CV_DEFAULT, NULL); 1955 cv_init(&cm_entry->x_conn_cv, NULL, CV_DEFAULT, NULL); 1956 cv_init(&cm_entry->x_dis_cv, NULL, CV_DEFAULT, NULL); 1957 1958 /* 1959 * Note that we add this partially initialized entry to the 1960 * connection list. This is so that we don't have connections to 1961 * the same server. 1962 * 1963 * Note that x_src is not initialized at this point. This is because 1964 * retryaddr might be NULL in which case x_src is whatever 1965 * t_kbind/bindresvport gives us. If another thread wants a 1966 * connection to the same server, seemingly we have an issue, but we 1967 * don't. If the other thread comes in with retryaddr == NULL, then it 1968 * will never look at x_src, and it will end up waiting in 1969 * connmgr_cwait() for the first thread to finish the connection 1970 * attempt. If the other thread comes in with retryaddr != NULL, then 1971 * that means there was a request sent on a connection, in which case 1972 * the the connection should already exist. Thus the first thread 1973 * never gets here ... it finds the connection it its server in the 1974 * connection list. 1975 * 1976 * But even if theory is wrong, in the retryaddr != NULL case, the 2nd 1977 * thread will skip us because x_src.len == 0. 1978 */ 1979 cm_entry->x_next = cm_hd; 1980 cm_hd = cm_entry; 1981 mutex_exit(&connmgr_lock); 1982 1983 /* 1984 * Either we didn't find an entry to the server of interest, or we 1985 * don't have the maximum number of connections to that server - 1986 * create a new connection. 1987 */ 1988 RPCLOG0(8, "connmgr_get: creating new connection\n"); 1989 rpcerr->re_status = RPC_TLIERROR; 1990 1991 i = t_kopen(NULL, device, FREAD|FWRITE|FNDELAY, &tiptr, zone_kcred()); 1992 if (i) { 1993 RPCLOG(1, "connmgr_get: can't open cots device, error %d\n", i); 1994 rpcerr->re_errno = i; 1995 connmgr_cancelconn(cm_entry); 1996 return (NULL); 1997 } 1998 rpc_poptimod(tiptr->fp->f_vnode); 1999 2000 if (i = strioctl(tiptr->fp->f_vnode, I_PUSH, (intptr_t)"rpcmod", 0, 2001 K_TO_K, kcred, &retval)) { 2002 RPCLOG(1, "connmgr_get: can't push cots module, %d\n", i); 2003 (void) t_kclose(tiptr, 1); 2004 rpcerr->re_errno = i; 2005 connmgr_cancelconn(cm_entry); 2006 return (NULL); 2007 } 2008 2009 if (i = strioctl(tiptr->fp->f_vnode, RPC_CLIENT, 0, 0, K_TO_K, 2010 kcred, &retval)) { 2011 RPCLOG(1, "connmgr_get: can't set client status with cots " 2012 "module, %d\n", i); 2013 (void) t_kclose(tiptr, 1); 2014 rpcerr->re_errno = i; 2015 connmgr_cancelconn(cm_entry); 2016 return (NULL); 2017 } 2018 2019 mutex_enter(&connmgr_lock); 2020 2021 wq = tiptr->fp->f_vnode->v_stream->sd_wrq->q_next; 2022 cm_entry->x_wq = wq; 2023 2024 mutex_exit(&connmgr_lock); 2025 2026 if (i = strioctl(tiptr->fp->f_vnode, I_PUSH, (intptr_t)"timod", 0, 2027 K_TO_K, kcred, &retval)) { 2028 RPCLOG(1, "connmgr_get: can't push timod, %d\n", i); 2029 (void) t_kclose(tiptr, 1); 2030 rpcerr->re_errno = i; 2031 connmgr_cancelconn(cm_entry); 2032 return (NULL); 2033 } 2034 2035 /* 2036 * If the caller has not specified reserved port usage then 2037 * take the system default. 2038 */ 2039 if (useresvport == -1) 2040 useresvport = clnt_cots_do_bindresvport; 2041 2042 if ((useresvport || retryaddr != NULL) && 2043 (addrfmly == AF_INET || addrfmly == AF_INET6)) { 2044 bool_t alloc_src = FALSE; 2045 2046 if (srcaddr->len != destaddr->len) { 2047 kmem_free(srcaddr->buf, srcaddr->maxlen); 2048 srcaddr->buf = kmem_zalloc(destaddr->len, KM_SLEEP); 2049 srcaddr->maxlen = destaddr->len; 2050 srcaddr->len = destaddr->len; 2051 alloc_src = TRUE; 2052 } 2053 2054 if ((i = bindresvport(tiptr, retryaddr, srcaddr, TRUE)) != 0) { 2055 (void) t_kclose(tiptr, 1); 2056 RPCLOG(1, "connmgr_get: couldn't bind, retryaddr: " 2057 "%p\n", (void *)retryaddr); 2058 2059 /* 2060 * 1225408: If we allocated a source address, then it 2061 * is either garbage or all zeroes. In that case 2062 * we need to clear srcaddr. 2063 */ 2064 if (alloc_src == TRUE) { 2065 kmem_free(srcaddr->buf, srcaddr->maxlen); 2066 srcaddr->maxlen = srcaddr->len = 0; 2067 srcaddr->buf = NULL; 2068 } 2069 rpcerr->re_errno = i; 2070 connmgr_cancelconn(cm_entry); 2071 return (NULL); 2072 } 2073 } else { 2074 if ((i = t_kbind(tiptr, NULL, NULL)) != 0) { 2075 RPCLOG(1, "clnt_cots_kcreate: t_kbind: %d\n", i); 2076 (void) t_kclose(tiptr, 1); 2077 rpcerr->re_errno = i; 2078 connmgr_cancelconn(cm_entry); 2079 return (NULL); 2080 } 2081 } 2082 2083 { 2084 /* 2085 * Keep the kernel stack lean. Don't move this call 2086 * declaration to the top of this function because a 2087 * call is declared in connmgr_wrapconnect() 2088 */ 2089 calllist_t call; 2090 2091 bzero(&call, sizeof (call)); 2092 cv_init(&call.call_cv, NULL, CV_DEFAULT, NULL); 2093 2094 /* 2095 * This is a bound end-point so don't close it's stream. 2096 */ 2097 connected = connmgr_connect(cm_entry, wq, destaddr, addrfmly, 2098 &call, &tidu_size, FALSE, waitp, 2099 nosignal); 2100 *rpcerr = call.call_err; 2101 cv_destroy(&call.call_cv); 2102 2103 } 2104 2105 mutex_enter(&connmgr_lock); 2106 2107 /* 2108 * Set up a transport entry in the connection manager's list. 2109 */ 2110 cm_entry->x_src.buf = kmem_zalloc(srcaddr->len, KM_SLEEP); 2111 bcopy(srcaddr->buf, cm_entry->x_src.buf, srcaddr->len); 2112 cm_entry->x_src.len = cm_entry->x_src.maxlen = srcaddr->len; 2113 2114 cm_entry->x_tiptr = tiptr; 2115 cm_entry->x_time = lbolt; 2116 2117 if (tiptr->tp_info.servtype == T_COTS_ORD) 2118 cm_entry->x_ordrel = TRUE; 2119 else 2120 cm_entry->x_ordrel = FALSE; 2121 2122 cm_entry->x_tidu_size = tidu_size; 2123 2124 if (cm_entry->x_early_disc) 2125 cm_entry->x_connected = FALSE; 2126 else 2127 cm_entry->x_connected = connected; 2128 2129 /* 2130 * There could be a discrepancy here such that 2131 * x_early_disc is TRUE yet connected is TRUE as well 2132 * and the connection is actually connected. In that case 2133 * lets be conservative and declare the connection as not 2134 * connected. 2135 */ 2136 cm_entry->x_early_disc = FALSE; 2137 cm_entry->x_needdis = (cm_entry->x_connected == FALSE); 2138 cm_entry->x_ctime = lbolt; 2139 2140 /* 2141 * Notify any threads waiting that the connection attempt is done. 2142 */ 2143 cm_entry->x_thread = FALSE; 2144 cv_broadcast(&cm_entry->x_conn_cv); 2145 2146 mutex_exit(&connmgr_lock); 2147 2148 if (cm_entry->x_connected == FALSE) { 2149 connmgr_release(cm_entry); 2150 return (NULL); 2151 } 2152 return (cm_entry); 2153 } 2154 2155 /* 2156 * Keep the cm_xprt entry on the connecton list when making a connection. This 2157 * is to prevent multiple connections to a slow server from appearing. 2158 * We use the bit field x_thread to tell if a thread is doing a connection 2159 * which keeps other interested threads from messing with connection. 2160 * Those other threads just wait if x_thread is set. 2161 * 2162 * If x_thread is not set, then we do the actual work of connecting via 2163 * connmgr_connect(). 2164 * 2165 * mutex convention: called with connmgr_lock held, returns with it released. 2166 */ 2167 static struct cm_xprt * 2168 connmgr_wrapconnect( 2169 struct cm_xprt *cm_entry, 2170 const struct timeval *waitp, 2171 struct netbuf *destaddr, 2172 int addrfmly, 2173 struct netbuf *srcaddr, 2174 struct rpc_err *rpcerr, 2175 bool_t reconnect, 2176 bool_t nosignal) 2177 { 2178 ASSERT(MUTEX_HELD(&connmgr_lock)); 2179 /* 2180 * Hold this entry as we are about to drop connmgr_lock. 2181 */ 2182 CONN_HOLD(cm_entry); 2183 2184 /* 2185 * If there is a thread already making a connection for us, then 2186 * wait for it to complete the connection. 2187 */ 2188 if (cm_entry->x_thread == TRUE) { 2189 rpcerr->re_status = connmgr_cwait(cm_entry, waitp, nosignal); 2190 2191 if (rpcerr->re_status != RPC_SUCCESS) { 2192 mutex_exit(&connmgr_lock); 2193 connmgr_release(cm_entry); 2194 return (NULL); 2195 } 2196 } else { 2197 bool_t connected; 2198 calllist_t call; 2199 2200 cm_entry->x_thread = TRUE; 2201 2202 while (cm_entry->x_needrel == TRUE) { 2203 cm_entry->x_needrel = FALSE; 2204 2205 connmgr_sndrel(cm_entry); 2206 delay(drv_usectohz(1000000)); 2207 2208 mutex_enter(&connmgr_lock); 2209 } 2210 2211 /* 2212 * If we need to send a T_DISCON_REQ, send one. 2213 */ 2214 connmgr_dis_and_wait(cm_entry); 2215 2216 mutex_exit(&connmgr_lock); 2217 2218 bzero(&call, sizeof (call)); 2219 cv_init(&call.call_cv, NULL, CV_DEFAULT, NULL); 2220 2221 connected = connmgr_connect(cm_entry, cm_entry->x_wq, 2222 destaddr, addrfmly, &call, 2223 &cm_entry->x_tidu_size, 2224 reconnect, waitp, nosignal); 2225 2226 *rpcerr = call.call_err; 2227 cv_destroy(&call.call_cv); 2228 2229 mutex_enter(&connmgr_lock); 2230 2231 2232 if (cm_entry->x_early_disc) 2233 cm_entry->x_connected = FALSE; 2234 else 2235 cm_entry->x_connected = connected; 2236 2237 /* 2238 * There could be a discrepancy here such that 2239 * x_early_disc is TRUE yet connected is TRUE as well 2240 * and the connection is actually connected. In that case 2241 * lets be conservative and declare the connection as not 2242 * connected. 2243 */ 2244 2245 cm_entry->x_early_disc = FALSE; 2246 cm_entry->x_needdis = (cm_entry->x_connected == FALSE); 2247 2248 2249 /* 2250 * connmgr_connect() may have given up before the connection 2251 * actually timed out. So ensure that before the next 2252 * connection attempt we do a disconnect. 2253 */ 2254 cm_entry->x_ctime = lbolt; 2255 cm_entry->x_thread = FALSE; 2256 2257 cv_broadcast(&cm_entry->x_conn_cv); 2258 2259 if (cm_entry->x_connected == FALSE) { 2260 mutex_exit(&connmgr_lock); 2261 connmgr_release(cm_entry); 2262 return (NULL); 2263 } 2264 } 2265 2266 if (srcaddr != NULL) { 2267 /* 2268 * Copy into the handle the 2269 * source address of the 2270 * connection, which we will use 2271 * in case of a later retry. 2272 */ 2273 if (srcaddr->len != cm_entry->x_src.len) { 2274 if (srcaddr->maxlen > 0) 2275 kmem_free(srcaddr->buf, srcaddr->maxlen); 2276 srcaddr->buf = kmem_zalloc(cm_entry->x_src.len, 2277 KM_SLEEP); 2278 srcaddr->maxlen = srcaddr->len = 2279 cm_entry->x_src.len; 2280 } 2281 bcopy(cm_entry->x_src.buf, srcaddr->buf, srcaddr->len); 2282 } 2283 cm_entry->x_time = lbolt; 2284 mutex_exit(&connmgr_lock); 2285 return (cm_entry); 2286 } 2287 2288 /* 2289 * If we need to send a T_DISCON_REQ, send one. 2290 */ 2291 static void 2292 connmgr_dis_and_wait(struct cm_xprt *cm_entry) 2293 { 2294 ASSERT(MUTEX_HELD(&connmgr_lock)); 2295 for (;;) { 2296 while (cm_entry->x_needdis == TRUE) { 2297 RPCLOG(8, "connmgr_dis_and_wait: need " 2298 "T_DISCON_REQ for connection 0x%p\n", 2299 (void *)cm_entry); 2300 cm_entry->x_needdis = FALSE; 2301 cm_entry->x_waitdis = TRUE; 2302 2303 connmgr_snddis(cm_entry); 2304 2305 mutex_enter(&connmgr_lock); 2306 } 2307 2308 if (cm_entry->x_waitdis == TRUE) { 2309 clock_t curlbolt; 2310 clock_t timout; 2311 2312 RPCLOG(8, "connmgr_dis_and_wait waiting for " 2313 "T_DISCON_REQ's ACK for connection %p\n", 2314 (void *)cm_entry); 2315 curlbolt = ddi_get_lbolt(); 2316 2317 timout = clnt_cots_min_conntout * 2318 drv_usectohz(1000000) + curlbolt; 2319 2320 /* 2321 * The TPI spec says that the T_DISCON_REQ 2322 * will get acknowledged, but in practice 2323 * the ACK may never get sent. So don't 2324 * block forever. 2325 */ 2326 (void) cv_timedwait(&cm_entry->x_dis_cv, 2327 &connmgr_lock, timout); 2328 } 2329 /* 2330 * If we got the ACK, break. If we didn't, 2331 * then send another T_DISCON_REQ. 2332 */ 2333 if (cm_entry->x_waitdis == FALSE) { 2334 break; 2335 } else { 2336 RPCLOG(8, "connmgr_dis_and_wait: did" 2337 "not get T_DISCON_REQ's ACK for " 2338 "connection %p\n", (void *)cm_entry); 2339 cm_entry->x_needdis = TRUE; 2340 } 2341 } 2342 } 2343 2344 static void 2345 connmgr_cancelconn(struct cm_xprt *cm_entry) 2346 { 2347 /* 2348 * Mark the connection table entry as dead; the next thread that 2349 * goes through connmgr_release() will notice this and deal with it. 2350 */ 2351 mutex_enter(&connmgr_lock); 2352 cm_entry->x_dead = TRUE; 2353 2354 /* 2355 * Notify any threads waiting for the connection that it isn't 2356 * going to happen. 2357 */ 2358 cm_entry->x_thread = FALSE; 2359 cv_broadcast(&cm_entry->x_conn_cv); 2360 mutex_exit(&connmgr_lock); 2361 2362 connmgr_release(cm_entry); 2363 } 2364 2365 static void 2366 connmgr_close(struct cm_xprt *cm_entry) 2367 { 2368 mutex_enter(&cm_entry->x_lock); 2369 while (cm_entry->x_ref != 0) { 2370 /* 2371 * Must be a noninterruptible wait. 2372 */ 2373 cv_wait(&cm_entry->x_cv, &cm_entry->x_lock); 2374 } 2375 2376 if (cm_entry->x_tiptr != NULL) 2377 (void) t_kclose(cm_entry->x_tiptr, 1); 2378 2379 mutex_exit(&cm_entry->x_lock); 2380 if (cm_entry->x_ksp != NULL) { 2381 mutex_enter(&connmgr_lock); 2382 cm_entry->x_ksp->ks_private = NULL; 2383 mutex_exit(&connmgr_lock); 2384 2385 /* 2386 * Must free the buffer we allocated for the 2387 * server address in the update function 2388 */ 2389 if (((struct cm_kstat_xprt *)(cm_entry->x_ksp->ks_data))-> 2390 x_server.value.str.addr.ptr != NULL) 2391 kmem_free(((struct cm_kstat_xprt *)(cm_entry->x_ksp-> 2392 ks_data))->x_server.value.str.addr.ptr, 2393 INET6_ADDRSTRLEN); 2394 kmem_free(cm_entry->x_ksp->ks_data, 2395 cm_entry->x_ksp->ks_data_size); 2396 kstat_delete(cm_entry->x_ksp); 2397 } 2398 2399 mutex_destroy(&cm_entry->x_lock); 2400 cv_destroy(&cm_entry->x_cv); 2401 cv_destroy(&cm_entry->x_conn_cv); 2402 cv_destroy(&cm_entry->x_dis_cv); 2403 2404 if (cm_entry->x_server.buf != NULL) 2405 kmem_free(cm_entry->x_server.buf, cm_entry->x_server.maxlen); 2406 if (cm_entry->x_src.buf != NULL) 2407 kmem_free(cm_entry->x_src.buf, cm_entry->x_src.maxlen); 2408 kmem_free(cm_entry, sizeof (struct cm_xprt)); 2409 } 2410 2411 /* 2412 * Called by KRPC after sending the call message to release the connection 2413 * it was using. 2414 */ 2415 static void 2416 connmgr_release(struct cm_xprt *cm_entry) 2417 { 2418 mutex_enter(&cm_entry->x_lock); 2419 cm_entry->x_ref--; 2420 if (cm_entry->x_ref == 0) 2421 cv_signal(&cm_entry->x_cv); 2422 mutex_exit(&cm_entry->x_lock); 2423 } 2424 2425 /* 2426 * Given an open stream, connect to the remote. Returns true if connected, 2427 * false otherwise. 2428 */ 2429 static bool_t 2430 connmgr_connect( 2431 struct cm_xprt *cm_entry, 2432 queue_t *wq, 2433 struct netbuf *addr, 2434 int addrfmly, 2435 calllist_t *e, 2436 int *tidu_ptr, 2437 bool_t reconnect, 2438 const struct timeval *waitp, 2439 bool_t nosignal) 2440 { 2441 mblk_t *mp; 2442 struct T_conn_req *tcr; 2443 struct T_info_ack *tinfo; 2444 int interrupted, error; 2445 int tidu_size, kstat_instance; 2446 2447 /* if it's a reconnect, flush any lingering data messages */ 2448 if (reconnect) 2449 (void) putctl1(wq, M_FLUSH, FLUSHRW); 2450 2451 mp = allocb(sizeof (*tcr) + addr->len, BPRI_LO); 2452 if (mp == NULL) { 2453 /* 2454 * This is unfortunate, but we need to look up the stats for 2455 * this zone to increment the "memory allocation failed" 2456 * counter. curproc->p_zone is safe since we're initiating a 2457 * connection and not in some strange streams context. 2458 */ 2459 struct rpcstat *rpcstat; 2460 2461 rpcstat = zone_getspecific(rpcstat_zone_key, rpc_zone()); 2462 ASSERT(rpcstat != NULL); 2463 2464 RPCLOG0(1, "connmgr_connect: cannot alloc mp for " 2465 "sending conn request\n"); 2466 COTSRCSTAT_INCR(rpcstat->rpc_cots_client, rcnomem); 2467 e->call_status = RPC_SYSTEMERROR; 2468 e->call_reason = ENOSR; 2469 return (FALSE); 2470 } 2471 2472 mp->b_datap->db_type = M_PROTO; 2473 tcr = (struct T_conn_req *)mp->b_rptr; 2474 bzero(tcr, sizeof (*tcr)); 2475 tcr->PRIM_type = T_CONN_REQ; 2476 tcr->DEST_length = addr->len; 2477 tcr->DEST_offset = sizeof (struct T_conn_req); 2478 mp->b_wptr = mp->b_rptr + sizeof (*tcr); 2479 2480 bcopy(addr->buf, mp->b_wptr, tcr->DEST_length); 2481 mp->b_wptr += tcr->DEST_length; 2482 2483 RPCLOG(8, "connmgr_connect: sending conn request on queue " 2484 "%p", (void *)wq); 2485 RPCLOG(8, " call %p\n", (void *)wq); 2486 /* 2487 * We use the entry in the handle that is normally used for 2488 * waiting for RPC replies to wait for the connection accept. 2489 */ 2490 clnt_dispatch_send(wq, mp, e, 0, 0); 2491 2492 mutex_enter(&clnt_pending_lock); 2493 2494 /* 2495 * We wait for the transport connection to be made, or an 2496 * indication that it could not be made. 2497 */ 2498 interrupted = 0; 2499 2500 /* 2501 * waitforack should have been called with T_OK_ACK, but the 2502 * present implementation needs to be passed T_INFO_ACK to 2503 * work correctly. 2504 */ 2505 error = waitforack(e, T_INFO_ACK, waitp, nosignal); 2506 if (error == EINTR) 2507 interrupted = 1; 2508 if (zone_status_get(curproc->p_zone) >= ZONE_IS_EMPTY) { 2509 /* 2510 * No time to lose; we essentially have been signaled to 2511 * quit. 2512 */ 2513 interrupted = 1; 2514 } 2515 #ifdef RPCDEBUG 2516 if (error == ETIME) 2517 RPCLOG0(8, "connmgr_connect: giving up " 2518 "on connection attempt; " 2519 "clnt_dispatch notifyconn " 2520 "diagnostic 'no one waiting for " 2521 "connection' should not be " 2522 "unexpected\n"); 2523 #endif 2524 if (e->call_prev) 2525 e->call_prev->call_next = e->call_next; 2526 else 2527 clnt_pending = e->call_next; 2528 if (e->call_next) 2529 e->call_next->call_prev = e->call_prev; 2530 mutex_exit(&clnt_pending_lock); 2531 2532 if (e->call_status != RPC_SUCCESS || error != 0) { 2533 if (interrupted) 2534 e->call_status = RPC_INTR; 2535 else if (error == ETIME) 2536 e->call_status = RPC_TIMEDOUT; 2537 else if (error == EPROTO) 2538 e->call_status = RPC_SYSTEMERROR; 2539 2540 RPCLOG(8, "connmgr_connect: can't connect, status: " 2541 "%s\n", clnt_sperrno(e->call_status)); 2542 2543 if (e->call_reply) { 2544 freemsg(e->call_reply); 2545 e->call_reply = NULL; 2546 } 2547 2548 return (FALSE); 2549 } 2550 /* 2551 * The result of the "connection accept" is a T_info_ack 2552 * in the call_reply field. 2553 */ 2554 ASSERT(e->call_reply != NULL); 2555 mp = e->call_reply; 2556 e->call_reply = NULL; 2557 tinfo = (struct T_info_ack *)mp->b_rptr; 2558 2559 tidu_size = tinfo->TIDU_size; 2560 tidu_size -= (tidu_size % BYTES_PER_XDR_UNIT); 2561 if (tidu_size > COTS_DEFAULT_ALLOCSIZE || (tidu_size <= 0)) 2562 tidu_size = COTS_DEFAULT_ALLOCSIZE; 2563 *tidu_ptr = tidu_size; 2564 2565 freemsg(mp); 2566 2567 /* 2568 * Set up the pertinent options. NODELAY is so the transport doesn't 2569 * buffer up RPC messages on either end. This may not be valid for 2570 * all transports. Failure to set this option is not cause to 2571 * bail out so we return success anyway. Note that lack of NODELAY 2572 * or some other way to flush the message on both ends will cause 2573 * lots of retries and terrible performance. 2574 */ 2575 if (addrfmly == AF_INET || addrfmly == AF_INET6) { 2576 (void) connmgr_setopt(wq, IPPROTO_TCP, TCP_NODELAY, e); 2577 if (e->call_status == RPC_XPRTFAILED) 2578 return (FALSE); 2579 } 2580 2581 /* 2582 * Since we have a connection, we now need to figure out if 2583 * we need to create a kstat. If x_ksp is not NULL then we 2584 * are reusing a connection and so we do not need to create 2585 * another kstat -- lets just return. 2586 */ 2587 if (cm_entry->x_ksp != NULL) 2588 return (TRUE); 2589 2590 /* 2591 * We need to increment rpc_kstat_instance atomically to prevent 2592 * two kstats being created with the same instance. 2593 */ 2594 kstat_instance = atomic_add_32_nv((uint32_t *)&rpc_kstat_instance, 1); 2595 2596 if ((cm_entry->x_ksp = kstat_create_zone("unix", kstat_instance, 2597 "rpc_cots_connections", "rpc", KSTAT_TYPE_NAMED, 2598 (uint_t)(sizeof (cm_kstat_xprt_t) / sizeof (kstat_named_t)), 2599 KSTAT_FLAG_VIRTUAL, cm_entry->x_zoneid)) == NULL) { 2600 return (TRUE); 2601 } 2602 2603 cm_entry->x_ksp->ks_lock = &connmgr_lock; 2604 cm_entry->x_ksp->ks_private = cm_entry; 2605 cm_entry->x_ksp->ks_data_size = ((INET6_ADDRSTRLEN * sizeof (char)) 2606 + sizeof (cm_kstat_template)); 2607 cm_entry->x_ksp->ks_data = kmem_alloc(cm_entry->x_ksp->ks_data_size, 2608 KM_SLEEP); 2609 bcopy(&cm_kstat_template, cm_entry->x_ksp->ks_data, 2610 cm_entry->x_ksp->ks_data_size); 2611 ((struct cm_kstat_xprt *)(cm_entry->x_ksp->ks_data))-> 2612 x_server.value.str.addr.ptr = 2613 kmem_alloc(INET6_ADDRSTRLEN, KM_SLEEP); 2614 2615 cm_entry->x_ksp->ks_update = conn_kstat_update; 2616 kstat_install(cm_entry->x_ksp); 2617 return (TRUE); 2618 } 2619 2620 /* 2621 * Called by connmgr_connect to set an option on the new stream. 2622 */ 2623 static bool_t 2624 connmgr_setopt(queue_t *wq, int level, int name, calllist_t *e) 2625 { 2626 mblk_t *mp; 2627 struct opthdr *opt; 2628 struct T_optmgmt_req *tor; 2629 struct timeval waitp; 2630 int error; 2631 2632 mp = allocb(sizeof (struct T_optmgmt_req) + sizeof (struct opthdr) + 2633 sizeof (int), BPRI_LO); 2634 if (mp == NULL) { 2635 RPCLOG0(1, "connmgr_setopt: cannot alloc mp for option " 2636 "request\n"); 2637 return (FALSE); 2638 } 2639 2640 mp->b_datap->db_type = M_PROTO; 2641 tor = (struct T_optmgmt_req *)(mp->b_rptr); 2642 tor->PRIM_type = T_SVR4_OPTMGMT_REQ; 2643 tor->MGMT_flags = T_NEGOTIATE; 2644 tor->OPT_length = sizeof (struct opthdr) + sizeof (int); 2645 tor->OPT_offset = sizeof (struct T_optmgmt_req); 2646 2647 opt = (struct opthdr *)(mp->b_rptr + sizeof (struct T_optmgmt_req)); 2648 opt->level = level; 2649 opt->name = name; 2650 opt->len = sizeof (int); 2651 *(int *)((char *)opt + sizeof (*opt)) = 1; 2652 mp->b_wptr += sizeof (struct T_optmgmt_req) + sizeof (struct opthdr) + 2653 sizeof (int); 2654 2655 /* 2656 * We will use this connection regardless 2657 * of whether or not the option is settable. 2658 */ 2659 clnt_dispatch_send(wq, mp, e, 0, 0); 2660 mutex_enter(&clnt_pending_lock); 2661 2662 waitp.tv_sec = clnt_cots_min_conntout; 2663 waitp.tv_usec = 0; 2664 error = waitforack(e, T_OPTMGMT_ACK, &waitp, 1); 2665 2666 if (e->call_prev) 2667 e->call_prev->call_next = e->call_next; 2668 else 2669 clnt_pending = e->call_next; 2670 if (e->call_next) 2671 e->call_next->call_prev = e->call_prev; 2672 mutex_exit(&clnt_pending_lock); 2673 2674 if (e->call_reply != NULL) { 2675 freemsg(e->call_reply); 2676 e->call_reply = NULL; 2677 } 2678 2679 if (e->call_status != RPC_SUCCESS || error != 0) { 2680 RPCLOG(1, "connmgr_setopt: can't set option: %d\n", name); 2681 return (FALSE); 2682 } 2683 RPCLOG(8, "connmgr_setopt: successfully set option: %d\n", name); 2684 return (TRUE); 2685 } 2686 2687 #ifdef DEBUG 2688 2689 /* 2690 * This is a knob to let us force code coverage in allocation failure 2691 * case. 2692 */ 2693 static int connmgr_failsnd; 2694 #define CONN_SND_ALLOC(Size, Pri) \ 2695 ((connmgr_failsnd-- > 0) ? NULL : allocb(Size, Pri)) 2696 2697 #else 2698 2699 #define CONN_SND_ALLOC(Size, Pri) allocb(Size, Pri) 2700 2701 #endif 2702 2703 /* 2704 * Sends an orderly release on the specified queue. 2705 * Entered with connmgr_lock. Exited without connmgr_lock 2706 */ 2707 static void 2708 connmgr_sndrel(struct cm_xprt *cm_entry) 2709 { 2710 struct T_ordrel_req *torr; 2711 mblk_t *mp; 2712 queue_t *q = cm_entry->x_wq; 2713 ASSERT(MUTEX_HELD(&connmgr_lock)); 2714 mp = CONN_SND_ALLOC(sizeof (struct T_ordrel_req), BPRI_LO); 2715 if (mp == NULL) { 2716 cm_entry->x_needrel = TRUE; 2717 mutex_exit(&connmgr_lock); 2718 RPCLOG(1, "connmgr_sndrel: cannot alloc mp for sending ordrel " 2719 "to queue %p\n", (void *)q); 2720 return; 2721 } 2722 mutex_exit(&connmgr_lock); 2723 2724 mp->b_datap->db_type = M_PROTO; 2725 torr = (struct T_ordrel_req *)(mp->b_rptr); 2726 torr->PRIM_type = T_ORDREL_REQ; 2727 mp->b_wptr = mp->b_rptr + sizeof (struct T_ordrel_req); 2728 2729 RPCLOG(8, "connmgr_sndrel: sending ordrel to queue %p\n", (void *)q); 2730 put(q, mp); 2731 } 2732 2733 /* 2734 * Sends an disconnect on the specified queue. 2735 * Entered with connmgr_lock. Exited without connmgr_lock 2736 */ 2737 static void 2738 connmgr_snddis(struct cm_xprt *cm_entry) 2739 { 2740 struct T_discon_req *tdis; 2741 mblk_t *mp; 2742 queue_t *q = cm_entry->x_wq; 2743 2744 ASSERT(MUTEX_HELD(&connmgr_lock)); 2745 mp = CONN_SND_ALLOC(sizeof (*tdis), BPRI_LO); 2746 if (mp == NULL) { 2747 cm_entry->x_needdis = TRUE; 2748 mutex_exit(&connmgr_lock); 2749 RPCLOG(1, "connmgr_snddis: cannot alloc mp for sending discon " 2750 "to queue %p\n", (void *)q); 2751 return; 2752 } 2753 mutex_exit(&connmgr_lock); 2754 2755 mp->b_datap->db_type = M_PROTO; 2756 tdis = (struct T_discon_req *)mp->b_rptr; 2757 tdis->PRIM_type = T_DISCON_REQ; 2758 mp->b_wptr = mp->b_rptr + sizeof (*tdis); 2759 2760 RPCLOG(8, "connmgr_snddis: sending discon to queue %p\n", (void *)q); 2761 put(q, mp); 2762 } 2763 2764 /* 2765 * Sets up the entry for receiving replies, and calls rpcmod's write put proc 2766 * (through put) to send the call. 2767 */ 2768 static void 2769 clnt_dispatch_send(queue_t *q, mblk_t *mp, calllist_t *e, uint_t xid, 2770 uint_t queue_flag) 2771 { 2772 ASSERT(e != NULL); 2773 2774 e->call_status = RPC_TIMEDOUT; /* optimistic, eh? */ 2775 e->call_reason = 0; 2776 e->call_wq = q; 2777 e->call_xid = xid; 2778 e->call_notified = FALSE; 2779 2780 /* 2781 * If queue_flag is set then the calllist_t is already on the hash 2782 * queue. In this case just send the message and return. 2783 */ 2784 if (queue_flag) { 2785 put(q, mp); 2786 return; 2787 } 2788 2789 /* 2790 * Set up calls for RPC requests (with XID != 0) on the hash 2791 * queue for fast lookups and place other calls (i.e. 2792 * connection management) on the linked list. 2793 */ 2794 if (xid != 0) { 2795 RPCLOG(64, "clnt_dispatch_send: putting xid 0x%x on " 2796 "dispatch list\n", xid); 2797 e->call_hash = call_hash(xid, clnt_cots_hash_size); 2798 e->call_bucket = &cots_call_ht[e->call_hash]; 2799 call_table_enter(e); 2800 } else { 2801 mutex_enter(&clnt_pending_lock); 2802 if (clnt_pending) 2803 clnt_pending->call_prev = e; 2804 e->call_next = clnt_pending; 2805 e->call_prev = NULL; 2806 clnt_pending = e; 2807 mutex_exit(&clnt_pending_lock); 2808 } 2809 2810 put(q, mp); 2811 } 2812 2813 /* 2814 * Called by rpcmod to notify a client with a clnt_pending call that its reply 2815 * has arrived. If we can't find a client waiting for this reply, we log 2816 * the error and return. 2817 */ 2818 bool_t 2819 clnt_dispatch_notify(mblk_t *mp, zoneid_t zoneid) 2820 { 2821 calllist_t *e = NULL; 2822 call_table_t *chtp; 2823 uint32_t xid; 2824 uint_t hash; 2825 2826 if ((IS_P2ALIGNED(mp->b_rptr, sizeof (uint32_t))) && 2827 (mp->b_wptr - mp->b_rptr) >= sizeof (xid)) 2828 xid = *((uint32_t *)mp->b_rptr); 2829 else { 2830 int i = 0; 2831 unsigned char *p = (unsigned char *)&xid; 2832 unsigned char *rptr; 2833 mblk_t *tmp = mp; 2834 2835 /* 2836 * Copy the xid, byte-by-byte into xid. 2837 */ 2838 while (tmp) { 2839 rptr = tmp->b_rptr; 2840 while (rptr < tmp->b_wptr) { 2841 *p++ = *rptr++; 2842 if (++i >= sizeof (xid)) 2843 goto done_xid_copy; 2844 } 2845 tmp = tmp->b_cont; 2846 } 2847 2848 /* 2849 * If we got here, we ran out of mblk space before the 2850 * xid could be copied. 2851 */ 2852 ASSERT(tmp == NULL && i < sizeof (xid)); 2853 2854 RPCLOG0(1, 2855 "clnt_dispatch_notify: message less than size of xid\n"); 2856 return (FALSE); 2857 2858 } 2859 done_xid_copy: 2860 2861 hash = call_hash(xid, clnt_cots_hash_size); 2862 chtp = &cots_call_ht[hash]; 2863 /* call_table_find returns with the hash bucket locked */ 2864 call_table_find(chtp, xid, e); 2865 2866 if (e != NULL) { 2867 /* 2868 * Found thread waiting for this reply 2869 */ 2870 mutex_enter(&e->call_lock); 2871 if (e->call_reply) 2872 /* 2873 * This can happen under the following scenario: 2874 * clnt_cots_kcallit() times out on the response, 2875 * rfscall() repeats the CLNT_CALL() with 2876 * the same xid, clnt_cots_kcallit() sends the retry, 2877 * thereby putting the clnt handle on the pending list, 2878 * the first response arrives, signalling the thread 2879 * in clnt_cots_kcallit(). Before that thread is 2880 * dispatched, the second response arrives as well, 2881 * and clnt_dispatch_notify still finds the handle on 2882 * the pending list, with call_reply set. So free the 2883 * old reply now. 2884 * 2885 * It is also possible for a response intended for 2886 * an RPC call with a different xid to reside here. 2887 * This can happen if the thread that owned this 2888 * client handle prior to the current owner bailed 2889 * out and left its call record on the dispatch 2890 * queue. A window exists where the response can 2891 * arrive before the current owner dispatches its 2892 * RPC call. 2893 * 2894 * In any case, this is the very last point where we 2895 * can safely check the call_reply field before 2896 * placing the new response there. 2897 */ 2898 freemsg(e->call_reply); 2899 e->call_reply = mp; 2900 e->call_status = RPC_SUCCESS; 2901 e->call_notified = TRUE; 2902 cv_signal(&e->call_cv); 2903 mutex_exit(&e->call_lock); 2904 mutex_exit(&chtp->ct_lock); 2905 return (TRUE); 2906 } else { 2907 zone_t *zone; 2908 struct rpcstat *rpcstat; 2909 2910 mutex_exit(&chtp->ct_lock); 2911 RPCLOG(65, "clnt_dispatch_notify: no caller for reply 0x%x\n", 2912 xid); 2913 /* 2914 * This is unfortunate, but we need to lookup the zone so we 2915 * can increment its "rcbadxids" counter. 2916 */ 2917 zone = zone_find_by_id(zoneid); 2918 if (zone == NULL) { 2919 /* 2920 * The zone went away... 2921 */ 2922 return (FALSE); 2923 } 2924 rpcstat = zone_getspecific(rpcstat_zone_key, zone); 2925 if (zone_status_get(zone) >= ZONE_IS_SHUTTING_DOWN) { 2926 /* 2927 * Not interested 2928 */ 2929 zone_rele(zone); 2930 return (FALSE); 2931 } 2932 COTSRCSTAT_INCR(rpcstat->rpc_cots_client, rcbadxids); 2933 zone_rele(zone); 2934 } 2935 return (FALSE); 2936 } 2937 2938 /* 2939 * Called by rpcmod when a non-data indication arrives. The ones in which we 2940 * are interested are connection indications and options acks. We dispatch 2941 * based on the queue the indication came in on. If we are not interested in 2942 * what came in, we return false to rpcmod, who will then pass it upstream. 2943 */ 2944 bool_t 2945 clnt_dispatch_notifyconn(queue_t *q, mblk_t *mp) 2946 { 2947 calllist_t *e; 2948 int type; 2949 2950 ASSERT((q->q_flag & QREADR) == 0); 2951 2952 type = ((union T_primitives *)mp->b_rptr)->type; 2953 RPCLOG(8, "clnt_dispatch_notifyconn: prim type: [%s]\n", 2954 rpc_tpiprim2name(type)); 2955 mutex_enter(&clnt_pending_lock); 2956 for (e = clnt_pending; /* NO CONDITION */; e = e->call_next) { 2957 if (e == NULL) { 2958 mutex_exit(&clnt_pending_lock); 2959 RPCLOG(1, "clnt_dispatch_notifyconn: no one waiting " 2960 "for connection on queue 0x%p\n", (void *)q); 2961 return (FALSE); 2962 } 2963 if (e->call_wq == q) 2964 break; 2965 } 2966 2967 switch (type) { 2968 case T_CONN_CON: 2969 /* 2970 * The transport is now connected, send a T_INFO_REQ to get 2971 * the tidu size. 2972 */ 2973 mutex_exit(&clnt_pending_lock); 2974 ASSERT(mp->b_datap->db_lim - mp->b_datap->db_base >= 2975 sizeof (struct T_info_req)); 2976 mp->b_rptr = mp->b_datap->db_base; 2977 ((union T_primitives *)mp->b_rptr)->type = T_INFO_REQ; 2978 mp->b_wptr = mp->b_rptr + sizeof (struct T_info_req); 2979 mp->b_datap->db_type = M_PCPROTO; 2980 put(q, mp); 2981 return (TRUE); 2982 case T_INFO_ACK: 2983 case T_OPTMGMT_ACK: 2984 e->call_status = RPC_SUCCESS; 2985 e->call_reply = mp; 2986 e->call_notified = TRUE; 2987 cv_signal(&e->call_cv); 2988 break; 2989 case T_ERROR_ACK: 2990 e->call_status = RPC_CANTCONNECT; 2991 e->call_reply = mp; 2992 e->call_notified = TRUE; 2993 cv_signal(&e->call_cv); 2994 break; 2995 case T_OK_ACK: 2996 /* 2997 * Great, but we are really waiting for a T_CONN_CON 2998 */ 2999 freemsg(mp); 3000 break; 3001 default: 3002 mutex_exit(&clnt_pending_lock); 3003 RPCLOG(1, "clnt_dispatch_notifyconn: bad type %d\n", type); 3004 return (FALSE); 3005 } 3006 3007 mutex_exit(&clnt_pending_lock); 3008 return (TRUE); 3009 } 3010 3011 /* 3012 * Called by rpcmod when the transport is (or should be) going away. Informs 3013 * all callers waiting for replies and marks the entry in the connection 3014 * manager's list as unconnected, and either closing (close handshake in 3015 * progress) or dead. 3016 */ 3017 void 3018 clnt_dispatch_notifyall(queue_t *q, int32_t msg_type, int32_t reason) 3019 { 3020 calllist_t *e; 3021 call_table_t *ctp; 3022 struct cm_xprt *cm_entry; 3023 int have_connmgr_lock; 3024 int i; 3025 3026 ASSERT((q->q_flag & QREADR) == 0); 3027 3028 RPCLOG(1, "clnt_dispatch_notifyall on queue %p", (void *)q); 3029 RPCLOG(1, " received a notifcation prim type [%s]", 3030 rpc_tpiprim2name(msg_type)); 3031 RPCLOG(1, " and reason %d\n", reason); 3032 3033 /* 3034 * Find the transport entry in the connection manager's list, close 3035 * the transport and delete the entry. In the case where rpcmod's 3036 * idle timer goes off, it sends us a T_ORDREL_REQ, indicating we 3037 * should gracefully close the connection. 3038 */ 3039 have_connmgr_lock = 1; 3040 mutex_enter(&connmgr_lock); 3041 for (cm_entry = cm_hd; cm_entry; cm_entry = cm_entry->x_next) { 3042 ASSERT(cm_entry != cm_entry->x_next); 3043 if (cm_entry->x_wq == q) { 3044 ASSERT(MUTEX_HELD(&connmgr_lock)); 3045 ASSERT(have_connmgr_lock == 1); 3046 switch (msg_type) { 3047 case T_ORDREL_REQ: 3048 3049 if (cm_entry->x_dead) { 3050 RPCLOG(1, "idle timeout on dead " 3051 "connection: %p\n", 3052 (void *)cm_entry); 3053 if (clnt_stop_idle != NULL) 3054 (*clnt_stop_idle)(q); 3055 break; 3056 } 3057 3058 /* 3059 * Only mark the connection as dead if it is 3060 * connected and idle. 3061 * An unconnected connection has probably 3062 * gone idle because the server is down, 3063 * and when it comes back up there will be 3064 * retries that need to use that connection. 3065 */ 3066 if (cm_entry->x_connected || 3067 cm_entry->x_doomed) { 3068 if (cm_entry->x_ordrel) { 3069 if (cm_entry->x_closing == TRUE) { 3070 /* 3071 * The connection is obviously 3072 * wedged due to a bug or problem 3073 * with the transport. Mark it 3074 * as dead. Otherwise we can leak 3075 * connections. 3076 */ 3077 cm_entry->x_dead = TRUE; 3078 mutex_exit(&connmgr_lock); 3079 have_connmgr_lock = 0; 3080 if (clnt_stop_idle != NULL) 3081 (*clnt_stop_idle)(q); 3082 break; 3083 } 3084 cm_entry->x_closing = TRUE; 3085 connmgr_sndrel(cm_entry); 3086 have_connmgr_lock = 0; 3087 } else { 3088 cm_entry->x_dead = TRUE; 3089 mutex_exit(&connmgr_lock); 3090 have_connmgr_lock = 0; 3091 if (clnt_stop_idle != NULL) 3092 (*clnt_stop_idle)(q); 3093 } 3094 } else { 3095 /* 3096 * We don't mark the connection 3097 * as dead, but we turn off the 3098 * idle timer. 3099 */ 3100 mutex_exit(&connmgr_lock); 3101 have_connmgr_lock = 0; 3102 if (clnt_stop_idle != NULL) 3103 (*clnt_stop_idle)(q); 3104 RPCLOG(1, "clnt_dispatch_notifyall:" 3105 " ignoring timeout from rpcmod" 3106 " (q %p) because we are not " 3107 " connected\n", (void *)q); 3108 } 3109 break; 3110 case T_ORDREL_IND: 3111 /* 3112 * If this entry is marked closing, then we are 3113 * completing a close handshake, and the 3114 * connection is dead. Otherwise, the server is 3115 * trying to close. Since the server will not 3116 * be sending any more RPC replies, we abort 3117 * the connection, including flushing 3118 * any RPC requests that are in-transit. 3119 */ 3120 if (cm_entry->x_closing) { 3121 cm_entry->x_dead = TRUE; 3122 mutex_exit(&connmgr_lock); 3123 have_connmgr_lock = 0; 3124 if (clnt_stop_idle != NULL) 3125 (*clnt_stop_idle)(q); 3126 } else { 3127 /* 3128 * if we're getting a disconnect 3129 * before we've finished our 3130 * connect attempt, mark it for 3131 * later processing 3132 */ 3133 if (cm_entry->x_thread) 3134 cm_entry->x_early_disc = TRUE; 3135 else 3136 cm_entry->x_connected = FALSE; 3137 cm_entry->x_waitdis = TRUE; 3138 connmgr_snddis(cm_entry); 3139 have_connmgr_lock = 0; 3140 } 3141 break; 3142 3143 case T_ERROR_ACK: 3144 case T_OK_ACK: 3145 cm_entry->x_waitdis = FALSE; 3146 cv_signal(&cm_entry->x_dis_cv); 3147 mutex_exit(&connmgr_lock); 3148 return; 3149 3150 case T_DISCON_REQ: 3151 if (cm_entry->x_thread) 3152 cm_entry->x_early_disc = TRUE; 3153 else 3154 cm_entry->x_connected = FALSE; 3155 cm_entry->x_waitdis = TRUE; 3156 3157 connmgr_snddis(cm_entry); 3158 have_connmgr_lock = 0; 3159 break; 3160 3161 case T_DISCON_IND: 3162 default: 3163 /* 3164 * if we're getting a disconnect before 3165 * we've finished our connect attempt, 3166 * mark it for later processing 3167 */ 3168 if (cm_entry->x_closing) { 3169 cm_entry->x_dead = TRUE; 3170 mutex_exit(&connmgr_lock); 3171 have_connmgr_lock = 0; 3172 if (clnt_stop_idle != NULL) 3173 (*clnt_stop_idle)(q); 3174 } else { 3175 if (cm_entry->x_thread) { 3176 cm_entry->x_early_disc = TRUE; 3177 } else { 3178 cm_entry->x_dead = TRUE; 3179 cm_entry->x_connected = FALSE; 3180 } 3181 } 3182 break; 3183 } 3184 break; 3185 } 3186 } 3187 3188 if (have_connmgr_lock) 3189 mutex_exit(&connmgr_lock); 3190 3191 if (msg_type == T_ERROR_ACK || msg_type == T_OK_ACK) { 3192 RPCLOG(1, "clnt_dispatch_notifyall: (wq %p) could not find " 3193 "connmgr entry for discon ack\n", (void *)q); 3194 return; 3195 } 3196 3197 /* 3198 * Then kick all the clnt_pending calls out of their wait. There 3199 * should be no clnt_pending calls in the case of rpcmod's idle 3200 * timer firing. 3201 */ 3202 for (i = 0; i < clnt_cots_hash_size; i++) { 3203 ctp = &cots_call_ht[i]; 3204 mutex_enter(&ctp->ct_lock); 3205 for (e = ctp->ct_call_next; 3206 e != (calllist_t *)ctp; 3207 e = e->call_next) { 3208 if (e->call_wq == q && e->call_notified == FALSE) { 3209 RPCLOG(1, 3210 "clnt_dispatch_notifyall for queue %p ", 3211 (void *)q); 3212 RPCLOG(1, "aborting clnt_pending call %p\n", 3213 (void *)e); 3214 3215 if (msg_type == T_DISCON_IND) 3216 e->call_reason = reason; 3217 e->call_notified = TRUE; 3218 e->call_status = RPC_XPRTFAILED; 3219 cv_signal(&e->call_cv); 3220 } 3221 } 3222 mutex_exit(&ctp->ct_lock); 3223 } 3224 3225 mutex_enter(&clnt_pending_lock); 3226 for (e = clnt_pending; e; e = e->call_next) { 3227 /* 3228 * Only signal those RPC handles that haven't been 3229 * signalled yet. Otherwise we can get a bogus call_reason. 3230 * This can happen if thread A is making a call over a 3231 * connection. If the server is killed, it will cause 3232 * reset, and reason will default to EIO as a result of 3233 * a T_ORDREL_IND. Thread B then attempts to recreate 3234 * the connection but gets a T_DISCON_IND. If we set the 3235 * call_reason code for all threads, then if thread A 3236 * hasn't been dispatched yet, it will get the wrong 3237 * reason. The bogus call_reason can make it harder to 3238 * discriminate between calls that fail because the 3239 * connection attempt failed versus those where the call 3240 * may have been executed on the server. 3241 */ 3242 if (e->call_wq == q && e->call_notified == FALSE) { 3243 RPCLOG(1, "clnt_dispatch_notifyall for queue %p ", 3244 (void *)q); 3245 RPCLOG(1, " aborting clnt_pending call %p\n", 3246 (void *)e); 3247 3248 if (msg_type == T_DISCON_IND) 3249 e->call_reason = reason; 3250 e->call_notified = TRUE; 3251 /* 3252 * Let the caller timeout, else he will retry 3253 * immediately. 3254 */ 3255 e->call_status = RPC_XPRTFAILED; 3256 3257 /* 3258 * We used to just signal those threads 3259 * waiting for a connection, (call_xid = 0). 3260 * That meant that threads waiting for a response 3261 * waited till their timeout expired. This 3262 * could be a long time if they've specified a 3263 * maximum timeout. (2^31 - 1). So we 3264 * Signal all threads now. 3265 */ 3266 cv_signal(&e->call_cv); 3267 } 3268 } 3269 mutex_exit(&clnt_pending_lock); 3270 } 3271 3272 3273 /*ARGSUSED*/ 3274 /* 3275 * after resuming a system that's been suspended for longer than the 3276 * NFS server's idle timeout (svc_idle_timeout for Solaris 2), rfscall() 3277 * generates "NFS server X not responding" and "NFS server X ok" messages; 3278 * here we reset inet connections to cause a re-connect and avoid those 3279 * NFS messages. see 4045054 3280 */ 3281 boolean_t 3282 connmgr_cpr_reset(void *arg, int code) 3283 { 3284 struct cm_xprt *cxp; 3285 3286 if (code == CB_CODE_CPR_CHKPT) 3287 return (B_TRUE); 3288 3289 if (mutex_tryenter(&connmgr_lock) == 0) 3290 return (B_FALSE); 3291 for (cxp = cm_hd; cxp; cxp = cxp->x_next) { 3292 if ((cxp->x_family == AF_INET || cxp->x_family == AF_INET6) && 3293 cxp->x_connected == TRUE) { 3294 if (cxp->x_thread) 3295 cxp->x_early_disc = TRUE; 3296 else 3297 cxp->x_connected = FALSE; 3298 cxp->x_needdis = TRUE; 3299 } 3300 } 3301 mutex_exit(&connmgr_lock); 3302 return (B_TRUE); 3303 } 3304 3305 void 3306 clnt_cots_stats_init(zoneid_t zoneid, struct rpc_cots_client **statsp) 3307 { 3308 3309 *statsp = (struct rpc_cots_client *)rpcstat_zone_init_common(zoneid, 3310 "unix", "rpc_cots_client", (const kstat_named_t *)&cots_rcstat_tmpl, 3311 sizeof (cots_rcstat_tmpl)); 3312 } 3313 3314 void 3315 clnt_cots_stats_fini(zoneid_t zoneid, struct rpc_cots_client **statsp) 3316 { 3317 rpcstat_zone_fini_common(zoneid, "unix", "rpc_cots_client"); 3318 kmem_free(*statsp, sizeof (cots_rcstat_tmpl)); 3319 } 3320 3321 void 3322 clnt_cots_init(void) 3323 { 3324 mutex_init(&connmgr_lock, NULL, MUTEX_DEFAULT, NULL); 3325 mutex_init(&clnt_pending_lock, NULL, MUTEX_DEFAULT, NULL); 3326 3327 if (clnt_cots_hash_size < DEFAULT_MIN_HASH_SIZE) 3328 clnt_cots_hash_size = DEFAULT_MIN_HASH_SIZE; 3329 3330 cots_call_ht = call_table_init(clnt_cots_hash_size); 3331 zone_key_create(&zone_cots_key, NULL, NULL, clnt_zone_destroy); 3332 } 3333 3334 void 3335 clnt_cots_fini(void) 3336 { 3337 (void) zone_key_delete(zone_cots_key); 3338 } 3339 3340 /* 3341 * Wait for TPI ack, returns success only if expected ack is received 3342 * within timeout period. 3343 */ 3344 3345 static int 3346 waitforack(calllist_t *e, t_scalar_t ack_prim, const struct timeval *waitp, 3347 bool_t nosignal) 3348 { 3349 union T_primitives *tpr; 3350 clock_t timout; 3351 int cv_stat = 1; 3352 3353 ASSERT(MUTEX_HELD(&clnt_pending_lock)); 3354 while (e->call_reply == NULL) { 3355 if (waitp != NULL) { 3356 timout = waitp->tv_sec * drv_usectohz(MICROSEC) + 3357 drv_usectohz(waitp->tv_usec) + lbolt; 3358 if (nosignal) 3359 cv_stat = cv_timedwait(&e->call_cv, 3360 &clnt_pending_lock, timout); 3361 else 3362 cv_stat = cv_timedwait_sig(&e->call_cv, 3363 &clnt_pending_lock, timout); 3364 } else { 3365 if (nosignal) 3366 cv_wait(&e->call_cv, &clnt_pending_lock); 3367 else 3368 cv_stat = cv_wait_sig(&e->call_cv, 3369 &clnt_pending_lock); 3370 } 3371 if (cv_stat == -1) 3372 return (ETIME); 3373 if (cv_stat == 0) 3374 return (EINTR); 3375 } 3376 tpr = (union T_primitives *)e->call_reply->b_rptr; 3377 if (tpr->type == ack_prim) 3378 return (0); /* Success */ 3379 3380 if (tpr->type == T_ERROR_ACK) { 3381 if (tpr->error_ack.TLI_error == TSYSERR) 3382 return (tpr->error_ack.UNIX_error); 3383 else 3384 return (t_tlitosyserr(tpr->error_ack.TLI_error)); 3385 } 3386 3387 return (EPROTO); /* unknown or unexpected primitive */ 3388 } 3389