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 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright (c) 2013 by Delphix. All rights reserved. 27 */ 28 29 #include <sys/conf.h> 30 #include <sys/stat.h> 31 #include <sys/file.h> 32 #include <sys/ddi.h> 33 #include <sys/sunddi.h> 34 #include <sys/modctl.h> 35 #include <sys/priv.h> 36 #include <sys/cpuvar.h> 37 #include <sys/socket.h> 38 #include <sys/strsubr.h> 39 #include <sys/sysmacros.h> 40 #include <sys/sdt.h> 41 #include <netinet/tcp.h> 42 #include <inet/tcp.h> 43 #include <sys/socketvar.h> 44 #include <sys/pathname.h> 45 #include <sys/fs/snode.h> 46 #include <sys/fs/dv_node.h> 47 #include <sys/vnode.h> 48 #include <netinet/in.h> 49 #include <net/if.h> 50 #include <sys/sockio.h> 51 #include <sys/ksocket.h> 52 #include <sys/filio.h> /* FIONBIO */ 53 #include <sys/iscsi_protocol.h> 54 #include <sys/idm/idm.h> 55 #include <sys/idm/idm_so.h> 56 #include <sys/idm/idm_text.h> 57 58 #define IN_PROGRESS_DELAY 1 59 60 /* 61 * in6addr_any is currently all zeroes, but use the macro in case this 62 * ever changes. 63 */ 64 static const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; 65 66 static void idm_sorx_cache_pdu_cb(idm_pdu_t *pdu, idm_status_t status); 67 static void idm_sorx_addl_pdu_cb(idm_pdu_t *pdu, idm_status_t status); 68 static void idm_sotx_cache_pdu_cb(idm_pdu_t *pdu, idm_status_t status); 69 70 static idm_status_t idm_so_conn_create_common(idm_conn_t *ic, ksocket_t new_so); 71 static void idm_so_conn_destroy_common(idm_conn_t *ic); 72 static void idm_so_conn_connect_common(idm_conn_t *ic); 73 74 static void idm_set_ini_preconnect_options(idm_so_conn_t *sc, 75 boolean_t boot_conn); 76 static void idm_set_postconnect_options(ksocket_t so); 77 static idm_status_t idm_i_so_tx(idm_pdu_t *pdu); 78 79 static idm_status_t idm_sorecvdata(idm_conn_t *ic, idm_pdu_t *pdu); 80 static void idm_so_send_rtt_data(idm_conn_t *ic, idm_task_t *idt, 81 idm_buf_t *idb, uint32_t offset, uint32_t length); 82 static void idm_so_send_rtt_data_done(idm_task_t *idt, idm_buf_t *idb); 83 static idm_status_t idm_so_send_buf_region(idm_task_t *idt, 84 idm_buf_t *idb, uint32_t buf_region_offset, uint32_t buf_region_length); 85 86 static uint32_t idm_fill_iov(idm_pdu_t *pdu, idm_buf_t *idb, 87 uint32_t ro, uint32_t dlength); 88 89 static idm_status_t idm_so_handle_digest(idm_conn_t *it, 90 nvpair_t *digest_choice, const idm_kv_xlate_t *ikvx); 91 92 static void idm_so_socket_set_nonblock(struct sonode *node); 93 static void idm_so_socket_set_block(struct sonode *node); 94 95 /* 96 * Transport ops prototypes 97 */ 98 static void idm_so_tx(idm_conn_t *ic, idm_pdu_t *pdu); 99 static idm_status_t idm_so_buf_tx_to_ini(idm_task_t *idt, idm_buf_t *idb); 100 static idm_status_t idm_so_buf_rx_from_ini(idm_task_t *idt, idm_buf_t *idb); 101 static void idm_so_rx_datain(idm_conn_t *ic, idm_pdu_t *pdu); 102 static void idm_so_rx_rtt(idm_conn_t *ic, idm_pdu_t *pdu); 103 static void idm_so_rx_dataout(idm_conn_t *ic, idm_pdu_t *pdu); 104 static idm_status_t idm_so_free_task_rsrc(idm_task_t *idt); 105 static kv_status_t idm_so_negotiate_key_values(idm_conn_t *it, 106 nvlist_t *request_nvl, nvlist_t *response_nvl, nvlist_t *negotiated_nvl); 107 static void idm_so_notice_key_values(idm_conn_t *it, 108 nvlist_t *negotiated_nvl); 109 static kv_status_t idm_so_declare_key_values(idm_conn_t *it, 110 nvlist_t *config_nvl, nvlist_t *outgoing_nvl); 111 static boolean_t idm_so_conn_is_capable(idm_conn_req_t *ic, 112 idm_transport_caps_t *caps); 113 static idm_status_t idm_so_buf_alloc(idm_buf_t *idb, uint64_t buflen); 114 static void idm_so_buf_free(idm_buf_t *idb); 115 static idm_status_t idm_so_buf_setup(idm_buf_t *idb); 116 static void idm_so_buf_teardown(idm_buf_t *idb); 117 static idm_status_t idm_so_tgt_svc_create(idm_svc_req_t *sr, idm_svc_t *is); 118 static void idm_so_tgt_svc_destroy(idm_svc_t *is); 119 static idm_status_t idm_so_tgt_svc_online(idm_svc_t *is); 120 static void idm_so_tgt_svc_offline(idm_svc_t *is); 121 static void idm_so_tgt_conn_destroy(idm_conn_t *ic); 122 static idm_status_t idm_so_tgt_conn_connect(idm_conn_t *ic); 123 static void idm_so_conn_disconnect(idm_conn_t *ic); 124 static idm_status_t idm_so_ini_conn_create(idm_conn_req_t *cr, idm_conn_t *ic); 125 static void idm_so_ini_conn_destroy(idm_conn_t *ic); 126 static idm_status_t idm_so_ini_conn_connect(idm_conn_t *ic); 127 128 /* 129 * IDM Native Sockets transport operations 130 */ 131 static 132 idm_transport_ops_t idm_so_transport_ops = { 133 idm_so_tx, /* it_tx_pdu */ 134 idm_so_buf_tx_to_ini, /* it_buf_tx_to_ini */ 135 idm_so_buf_rx_from_ini, /* it_buf_rx_from_ini */ 136 idm_so_rx_datain, /* it_rx_datain */ 137 idm_so_rx_rtt, /* it_rx_rtt */ 138 idm_so_rx_dataout, /* it_rx_dataout */ 139 NULL, /* it_alloc_conn_rsrc */ 140 NULL, /* it_free_conn_rsrc */ 141 NULL, /* it_tgt_enable_datamover */ 142 NULL, /* it_ini_enable_datamover */ 143 NULL, /* it_conn_terminate */ 144 idm_so_free_task_rsrc, /* it_free_task_rsrc */ 145 idm_so_negotiate_key_values, /* it_negotiate_key_values */ 146 idm_so_notice_key_values, /* it_notice_key_values */ 147 idm_so_conn_is_capable, /* it_conn_is_capable */ 148 idm_so_buf_alloc, /* it_buf_alloc */ 149 idm_so_buf_free, /* it_buf_free */ 150 idm_so_buf_setup, /* it_buf_setup */ 151 idm_so_buf_teardown, /* it_buf_teardown */ 152 idm_so_tgt_svc_create, /* it_tgt_svc_create */ 153 idm_so_tgt_svc_destroy, /* it_tgt_svc_destroy */ 154 idm_so_tgt_svc_online, /* it_tgt_svc_online */ 155 idm_so_tgt_svc_offline, /* it_tgt_svc_offline */ 156 idm_so_tgt_conn_destroy, /* it_tgt_conn_destroy */ 157 idm_so_tgt_conn_connect, /* it_tgt_conn_connect */ 158 idm_so_conn_disconnect, /* it_tgt_conn_disconnect */ 159 idm_so_ini_conn_create, /* it_ini_conn_create */ 160 idm_so_ini_conn_destroy, /* it_ini_conn_destroy */ 161 idm_so_ini_conn_connect, /* it_ini_conn_connect */ 162 idm_so_conn_disconnect, /* it_ini_conn_disconnect */ 163 idm_so_declare_key_values /* it_declare_key_values */ 164 }; 165 166 kmutex_t idm_so_timed_socket_mutex; 167 168 int32_t idm_so_sndbuf = IDM_SNDBUF_SIZE; 169 int32_t idm_so_rcvbuf = IDM_RCVBUF_SIZE; 170 171 /* 172 * idm_so_init() 173 * Sockets transport initialization 174 */ 175 void 176 idm_so_init(idm_transport_t *it) 177 { 178 /* Cache for IDM Data and R2T Transmit PDU's */ 179 idm.idm_sotx_pdu_cache = kmem_cache_create("idm_tx_pdu_cache", 180 sizeof (idm_pdu_t) + sizeof (iscsi_hdr_t), 8, 181 &idm_sotx_pdu_constructor, NULL, NULL, NULL, NULL, KM_SLEEP); 182 183 /* Cache for IDM Receive PDU's */ 184 idm.idm_sorx_pdu_cache = kmem_cache_create("idm_rx_pdu_cache", 185 sizeof (idm_pdu_t) + IDM_SORX_CACHE_HDRLEN, 8, 186 &idm_sorx_pdu_constructor, NULL, NULL, NULL, NULL, KM_SLEEP); 187 188 /* 128k buffer cache */ 189 idm.idm_so_128k_buf_cache = kmem_cache_create("idm_128k_buf_cache", 190 IDM_SO_BUF_CACHE_UB, 8, NULL, NULL, NULL, NULL, NULL, KM_SLEEP); 191 192 /* Set the sockets transport ops */ 193 it->it_ops = &idm_so_transport_ops; 194 195 mutex_init(&idm_so_timed_socket_mutex, NULL, MUTEX_DEFAULT, NULL); 196 197 } 198 199 /* 200 * idm_so_fini() 201 * Sockets transport teardown 202 */ 203 void 204 idm_so_fini(void) 205 { 206 kmem_cache_destroy(idm.idm_so_128k_buf_cache); 207 kmem_cache_destroy(idm.idm_sotx_pdu_cache); 208 kmem_cache_destroy(idm.idm_sorx_pdu_cache); 209 mutex_destroy(&idm_so_timed_socket_mutex); 210 } 211 212 ksocket_t 213 idm_socreate(int domain, int type, int protocol) 214 { 215 ksocket_t ks; 216 217 if (!ksocket_socket(&ks, domain, type, protocol, KSOCKET_NOSLEEP, 218 CRED())) { 219 return (ks); 220 } else { 221 return (NULL); 222 } 223 } 224 225 /* 226 * idm_soshutdown will disconnect the socket and prevent subsequent PDU 227 * reception and transmission. The sonode still exists but its state 228 * gets modified to indicate it is no longer connected. Calls to 229 * idm_sorecv/idm_iov_sorecv will return so idm_soshutdown can be used 230 * regain control of a thread stuck in idm_sorecv. 231 */ 232 void 233 idm_soshutdown(ksocket_t so) 234 { 235 (void) ksocket_shutdown(so, SHUT_RDWR, CRED()); 236 } 237 238 /* 239 * idm_sodestroy releases all resources associated with a socket previously 240 * created with idm_socreate. The socket must be shutdown using 241 * idm_soshutdown before the socket is destroyed with idm_sodestroy, 242 * otherwise undefined behavior will result. 243 */ 244 void 245 idm_sodestroy(ksocket_t ks) 246 { 247 (void) ksocket_close(ks, CRED()); 248 } 249 250 /* 251 * Function to compare two addresses in sockaddr_storage format 252 */ 253 254 int 255 idm_ss_compare(const struct sockaddr_storage *cmp_ss1, 256 const struct sockaddr_storage *cmp_ss2, 257 boolean_t v4_mapped_as_v4, 258 boolean_t compare_ports) 259 { 260 struct sockaddr_storage mapped_v4_ss1, mapped_v4_ss2; 261 const struct sockaddr_storage *ss1, *ss2; 262 struct in_addr *in1, *in2; 263 struct in6_addr *in61, *in62; 264 int i; 265 266 /* 267 * Normalize V4-mapped IPv6 addresses into V4 format if 268 * v4_mapped_as_v4 is B_TRUE. 269 */ 270 ss1 = cmp_ss1; 271 ss2 = cmp_ss2; 272 if (v4_mapped_as_v4 && (ss1->ss_family == AF_INET6)) { 273 in61 = &((struct sockaddr_in6 *)ss1)->sin6_addr; 274 if (IN6_IS_ADDR_V4MAPPED(in61)) { 275 bzero(&mapped_v4_ss1, sizeof (mapped_v4_ss1)); 276 mapped_v4_ss1.ss_family = AF_INET; 277 ((struct sockaddr_in *)&mapped_v4_ss1)->sin_port = 278 ((struct sockaddr_in *)ss1)->sin_port; 279 IN6_V4MAPPED_TO_INADDR(in61, 280 &((struct sockaddr_in *)&mapped_v4_ss1)->sin_addr); 281 ss1 = &mapped_v4_ss1; 282 } 283 } 284 ss2 = cmp_ss2; 285 if (v4_mapped_as_v4 && (ss2->ss_family == AF_INET6)) { 286 in62 = &((struct sockaddr_in6 *)ss2)->sin6_addr; 287 if (IN6_IS_ADDR_V4MAPPED(in62)) { 288 bzero(&mapped_v4_ss2, sizeof (mapped_v4_ss2)); 289 mapped_v4_ss2.ss_family = AF_INET; 290 ((struct sockaddr_in *)&mapped_v4_ss2)->sin_port = 291 ((struct sockaddr_in *)ss2)->sin_port; 292 IN6_V4MAPPED_TO_INADDR(in62, 293 &((struct sockaddr_in *)&mapped_v4_ss2)->sin_addr); 294 ss2 = &mapped_v4_ss2; 295 } 296 } 297 298 /* 299 * Compare ports, then address family, then ip address 300 */ 301 if (compare_ports && 302 (((struct sockaddr_in *)ss1)->sin_port != 303 ((struct sockaddr_in *)ss2)->sin_port)) { 304 if (((struct sockaddr_in *)ss1)->sin_port > 305 ((struct sockaddr_in *)ss2)->sin_port) 306 return (1); 307 else 308 return (-1); 309 } 310 311 /* 312 * ports are the same 313 */ 314 if (ss1->ss_family != ss2->ss_family) { 315 if (ss1->ss_family == AF_INET) 316 return (1); 317 else 318 return (-1); 319 } 320 321 /* 322 * address families are the same 323 */ 324 if (ss1->ss_family == AF_INET) { 325 in1 = &((struct sockaddr_in *)ss1)->sin_addr; 326 in2 = &((struct sockaddr_in *)ss2)->sin_addr; 327 328 if (in1->s_addr > in2->s_addr) 329 return (1); 330 else if (in1->s_addr < in2->s_addr) 331 return (-1); 332 else 333 return (0); 334 } else if (ss1->ss_family == AF_INET6) { 335 in61 = &((struct sockaddr_in6 *)ss1)->sin6_addr; 336 in62 = &((struct sockaddr_in6 *)ss2)->sin6_addr; 337 338 for (i = 0; i < 4; i++) { 339 if (in61->s6_addr32[i] > in62->s6_addr32[i]) 340 return (1); 341 else if (in61->s6_addr32[i] < in62->s6_addr32[i]) 342 return (-1); 343 } 344 return (0); 345 } 346 347 return (1); 348 } 349 350 /* 351 * IP address filter functions to flag addresses that should not 352 * go out to initiators through discovery. 353 */ 354 static boolean_t 355 idm_v4_addr_okay(struct in_addr *in_addr) 356 { 357 in_addr_t addr = ntohl(in_addr->s_addr); 358 359 if ((INADDR_NONE == addr) || 360 (IN_MULTICAST(addr)) || 361 ((addr >> IN_CLASSA_NSHIFT) == 0) || 362 ((addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET)) { 363 return (B_FALSE); 364 } 365 return (B_TRUE); 366 } 367 368 static boolean_t 369 idm_v6_addr_okay(struct in6_addr *addr6) 370 { 371 372 if ((IN6_IS_ADDR_UNSPECIFIED(addr6)) || 373 (IN6_IS_ADDR_LOOPBACK(addr6)) || 374 (IN6_IS_ADDR_MULTICAST(addr6)) || 375 (IN6_IS_ADDR_V4MAPPED(addr6)) || 376 (IN6_IS_ADDR_V4COMPAT(addr6)) || 377 (IN6_IS_ADDR_LINKLOCAL(addr6))) { 378 return (B_FALSE); 379 } 380 return (B_TRUE); 381 } 382 383 /* 384 * idm_get_ipaddr will retrieve a list of IP Addresses which the host is 385 * configured with by sending down a sequence of kernel ioctl to IP STREAMS. 386 */ 387 int 388 idm_get_ipaddr(idm_addr_list_t **ipaddr_p) 389 { 390 ksocket_t so4, so6; 391 struct lifnum lifn; 392 struct lifconf lifc; 393 struct lifreq *lp; 394 int rval; 395 int numifs; 396 int bufsize; 397 void *buf; 398 int i, j, n, rc; 399 struct sockaddr_storage ss; 400 struct sockaddr_in *sin; 401 struct sockaddr_in6 *sin6; 402 idm_addr_t *ip; 403 idm_addr_list_t *ipaddr = NULL; 404 int size_ipaddr; 405 406 *ipaddr_p = NULL; 407 size_ipaddr = 0; 408 buf = NULL; 409 410 /* create an ipv4 and ipv6 UDP socket */ 411 if ((so6 = idm_socreate(PF_INET6, SOCK_DGRAM, 0)) == NULL) 412 return (0); 413 if ((so4 = idm_socreate(PF_INET, SOCK_DGRAM, 0)) == NULL) { 414 idm_sodestroy(so6); 415 return (0); 416 } 417 418 419 retry_count: 420 /* snapshot the current number of interfaces */ 421 lifn.lifn_family = PF_UNSPEC; 422 lifn.lifn_flags = LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES; 423 lifn.lifn_count = 0; 424 /* use vp6 for ioctls with unspecified families by default */ 425 if (ksocket_ioctl(so6, SIOCGLIFNUM, (intptr_t)&lifn, &rval, CRED()) 426 != 0) { 427 goto cleanup; 428 } 429 430 numifs = lifn.lifn_count; 431 if (numifs <= 0) { 432 goto cleanup; 433 } 434 435 /* allocate extra room in case more interfaces appear */ 436 numifs += 10; 437 438 /* get the interface names and ip addresses */ 439 bufsize = numifs * sizeof (struct lifreq); 440 buf = kmem_alloc(bufsize, KM_SLEEP); 441 442 lifc.lifc_family = AF_UNSPEC; 443 lifc.lifc_flags = LIFC_NOXMIT | LIFC_TEMPORARY | LIFC_ALLZONES; 444 lifc.lifc_len = bufsize; 445 lifc.lifc_buf = buf; 446 rc = ksocket_ioctl(so6, SIOCGLIFCONF, (intptr_t)&lifc, &rval, CRED()); 447 if (rc != 0) { 448 goto cleanup; 449 } 450 /* if our extra room is used up, try again */ 451 if (bufsize <= lifc.lifc_len) { 452 kmem_free(buf, bufsize); 453 buf = NULL; 454 goto retry_count; 455 } 456 /* calc actual number of ifconfs */ 457 n = lifc.lifc_len / sizeof (struct lifreq); 458 459 /* get ip address */ 460 if (n > 0) { 461 size_ipaddr = sizeof (idm_addr_list_t) + 462 (n - 1) * sizeof (idm_addr_t); 463 ipaddr = kmem_zalloc(size_ipaddr, KM_SLEEP); 464 } else { 465 goto cleanup; 466 } 467 468 /* 469 * Examine the array of interfaces and filter uninteresting ones 470 */ 471 for (i = 0, j = 0, lp = lifc.lifc_req; i < n; i++, lp++) { 472 473 /* 474 * Copy the address as the SIOCGLIFFLAGS ioctl is destructive 475 */ 476 ss = lp->lifr_addr; 477 /* 478 * fetch the flags using the socket of the correct family 479 */ 480 switch (ss.ss_family) { 481 case AF_INET: 482 rc = ksocket_ioctl(so4, SIOCGLIFFLAGS, (intptr_t)lp, 483 &rval, CRED()); 484 break; 485 case AF_INET6: 486 rc = ksocket_ioctl(so6, SIOCGLIFFLAGS, (intptr_t)lp, 487 &rval, CRED()); 488 break; 489 default: 490 continue; 491 } 492 if (rc == 0) { 493 /* 494 * If we got the flags, skip uninteresting 495 * interfaces based on flags 496 */ 497 if ((lp->lifr_flags & IFF_UP) != IFF_UP) 498 continue; 499 if (lp->lifr_flags & 500 (IFF_ANYCAST|IFF_NOLOCAL|IFF_DEPRECATED)) 501 continue; 502 } 503 504 /* save ip address */ 505 ip = &ipaddr->al_addrs[j]; 506 switch (ss.ss_family) { 507 case AF_INET: 508 sin = (struct sockaddr_in *)&ss; 509 if (!idm_v4_addr_okay(&sin->sin_addr)) 510 continue; 511 ip->a_addr.i_addr.in4 = sin->sin_addr; 512 ip->a_addr.i_insize = sizeof (struct in_addr); 513 break; 514 case AF_INET6: 515 sin6 = (struct sockaddr_in6 *)&ss; 516 if (!idm_v6_addr_okay(&sin6->sin6_addr)) 517 continue; 518 ip->a_addr.i_addr.in6 = sin6->sin6_addr; 519 ip->a_addr.i_insize = sizeof (struct in6_addr); 520 break; 521 default: 522 continue; 523 } 524 j++; 525 } 526 527 if (j == 0) { 528 /* no valid ifaddr */ 529 kmem_free(ipaddr, size_ipaddr); 530 size_ipaddr = 0; 531 ipaddr = NULL; 532 } else { 533 ipaddr->al_out_cnt = j; 534 } 535 536 537 cleanup: 538 idm_sodestroy(so6); 539 idm_sodestroy(so4); 540 541 if (buf != NULL) 542 kmem_free(buf, bufsize); 543 544 *ipaddr_p = ipaddr; 545 return (size_ipaddr); 546 } 547 548 int 549 idm_sorecv(ksocket_t so, void *msg, size_t len) 550 { 551 iovec_t iov; 552 553 ASSERT(so != NULL); 554 ASSERT(len != 0); 555 556 /* 557 * Fill in iovec and receive data 558 */ 559 iov.iov_base = msg; 560 iov.iov_len = len; 561 562 return (idm_iov_sorecv(so, &iov, 1, len)); 563 } 564 565 /* 566 * idm_sosendto - Sends a buffered data on a non-connected socket. 567 * 568 * This function puts the data provided on the wire by calling sosendmsg. 569 * It will return only when all the data has been sent or if an error 570 * occurs. 571 * 572 * Returns 0 for success, the socket errno value if sosendmsg fails, and 573 * -1 if sosendmsg returns success but uio_resid != 0 574 */ 575 int 576 idm_sosendto(ksocket_t so, void *buff, size_t len, 577 struct sockaddr *name, socklen_t namelen) 578 { 579 struct msghdr msg; 580 struct iovec iov[1]; 581 int error; 582 size_t sent = 0; 583 584 iov[0].iov_base = buff; 585 iov[0].iov_len = len; 586 587 /* Initialization of the message header. */ 588 bzero(&msg, sizeof (msg)); 589 msg.msg_iov = iov; 590 msg.msg_iovlen = 1; 591 msg.msg_name = name; 592 msg.msg_namelen = namelen; 593 594 if ((error = ksocket_sendmsg(so, &msg, 0, &sent, CRED())) == 0) { 595 /* Data sent */ 596 if (sent == len) { 597 /* All data sent. Success. */ 598 return (0); 599 } else { 600 /* Not all data was sent. Failure */ 601 return (-1); 602 } 603 } 604 605 /* Send failed */ 606 return (error); 607 } 608 609 /* 610 * idm_iov_sosend - Sends an iovec on a connection. 611 * 612 * This function puts the data provided on the wire by calling sosendmsg. 613 * It will return only when all the data has been sent or if an error 614 * occurs. 615 * 616 * Returns 0 for success, the socket errno value if sosendmsg fails, and 617 * -1 if sosendmsg returns success but uio_resid != 0 618 */ 619 int 620 idm_iov_sosend(ksocket_t so, iovec_t *iop, int iovlen, size_t total_len) 621 { 622 struct msghdr msg; 623 int error; 624 size_t sent = 0; 625 626 ASSERT(iop != NULL); 627 628 /* Initialization of the message header. */ 629 bzero(&msg, sizeof (msg)); 630 msg.msg_iov = iop; 631 msg.msg_iovlen = iovlen; 632 633 if ((error = ksocket_sendmsg(so, &msg, 0, &sent, CRED())) 634 == 0) { 635 /* Data sent */ 636 if (sent == total_len) { 637 /* All data sent. Success. */ 638 return (0); 639 } else { 640 /* Not all data was sent. Failure */ 641 return (-1); 642 } 643 } 644 645 /* Send failed */ 646 return (error); 647 } 648 649 /* 650 * idm_iov_sorecv - Receives an iovec from a connection 651 * 652 * This function gets the data asked for from the socket. It will return 653 * only when all the requested data has been retrieved or if an error 654 * occurs. 655 * 656 * Returns 0 for success, the socket errno value if sorecvmsg fails, and 657 * -1 if sorecvmsg returns success but uio_resid != 0 658 */ 659 int 660 idm_iov_sorecv(ksocket_t so, iovec_t *iop, int iovlen, size_t total_len) 661 { 662 struct msghdr msg; 663 int error; 664 size_t recv; 665 int flags; 666 667 ASSERT(iop != NULL); 668 669 /* Initialization of the message header. */ 670 bzero(&msg, sizeof (msg)); 671 msg.msg_iov = iop; 672 msg.msg_iovlen = iovlen; 673 flags = MSG_WAITALL; 674 675 if ((error = ksocket_recvmsg(so, &msg, flags, &recv, CRED())) 676 == 0) { 677 /* Received data */ 678 if (recv == total_len) { 679 /* All requested data received. Success */ 680 return (0); 681 } else { 682 /* 683 * Not all data was received. The connection has 684 * probably failed. 685 */ 686 return (-1); 687 } 688 } 689 690 /* Receive failed */ 691 return (error); 692 } 693 694 static void 695 idm_set_ini_preconnect_options(idm_so_conn_t *sc, boolean_t boot_conn) 696 { 697 int conn_abort = 10000; 698 int conn_notify = 2000; 699 int abort = 30000; 700 701 /* Pre-connect socket options */ 702 (void) ksocket_setsockopt(sc->ic_so, IPPROTO_TCP, 703 TCP_CONN_NOTIFY_THRESHOLD, (char *)&conn_notify, sizeof (int), 704 CRED()); 705 if (boot_conn == B_FALSE) { 706 (void) ksocket_setsockopt(sc->ic_so, IPPROTO_TCP, 707 TCP_CONN_ABORT_THRESHOLD, (char *)&conn_abort, sizeof (int), 708 CRED()); 709 (void) ksocket_setsockopt(sc->ic_so, IPPROTO_TCP, 710 TCP_ABORT_THRESHOLD, 711 (char *)&abort, sizeof (int), CRED()); 712 } 713 } 714 715 static void 716 idm_set_postconnect_options(ksocket_t ks) 717 { 718 const int on = 1; 719 720 /* Set connect options */ 721 (void) ksocket_setsockopt(ks, SOL_SOCKET, SO_RCVBUF, 722 (char *)&idm_so_rcvbuf, sizeof (idm_so_rcvbuf), CRED()); 723 (void) ksocket_setsockopt(ks, SOL_SOCKET, SO_SNDBUF, 724 (char *)&idm_so_sndbuf, sizeof (idm_so_sndbuf), CRED()); 725 (void) ksocket_setsockopt(ks, IPPROTO_TCP, TCP_NODELAY, 726 (char *)&on, sizeof (on), CRED()); 727 } 728 729 static uint32_t 730 n2h24(const uchar_t *ptr) 731 { 732 return ((ptr[0] << 16) | (ptr[1] << 8) | ptr[2]); 733 } 734 735 736 static idm_status_t 737 idm_sorecvhdr(idm_conn_t *ic, idm_pdu_t *pdu) 738 { 739 iscsi_hdr_t *bhs; 740 uint32_t hdr_digest_crc; 741 uint32_t crc_calculated; 742 void *new_hdr; 743 int ahslen = 0; 744 int total_len = 0; 745 int iovlen = 0; 746 struct iovec iov[2]; 747 idm_so_conn_t *so_conn; 748 int rc; 749 750 so_conn = ic->ic_transport_private; 751 752 /* 753 * Read BHS 754 */ 755 bhs = pdu->isp_hdr; 756 rc = idm_sorecv(so_conn->ic_so, pdu->isp_hdr, sizeof (iscsi_hdr_t)); 757 if (rc != IDM_STATUS_SUCCESS) { 758 return (IDM_STATUS_FAIL); 759 } 760 761 /* 762 * Check actual AHS length against the amount available in the buffer 763 */ 764 pdu->isp_hdrlen = sizeof (iscsi_hdr_t) + 765 (bhs->hlength * sizeof (uint32_t)); 766 pdu->isp_datalen = n2h24(bhs->dlength); 767 if (ic->ic_conn_type == CONN_TYPE_TGT && 768 pdu->isp_datalen > ic->ic_conn_params.max_recv_dataseglen) { 769 IDM_CONN_LOG(CE_WARN, 770 "idm_sorecvhdr: exceeded the max data segment length"); 771 return (IDM_STATUS_FAIL); 772 } 773 if (bhs->hlength > IDM_SORX_CACHE_AHSLEN) { 774 /* Allocate a new header segment and change the callback */ 775 new_hdr = kmem_alloc(pdu->isp_hdrlen, KM_SLEEP); 776 bcopy(pdu->isp_hdr, new_hdr, sizeof (iscsi_hdr_t)); 777 pdu->isp_hdr = new_hdr; 778 pdu->isp_flags |= IDM_PDU_ADDL_HDR; 779 780 /* 781 * This callback will restore the expected values after 782 * the RX PDU has been processed. 783 */ 784 pdu->isp_callback = idm_sorx_addl_pdu_cb; 785 } 786 787 /* 788 * Setup receipt of additional header and header digest (if enabled). 789 */ 790 if (bhs->hlength > 0) { 791 iov[iovlen].iov_base = (caddr_t)(pdu->isp_hdr + 1); 792 ahslen = pdu->isp_hdrlen - sizeof (iscsi_hdr_t); 793 iov[iovlen].iov_len = ahslen; 794 total_len += iov[iovlen].iov_len; 795 iovlen++; 796 } 797 798 if (ic->ic_conn_flags & IDM_CONN_HEADER_DIGEST) { 799 iov[iovlen].iov_base = (caddr_t)&hdr_digest_crc; 800 iov[iovlen].iov_len = sizeof (hdr_digest_crc); 801 total_len += iov[iovlen].iov_len; 802 iovlen++; 803 } 804 805 if ((iovlen != 0) && 806 (idm_iov_sorecv(so_conn->ic_so, &iov[0], iovlen, 807 total_len) != 0)) { 808 return (IDM_STATUS_FAIL); 809 } 810 811 /* 812 * Validate header digest if enabled 813 */ 814 if (ic->ic_conn_flags & IDM_CONN_HEADER_DIGEST) { 815 crc_calculated = idm_crc32c(pdu->isp_hdr, 816 sizeof (iscsi_hdr_t) + ahslen); 817 if (crc_calculated != hdr_digest_crc) { 818 /* Invalid Header Digest */ 819 return (IDM_STATUS_HEADER_DIGEST); 820 } 821 } 822 823 return (0); 824 } 825 826 /* 827 * idm_so_ini_conn_create() 828 * Allocate the sockets transport connection resources. 829 */ 830 static idm_status_t 831 idm_so_ini_conn_create(idm_conn_req_t *cr, idm_conn_t *ic) 832 { 833 ksocket_t so; 834 idm_so_conn_t *so_conn; 835 idm_status_t idmrc; 836 837 so = idm_socreate(cr->cr_domain, cr->cr_type, 838 cr->cr_protocol); 839 if (so == NULL) { 840 return (IDM_STATUS_FAIL); 841 } 842 843 /* Bind the socket if configured to do so */ 844 if (cr->cr_bound) { 845 if (ksocket_bind(so, &cr->cr_bound_addr.sin, 846 SIZEOF_SOCKADDR(&cr->cr_bound_addr.sin), CRED()) != 0) { 847 idm_sodestroy(so); 848 return (IDM_STATUS_FAIL); 849 } 850 } 851 852 idmrc = idm_so_conn_create_common(ic, so); 853 if (idmrc != IDM_STATUS_SUCCESS) { 854 idm_soshutdown(so); 855 idm_sodestroy(so); 856 return (IDM_STATUS_FAIL); 857 } 858 859 so_conn = ic->ic_transport_private; 860 /* Set up socket options */ 861 idm_set_ini_preconnect_options(so_conn, cr->cr_boot_conn); 862 863 return (IDM_STATUS_SUCCESS); 864 } 865 866 /* 867 * idm_so_ini_conn_destroy() 868 * Tear down the sockets transport connection resources. 869 */ 870 static void 871 idm_so_ini_conn_destroy(idm_conn_t *ic) 872 { 873 idm_so_conn_destroy_common(ic); 874 } 875 876 /* 877 * idm_so_ini_conn_connect() 878 * Establish the connection referred to by the handle previously allocated via 879 * idm_so_ini_conn_create(). 880 */ 881 static idm_status_t 882 idm_so_ini_conn_connect(idm_conn_t *ic) 883 { 884 idm_so_conn_t *so_conn; 885 struct sonode *node = NULL; 886 int rc; 887 clock_t lbolt, conn_login_max, conn_login_interval; 888 boolean_t nonblock; 889 890 so_conn = ic->ic_transport_private; 891 nonblock = ic->ic_conn_params.nonblock_socket; 892 conn_login_max = ic->ic_conn_params.conn_login_max; 893 conn_login_interval = ddi_get_lbolt() + 894 SEC_TO_TICK(ic->ic_conn_params.conn_login_interval); 895 896 if (nonblock == B_TRUE) { 897 node = ((struct sonode *)(so_conn->ic_so)); 898 /* Set to none block socket mode */ 899 idm_so_socket_set_nonblock(node); 900 do { 901 rc = ksocket_connect(so_conn->ic_so, 902 &ic->ic_ini_dst_addr.sin, 903 (SIZEOF_SOCKADDR(&ic->ic_ini_dst_addr.sin)), 904 CRED()); 905 if (rc == 0 || rc == EISCONN) { 906 /* socket success or already success */ 907 rc = IDM_STATUS_SUCCESS; 908 break; 909 } 910 if ((rc == ETIMEDOUT) || (rc == ECONNREFUSED) || 911 (rc == ECONNRESET)) { 912 /* socket connection timeout or refuse */ 913 break; 914 } 915 lbolt = ddi_get_lbolt(); 916 if (lbolt > conn_login_max) { 917 /* 918 * Connection retry timeout, 919 * failed connect to target. 920 */ 921 break; 922 } 923 if (lbolt < conn_login_interval) { 924 if ((rc == EINPROGRESS) || (rc == EALREADY)) { 925 /* TCP connect still in progress */ 926 delay(SEC_TO_TICK(IN_PROGRESS_DELAY)); 927 continue; 928 } else { 929 delay(conn_login_interval - lbolt); 930 } 931 } 932 conn_login_interval = ddi_get_lbolt() + 933 SEC_TO_TICK(ic->ic_conn_params.conn_login_interval); 934 } while (rc != 0); 935 /* resume to nonblock mode */ 936 if (rc == IDM_STATUS_SUCCESS) { 937 idm_so_socket_set_block(node); 938 } 939 } else { 940 rc = ksocket_connect(so_conn->ic_so, &ic->ic_ini_dst_addr.sin, 941 (SIZEOF_SOCKADDR(&ic->ic_ini_dst_addr.sin)), CRED()); 942 } 943 944 if (rc != 0) { 945 idm_soshutdown(so_conn->ic_so); 946 return (IDM_STATUS_FAIL); 947 } 948 949 idm_so_conn_connect_common(ic); 950 951 idm_set_postconnect_options(so_conn->ic_so); 952 953 return (IDM_STATUS_SUCCESS); 954 } 955 956 idm_status_t 957 idm_so_tgt_conn_create(idm_conn_t *ic, ksocket_t new_so) 958 { 959 idm_status_t idmrc; 960 961 idm_set_postconnect_options(new_so); 962 idmrc = idm_so_conn_create_common(ic, new_so); 963 964 return (idmrc); 965 } 966 967 static void 968 idm_so_tgt_conn_destroy(idm_conn_t *ic) 969 { 970 idm_so_conn_destroy_common(ic); 971 } 972 973 /* 974 * idm_so_tgt_conn_connect() 975 * Establish the connection in ic, passed from idm_tgt_conn_finish(), which 976 * is invoked from the SM as a result of an inbound connection request. 977 */ 978 static idm_status_t 979 idm_so_tgt_conn_connect(idm_conn_t *ic) 980 { 981 idm_so_conn_connect_common(ic); 982 983 return (IDM_STATUS_SUCCESS); 984 } 985 986 static idm_status_t 987 idm_so_conn_create_common(idm_conn_t *ic, ksocket_t new_so) 988 { 989 idm_so_conn_t *so_conn; 990 991 so_conn = kmem_zalloc(sizeof (idm_so_conn_t), KM_SLEEP); 992 so_conn->ic_so = new_so; 993 994 ic->ic_transport_private = so_conn; 995 ic->ic_transport_hdrlen = 0; 996 997 /* Set the scoreboarding flag on this connection */ 998 ic->ic_conn_flags |= IDM_CONN_USE_SCOREBOARD; 999 ic->ic_conn_params.max_recv_dataseglen = 1000 ISCSI_DEFAULT_MAX_RECV_SEG_LEN; 1001 ic->ic_conn_params.max_xmit_dataseglen = 1002 ISCSI_DEFAULT_MAX_XMIT_SEG_LEN; 1003 1004 /* 1005 * Initialize tx thread mutex and list 1006 */ 1007 mutex_init(&so_conn->ic_tx_mutex, NULL, MUTEX_DEFAULT, NULL); 1008 cv_init(&so_conn->ic_tx_cv, NULL, CV_DEFAULT, NULL); 1009 list_create(&so_conn->ic_tx_list, sizeof (idm_pdu_t), 1010 offsetof(idm_pdu_t, idm_tx_link)); 1011 1012 return (IDM_STATUS_SUCCESS); 1013 } 1014 1015 static void 1016 idm_so_conn_destroy_common(idm_conn_t *ic) 1017 { 1018 idm_so_conn_t *so_conn = ic->ic_transport_private; 1019 1020 ic->ic_transport_private = NULL; 1021 idm_sodestroy(so_conn->ic_so); 1022 list_destroy(&so_conn->ic_tx_list); 1023 mutex_destroy(&so_conn->ic_tx_mutex); 1024 cv_destroy(&so_conn->ic_tx_cv); 1025 1026 kmem_free(so_conn, sizeof (idm_so_conn_t)); 1027 } 1028 1029 static void 1030 idm_so_conn_connect_common(idm_conn_t *ic) 1031 { 1032 idm_so_conn_t *so_conn; 1033 struct sockaddr_in6 t_addr; 1034 socklen_t t_addrlen = 0; 1035 1036 so_conn = ic->ic_transport_private; 1037 bzero(&t_addr, sizeof (struct sockaddr_in6)); 1038 t_addrlen = sizeof (struct sockaddr_in6); 1039 1040 /* Set the local and remote addresses in the idm conn handle */ 1041 (void) ksocket_getsockname(so_conn->ic_so, (struct sockaddr *)&t_addr, 1042 &t_addrlen, CRED()); 1043 bcopy(&t_addr, &ic->ic_laddr, t_addrlen); 1044 (void) ksocket_getpeername(so_conn->ic_so, (struct sockaddr *)&t_addr, 1045 &t_addrlen, CRED()); 1046 bcopy(&t_addr, &ic->ic_raddr, t_addrlen); 1047 1048 mutex_enter(&ic->ic_mutex); 1049 so_conn->ic_tx_thread = thread_create(NULL, 0, idm_sotx_thread, ic, 0, 1050 &p0, TS_RUN, minclsyspri); 1051 so_conn->ic_rx_thread = thread_create(NULL, 0, idm_sorx_thread, ic, 0, 1052 &p0, TS_RUN, minclsyspri); 1053 1054 while (so_conn->ic_rx_thread_did == 0 || 1055 so_conn->ic_tx_thread_did == 0) 1056 cv_wait(&ic->ic_cv, &ic->ic_mutex); 1057 mutex_exit(&ic->ic_mutex); 1058 } 1059 1060 /* 1061 * idm_so_conn_disconnect() 1062 * Shutdown the socket connection and stop the thread 1063 */ 1064 static void 1065 idm_so_conn_disconnect(idm_conn_t *ic) 1066 { 1067 idm_so_conn_t *so_conn; 1068 1069 so_conn = ic->ic_transport_private; 1070 1071 mutex_enter(&ic->ic_mutex); 1072 so_conn->ic_rx_thread_running = B_FALSE; 1073 so_conn->ic_tx_thread_running = B_FALSE; 1074 /* We need to wakeup the TX thread */ 1075 mutex_enter(&so_conn->ic_tx_mutex); 1076 cv_signal(&so_conn->ic_tx_cv); 1077 mutex_exit(&so_conn->ic_tx_mutex); 1078 mutex_exit(&ic->ic_mutex); 1079 1080 /* This should wakeup the RX thread if it is sleeping */ 1081 idm_soshutdown(so_conn->ic_so); 1082 1083 thread_join(so_conn->ic_tx_thread_did); 1084 thread_join(so_conn->ic_rx_thread_did); 1085 } 1086 1087 /* 1088 * idm_so_tgt_svc_create() 1089 * Establish a service on an IP address and port. idm_svc_req_t contains 1090 * the service parameters. 1091 */ 1092 /*ARGSUSED*/ 1093 static idm_status_t 1094 idm_so_tgt_svc_create(idm_svc_req_t *sr, idm_svc_t *is) 1095 { 1096 idm_so_svc_t *so_svc; 1097 1098 so_svc = kmem_zalloc(sizeof (idm_so_svc_t), KM_SLEEP); 1099 1100 /* Set the new sockets service in svc handle */ 1101 is->is_so_svc = (void *)so_svc; 1102 1103 return (IDM_STATUS_SUCCESS); 1104 } 1105 1106 /* 1107 * idm_so_tgt_svc_destroy() 1108 * Teardown sockets resources allocated in idm_so_tgt_svc_create() 1109 */ 1110 static void 1111 idm_so_tgt_svc_destroy(idm_svc_t *is) 1112 { 1113 /* the socket will have been torn down; free the service */ 1114 kmem_free(is->is_so_svc, sizeof (idm_so_svc_t)); 1115 } 1116 1117 /* 1118 * idm_so_tgt_svc_online() 1119 * Launch a watch thread on the svc allocated in idm_so_tgt_svc_create() 1120 */ 1121 1122 static idm_status_t 1123 idm_so_tgt_svc_online(idm_svc_t *is) 1124 { 1125 idm_so_svc_t *so_svc; 1126 idm_svc_req_t *sr = &is->is_svc_req; 1127 struct sockaddr_in6 sin6_ip; 1128 const uint32_t on = 1; 1129 const uint32_t off = 0; 1130 1131 mutex_enter(&is->is_mutex); 1132 so_svc = (idm_so_svc_t *)is->is_so_svc; 1133 1134 /* 1135 * Try creating an IPv6 socket first 1136 */ 1137 if ((so_svc->is_so = idm_socreate(PF_INET6, SOCK_STREAM, 0)) == NULL) { 1138 mutex_exit(&is->is_mutex); 1139 return (IDM_STATUS_FAIL); 1140 } else { 1141 bzero(&sin6_ip, sizeof (sin6_ip)); 1142 sin6_ip.sin6_family = AF_INET6; 1143 sin6_ip.sin6_port = htons(sr->sr_port); 1144 sin6_ip.sin6_addr = in6addr_any; 1145 1146 (void) ksocket_setsockopt(so_svc->is_so, SOL_SOCKET, 1147 SO_REUSEADDR, (char *)&on, sizeof (on), CRED()); 1148 /* 1149 * Turn off SO_MAC_EXEMPT so future sobinds succeed 1150 */ 1151 (void) ksocket_setsockopt(so_svc->is_so, SOL_SOCKET, 1152 SO_MAC_EXEMPT, (char *)&off, sizeof (off), CRED()); 1153 1154 if (ksocket_bind(so_svc->is_so, (struct sockaddr *)&sin6_ip, 1155 sizeof (sin6_ip), CRED()) != 0) { 1156 mutex_exit(&is->is_mutex); 1157 idm_sodestroy(so_svc->is_so); 1158 return (IDM_STATUS_FAIL); 1159 } 1160 } 1161 1162 idm_set_postconnect_options(so_svc->is_so); 1163 1164 if (ksocket_listen(so_svc->is_so, 5, CRED()) != 0) { 1165 mutex_exit(&is->is_mutex); 1166 idm_soshutdown(so_svc->is_so); 1167 idm_sodestroy(so_svc->is_so); 1168 return (IDM_STATUS_FAIL); 1169 } 1170 1171 /* Launch a watch thread */ 1172 so_svc->is_thread = thread_create(NULL, 0, idm_so_svc_port_watcher, 1173 is, 0, &p0, TS_RUN, minclsyspri); 1174 1175 if (so_svc->is_thread == NULL) { 1176 /* Failure to launch; teardown the socket */ 1177 mutex_exit(&is->is_mutex); 1178 idm_soshutdown(so_svc->is_so); 1179 idm_sodestroy(so_svc->is_so); 1180 return (IDM_STATUS_FAIL); 1181 } 1182 ksocket_hold(so_svc->is_so); 1183 /* Wait for the port watcher thread to start */ 1184 while (!so_svc->is_thread_running) 1185 cv_wait(&is->is_cv, &is->is_mutex); 1186 mutex_exit(&is->is_mutex); 1187 1188 return (IDM_STATUS_SUCCESS); 1189 } 1190 1191 /* 1192 * idm_so_tgt_svc_offline 1193 * 1194 * Stop listening on the IP address and port identified by idm_svc_t. 1195 */ 1196 static void 1197 idm_so_tgt_svc_offline(idm_svc_t *is) 1198 { 1199 idm_so_svc_t *so_svc; 1200 mutex_enter(&is->is_mutex); 1201 so_svc = (idm_so_svc_t *)is->is_so_svc; 1202 so_svc->is_thread_running = B_FALSE; 1203 mutex_exit(&is->is_mutex); 1204 1205 /* 1206 * Teardown socket 1207 */ 1208 idm_sodestroy(so_svc->is_so); 1209 1210 /* 1211 * Now we expect the port watcher thread to terminate 1212 */ 1213 thread_join(so_svc->is_thread_did); 1214 } 1215 1216 /* 1217 * Watch thread for target service connection establishment. 1218 */ 1219 void 1220 idm_so_svc_port_watcher(void *arg) 1221 { 1222 idm_svc_t *svc = arg; 1223 ksocket_t new_so; 1224 idm_conn_t *ic; 1225 idm_status_t idmrc; 1226 idm_so_svc_t *so_svc; 1227 int rc; 1228 const uint32_t off = 0; 1229 struct sockaddr_in6 t_addr; 1230 socklen_t t_addrlen; 1231 1232 bzero(&t_addr, sizeof (struct sockaddr_in6)); 1233 t_addrlen = sizeof (struct sockaddr_in6); 1234 mutex_enter(&svc->is_mutex); 1235 1236 so_svc = svc->is_so_svc; 1237 so_svc->is_thread_running = B_TRUE; 1238 so_svc->is_thread_did = so_svc->is_thread->t_did; 1239 1240 cv_signal(&svc->is_cv); 1241 1242 IDM_SVC_LOG(CE_NOTE, "iSCSI service (%p/%d) online", (void *)svc, 1243 svc->is_svc_req.sr_port); 1244 1245 while (so_svc->is_thread_running) { 1246 mutex_exit(&svc->is_mutex); 1247 1248 if ((rc = ksocket_accept(so_svc->is_so, 1249 (struct sockaddr *)&t_addr, &t_addrlen, 1250 &new_so, CRED())) != 0) { 1251 mutex_enter(&svc->is_mutex); 1252 if (rc == ECONNABORTED) 1253 continue; 1254 /* Connection problem */ 1255 break; 1256 } 1257 /* 1258 * Turn off SO_MAC_EXEMPT so future sobinds succeed 1259 */ 1260 (void) ksocket_setsockopt(new_so, SOL_SOCKET, SO_MAC_EXEMPT, 1261 (char *)&off, sizeof (off), CRED()); 1262 1263 idmrc = idm_svc_conn_create(svc, IDM_TRANSPORT_TYPE_SOCKETS, 1264 &ic); 1265 if (idmrc != IDM_STATUS_SUCCESS) { 1266 /* Drop connection */ 1267 idm_soshutdown(new_so); 1268 idm_sodestroy(new_so); 1269 mutex_enter(&svc->is_mutex); 1270 continue; 1271 } 1272 1273 idmrc = idm_so_tgt_conn_create(ic, new_so); 1274 if (idmrc != IDM_STATUS_SUCCESS) { 1275 idm_svc_conn_destroy(ic); 1276 idm_soshutdown(new_so); 1277 idm_sodestroy(new_so); 1278 mutex_enter(&svc->is_mutex); 1279 continue; 1280 } 1281 1282 /* 1283 * Kick the state machine. At CS_S3_XPT_UP the state machine 1284 * will notify the client (target) about the new connection. 1285 */ 1286 idm_conn_event(ic, CE_CONNECT_ACCEPT, NULL); 1287 1288 mutex_enter(&svc->is_mutex); 1289 } 1290 ksocket_rele(so_svc->is_so); 1291 so_svc->is_thread_running = B_FALSE; 1292 mutex_exit(&svc->is_mutex); 1293 1294 IDM_SVC_LOG(CE_NOTE, "iSCSI service (%p/%d) offline", (void *)svc, 1295 svc->is_svc_req.sr_port); 1296 1297 thread_exit(); 1298 } 1299 1300 /* 1301 * idm_so_free_task_rsrc() stops any ongoing processing of the task and 1302 * frees resources associated with the task. 1303 * 1304 * It's not clear that this should return idm_status_t. What do we do 1305 * if it fails? 1306 */ 1307 static idm_status_t 1308 idm_so_free_task_rsrc(idm_task_t *idt) 1309 { 1310 idm_buf_t *idb, *next_idb; 1311 1312 /* 1313 * There is nothing to cleanup on initiator connections 1314 */ 1315 if (IDM_CONN_ISINI(idt->idt_ic)) 1316 return (IDM_STATUS_SUCCESS); 1317 1318 /* 1319 * If this is a target connection, call idm_buf_rx_from_ini_done for 1320 * any buffer on the "outbufv" list with idb->idb_in_transport==B_TRUE. 1321 * 1322 * In addition, remove any buffers associated with this task from 1323 * the ic_tx_list. We'll do this by walking the idt_inbufv list, but 1324 * items don't actually get removed from that list (and completion 1325 * routines called) until idm_task_cleanup. 1326 */ 1327 mutex_enter(&idt->idt_mutex); 1328 1329 for (idb = list_head(&idt->idt_outbufv); idb != NULL; idb = next_idb) { 1330 next_idb = list_next(&idt->idt_outbufv, idb); 1331 if (idb->idb_in_transport) { 1332 /* 1333 * idm_buf_rx_from_ini_done releases idt->idt_mutex 1334 */ 1335 DTRACE_ISCSI_8(xfer__done, idm_conn_t *, idt->idt_ic, 1336 uintptr_t, idb->idb_buf, 1337 uint32_t, idb->idb_bufoffset, 1338 uint64_t, 0, uint32_t, 0, uint32_t, 0, 1339 uint32_t, idb->idb_xfer_len, 1340 int, XFER_BUF_RX_FROM_INI); 1341 idm_buf_rx_from_ini_done(idt, idb, IDM_STATUS_ABORTED); 1342 mutex_enter(&idt->idt_mutex); 1343 } 1344 } 1345 1346 for (idb = list_head(&idt->idt_inbufv); idb != NULL; idb = next_idb) { 1347 next_idb = list_next(&idt->idt_inbufv, idb); 1348 /* 1349 * We want to remove these items from the tx_list as well, 1350 * but knowing it's in the idt_inbufv list is not a guarantee 1351 * that it's in the tx_list. If it's on the tx list then 1352 * let idm_sotx_thread() clean it up. 1353 */ 1354 if (idb->idb_in_transport && !idb->idb_tx_thread) { 1355 /* 1356 * idm_buf_tx_to_ini_done releases idt->idt_mutex 1357 */ 1358 DTRACE_ISCSI_8(xfer__done, idm_conn_t *, idt->idt_ic, 1359 uintptr_t, idb->idb_buf, 1360 uint32_t, idb->idb_bufoffset, 1361 uint64_t, 0, uint32_t, 0, uint32_t, 0, 1362 uint32_t, idb->idb_xfer_len, 1363 int, XFER_BUF_TX_TO_INI); 1364 idm_buf_tx_to_ini_done(idt, idb, IDM_STATUS_ABORTED); 1365 mutex_enter(&idt->idt_mutex); 1366 } 1367 } 1368 1369 mutex_exit(&idt->idt_mutex); 1370 1371 return (IDM_STATUS_SUCCESS); 1372 } 1373 1374 /* 1375 * idm_so_negotiate_key_values() validates the key values for this connection 1376 */ 1377 /* ARGSUSED */ 1378 static kv_status_t 1379 idm_so_negotiate_key_values(idm_conn_t *it, nvlist_t *request_nvl, 1380 nvlist_t *response_nvl, nvlist_t *negotiated_nvl) 1381 { 1382 /* All parameters are negotiated at the iscsit level */ 1383 return (KV_HANDLED); 1384 } 1385 1386 /* 1387 * idm_so_notice_key_values() activates the negotiated key values for 1388 * this connection. 1389 */ 1390 static void 1391 idm_so_notice_key_values(idm_conn_t *it, nvlist_t *negotiated_nvl) 1392 { 1393 char *nvp_name; 1394 nvpair_t *nvp; 1395 nvpair_t *next_nvp; 1396 int nvrc; 1397 idm_status_t idm_status; 1398 const idm_kv_xlate_t *ikvx; 1399 uint64_t num_val; 1400 1401 for (nvp = nvlist_next_nvpair(negotiated_nvl, NULL); 1402 nvp != NULL; nvp = next_nvp) { 1403 next_nvp = nvlist_next_nvpair(negotiated_nvl, nvp); 1404 nvp_name = nvpair_name(nvp); 1405 1406 ikvx = idm_lookup_kv_xlate(nvp_name, strlen(nvp_name)); 1407 switch (ikvx->ik_key_id) { 1408 case KI_HEADER_DIGEST: 1409 case KI_DATA_DIGEST: 1410 idm_status = idm_so_handle_digest(it, nvp, ikvx); 1411 ASSERT(idm_status == 0); 1412 1413 /* Remove processed item from negotiated_nvl list */ 1414 nvrc = nvlist_remove_all( 1415 negotiated_nvl, ikvx->ik_key_name); 1416 ASSERT(nvrc == 0); 1417 break; 1418 case KI_MAX_RECV_DATA_SEGMENT_LENGTH: 1419 /* 1420 * Just pass the value down to idm layer. 1421 * No need to remove it from negotiated_nvl list here. 1422 */ 1423 nvrc = nvpair_value_uint64(nvp, &num_val); 1424 ASSERT(nvrc == 0); 1425 it->ic_conn_params.max_xmit_dataseglen = 1426 (uint32_t)num_val; 1427 break; 1428 default: 1429 break; 1430 } 1431 } 1432 } 1433 1434 /* 1435 * idm_so_declare_key_values() declares the key values for this connection 1436 */ 1437 /* ARGSUSED */ 1438 static kv_status_t 1439 idm_so_declare_key_values(idm_conn_t *it, nvlist_t *config_nvl, 1440 nvlist_t *outgoing_nvl) 1441 { 1442 char *nvp_name; 1443 nvpair_t *nvp; 1444 nvpair_t *next_nvp; 1445 kv_status_t kvrc; 1446 int nvrc = 0; 1447 const idm_kv_xlate_t *ikvx; 1448 uint64_t num_val; 1449 1450 for (nvp = nvlist_next_nvpair(config_nvl, NULL); 1451 nvp != NULL && nvrc == 0; nvp = next_nvp) { 1452 next_nvp = nvlist_next_nvpair(config_nvl, nvp); 1453 nvp_name = nvpair_name(nvp); 1454 1455 ikvx = idm_lookup_kv_xlate(nvp_name, strlen(nvp_name)); 1456 switch (ikvx->ik_key_id) { 1457 case KI_MAX_RECV_DATA_SEGMENT_LENGTH: 1458 if ((nvrc = nvpair_value_uint64(nvp, &num_val)) != 0) { 1459 break; 1460 } 1461 if (outgoing_nvl && 1462 (nvrc = nvlist_add_uint64(outgoing_nvl, 1463 nvp_name, num_val)) != 0) { 1464 break; 1465 } 1466 it->ic_conn_params.max_recv_dataseglen = 1467 (uint32_t)num_val; 1468 break; 1469 default: 1470 break; 1471 } 1472 } 1473 kvrc = idm_nvstat_to_kvstat(nvrc); 1474 return (kvrc); 1475 } 1476 1477 static idm_status_t 1478 idm_so_handle_digest(idm_conn_t *it, nvpair_t *digest_choice, 1479 const idm_kv_xlate_t *ikvx) 1480 { 1481 int nvrc; 1482 char *digest_choice_string; 1483 1484 nvrc = nvpair_value_string(digest_choice, 1485 &digest_choice_string); 1486 ASSERT(nvrc == 0); 1487 if (strcasecmp(digest_choice_string, "crc32c") == 0) { 1488 switch (ikvx->ik_key_id) { 1489 case KI_HEADER_DIGEST: 1490 it->ic_conn_flags |= IDM_CONN_HEADER_DIGEST; 1491 break; 1492 case KI_DATA_DIGEST: 1493 it->ic_conn_flags |= IDM_CONN_DATA_DIGEST; 1494 break; 1495 default: 1496 ASSERT(0); 1497 break; 1498 } 1499 } else if (strcasecmp(digest_choice_string, "none") == 0) { 1500 switch (ikvx->ik_key_id) { 1501 case KI_HEADER_DIGEST: 1502 it->ic_conn_flags &= ~IDM_CONN_HEADER_DIGEST; 1503 break; 1504 case KI_DATA_DIGEST: 1505 it->ic_conn_flags &= ~IDM_CONN_DATA_DIGEST; 1506 break; 1507 default: 1508 ASSERT(0); 1509 break; 1510 } 1511 } else { 1512 ASSERT(0); 1513 } 1514 1515 return (IDM_STATUS_SUCCESS); 1516 } 1517 1518 1519 /* 1520 * idm_so_conn_is_capable() verifies that the passed connection is provided 1521 * for by the sockets interface. 1522 */ 1523 /* ARGSUSED */ 1524 static boolean_t 1525 idm_so_conn_is_capable(idm_conn_req_t *ic, idm_transport_caps_t *caps) 1526 { 1527 return (B_TRUE); 1528 } 1529 1530 /* 1531 * idm_so_rx_datain() validates the Data Sequence number of the PDU. The 1532 * idm_sorecv_scsidata() function invoked earlier actually reads the data 1533 * off the socket into the appropriate buffers. 1534 */ 1535 static void 1536 idm_so_rx_datain(idm_conn_t *ic, idm_pdu_t *pdu) 1537 { 1538 iscsi_data_hdr_t *bhs; 1539 idm_task_t *idt; 1540 idm_buf_t *idb; 1541 uint32_t datasn; 1542 size_t offset; 1543 iscsi_hdr_t *ihp = (iscsi_hdr_t *)pdu->isp_hdr; 1544 iscsi_data_rsp_hdr_t *idrhp = (iscsi_data_rsp_hdr_t *)ihp; 1545 1546 ASSERT(ic != NULL); 1547 ASSERT(pdu != NULL); 1548 1549 bhs = (iscsi_data_hdr_t *)pdu->isp_hdr; 1550 datasn = ntohl(bhs->datasn); 1551 offset = ntohl(bhs->offset); 1552 1553 ASSERT(bhs->opcode == ISCSI_OP_SCSI_DATA_RSP); 1554 1555 /* 1556 * Look up the task corresponding to the initiator task tag 1557 * to get the buffers affiliated with the task. 1558 */ 1559 idt = idm_task_find(ic, bhs->itt, bhs->ttt); 1560 if (idt == NULL) { 1561 IDM_CONN_LOG(CE_WARN, "idm_so_rx_datain: failed to find task"); 1562 idm_pdu_rx_protocol_error(ic, pdu); 1563 return; 1564 } 1565 1566 idb = pdu->isp_sorx_buf; 1567 if (idb == NULL) { 1568 IDM_CONN_LOG(CE_WARN, 1569 "idm_so_rx_datain: failed to find buffer"); 1570 idm_task_rele(idt); 1571 idm_pdu_rx_protocol_error(ic, pdu); 1572 return; 1573 } 1574 1575 /* 1576 * DataSN values should be sequential and should not have any gaps or 1577 * repetitions. Check the DataSN with the one stored in the task. 1578 */ 1579 if (datasn == idt->idt_exp_datasn) { 1580 idt->idt_exp_datasn++; /* keep track of DataSN received */ 1581 } else { 1582 IDM_CONN_LOG(CE_WARN, "idm_so_rx_datain: datasn out of order"); 1583 idm_task_rele(idt); 1584 idm_pdu_rx_protocol_error(ic, pdu); 1585 return; 1586 } 1587 1588 /* 1589 * PDUs in a sequence should be in continuously increasing 1590 * address offset 1591 */ 1592 if (offset != idb->idb_exp_offset) { 1593 IDM_CONN_LOG(CE_WARN, "idm_so_rx_datain: unexpected offset"); 1594 idm_task_rele(idt); 1595 idm_pdu_rx_protocol_error(ic, pdu); 1596 return; 1597 } 1598 /* Expected next relative buffer offset */ 1599 idb->idb_exp_offset += n2h24(bhs->dlength); 1600 idt->idt_rx_bytes += n2h24(bhs->dlength); 1601 1602 idm_task_rele(idt); 1603 1604 /* 1605 * For now call scsi_rsp which will process the data rsp 1606 * Revisit, need to provide an explicit client entry point for 1607 * phase collapse completions. 1608 */ 1609 if (((ihp->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_SCSI_DATA_RSP) && 1610 (idrhp->flags & ISCSI_FLAG_DATA_STATUS)) { 1611 (*ic->ic_conn_ops.icb_rx_scsi_rsp)(ic, pdu); 1612 } 1613 1614 idm_pdu_complete(pdu, IDM_STATUS_SUCCESS); 1615 } 1616 1617 /* 1618 * The idm_so_rx_dataout() function is used by the iSCSI target to read 1619 * data from the Data-Out PDU sent by the iSCSI initiator. 1620 * 1621 * This function gets the Initiator Task Tag from the PDU BHS and looks up the 1622 * task to get the buffers associated with the PDU. A PDU might span buffers. 1623 * The data is then read into the respective buffer. 1624 */ 1625 static void 1626 idm_so_rx_dataout(idm_conn_t *ic, idm_pdu_t *pdu) 1627 { 1628 1629 iscsi_data_hdr_t *bhs; 1630 idm_task_t *idt; 1631 idm_buf_t *idb; 1632 size_t offset; 1633 1634 ASSERT(ic != NULL); 1635 ASSERT(pdu != NULL); 1636 1637 bhs = (iscsi_data_hdr_t *)pdu->isp_hdr; 1638 offset = ntohl(bhs->offset); 1639 ASSERT(bhs->opcode == ISCSI_OP_SCSI_DATA); 1640 1641 /* 1642 * Look up the task corresponding to the initiator task tag 1643 * to get the buffers affiliated with the task. 1644 */ 1645 idt = idm_task_find(ic, bhs->itt, bhs->ttt); 1646 if (idt == NULL) { 1647 IDM_CONN_LOG(CE_WARN, 1648 "idm_so_rx_dataout: failed to find task"); 1649 idm_pdu_rx_protocol_error(ic, pdu); 1650 return; 1651 } 1652 1653 idb = pdu->isp_sorx_buf; 1654 if (idb == NULL) { 1655 IDM_CONN_LOG(CE_WARN, 1656 "idm_so_rx_dataout: failed to find buffer"); 1657 idm_task_rele(idt); 1658 idm_pdu_rx_protocol_error(ic, pdu); 1659 return; 1660 } 1661 1662 /* Keep track of data transferred - check data offsets */ 1663 if (offset != idb->idb_exp_offset) { 1664 IDM_CONN_LOG(CE_NOTE, "idm_so_rx_dataout: offset out of seq: " 1665 "%ld, %d", offset, idb->idb_exp_offset); 1666 idm_task_rele(idt); 1667 idm_pdu_rx_protocol_error(ic, pdu); 1668 return; 1669 } 1670 /* Expected next relative offset */ 1671 idb->idb_exp_offset += ntoh24(bhs->dlength); 1672 idt->idt_rx_bytes += n2h24(bhs->dlength); 1673 1674 /* 1675 * Call the buffer callback when the transfer is complete 1676 * 1677 * The connection state machine should only abort tasks after 1678 * shutting down the connection so we are assured that there 1679 * won't be a simultaneous attempt to abort this task at the 1680 * same time as we are processing this PDU (due to a connection 1681 * state change). 1682 */ 1683 if (bhs->flags & ISCSI_FLAG_FINAL) { 1684 /* 1685 * We only want to call idm_buf_rx_from_ini_done once 1686 * per transfer. It's possible that this task has 1687 * already been aborted in which case 1688 * idm_so_free_task_rsrc will call idm_buf_rx_from_ini_done 1689 * for each buffer with idb_in_transport==B_TRUE. To 1690 * close this window and ensure that this doesn't happen, 1691 * we'll clear idb->idb_in_transport now while holding 1692 * the task mutex. This is only really an issue for 1693 * SCSI task abort -- if tasks were being aborted because 1694 * of a connection state change the state machine would 1695 * have already stopped the receive thread. 1696 */ 1697 mutex_enter(&idt->idt_mutex); 1698 1699 /* 1700 * Release the task hold here (obtained in idm_task_find) 1701 * because the task may complete synchronously during 1702 * idm_buf_rx_from_ini_done. Since we still have an active 1703 * buffer we know there is at least one additional hold on idt. 1704 */ 1705 idm_task_rele(idt); 1706 1707 /* 1708 * idm_buf_rx_from_ini_done releases idt->idt_mutex 1709 */ 1710 DTRACE_ISCSI_8(xfer__done, idm_conn_t *, idt->idt_ic, 1711 uintptr_t, idb->idb_buf, uint32_t, idb->idb_bufoffset, 1712 uint64_t, 0, uint32_t, 0, uint32_t, 0, 1713 uint32_t, idb->idb_xfer_len, 1714 int, XFER_BUF_RX_FROM_INI); 1715 idm_buf_rx_from_ini_done(idt, idb, IDM_STATUS_SUCCESS); 1716 idm_pdu_complete(pdu, IDM_STATUS_SUCCESS); 1717 return; 1718 } 1719 1720 idm_task_rele(idt); 1721 idm_pdu_complete(pdu, IDM_STATUS_SUCCESS); 1722 } 1723 1724 /* 1725 * The idm_so_rx_rtt() function is used by the iSCSI initiator to handle 1726 * the R2T PDU sent by the iSCSI target indicating that it is ready to 1727 * accept data. This gets the Initiator Task Tag (itt) from the PDU BHS 1728 * and looks up the task in the task tree using the itt to get the output 1729 * buffers associated the task. The R2T PDU contains the offset of the 1730 * requested data and the data length. This function then constructs a 1731 * sequence of iSCSI PDUs and outputs the requested data. Each Data-Out 1732 * PDU is associated with the R2T by the Target Transfer Tag (ttt). 1733 */ 1734 1735 static void 1736 idm_so_rx_rtt(idm_conn_t *ic, idm_pdu_t *pdu) 1737 { 1738 idm_task_t *idt; 1739 idm_buf_t *idb; 1740 iscsi_rtt_hdr_t *rtt_hdr; 1741 uint32_t data_offset; 1742 uint32_t data_length; 1743 1744 ASSERT(ic != NULL); 1745 ASSERT(pdu != NULL); 1746 1747 rtt_hdr = (iscsi_rtt_hdr_t *)pdu->isp_hdr; 1748 data_offset = ntohl(rtt_hdr->data_offset); 1749 data_length = ntohl(rtt_hdr->data_length); 1750 idt = idm_task_find(ic, rtt_hdr->itt, rtt_hdr->ttt); 1751 1752 if (idt == NULL) { 1753 IDM_CONN_LOG(CE_WARN, "idm_so_rx_rtt: could not find task"); 1754 idm_pdu_rx_protocol_error(ic, pdu); 1755 return; 1756 } 1757 1758 /* Find the buffer bound to the task by the iSCSI initiator */ 1759 mutex_enter(&idt->idt_mutex); 1760 idb = idm_buf_find(&idt->idt_outbufv, data_offset); 1761 if (idb == NULL) { 1762 mutex_exit(&idt->idt_mutex); 1763 idm_task_rele(idt); 1764 IDM_CONN_LOG(CE_WARN, "idm_so_rx_rtt: could not find buffer"); 1765 idm_pdu_rx_protocol_error(ic, pdu); 1766 return; 1767 } 1768 1769 /* return buffer contains this data */ 1770 if (data_offset + data_length > idb->idb_buflen) { 1771 /* Overflow */ 1772 mutex_exit(&idt->idt_mutex); 1773 idm_task_rele(idt); 1774 IDM_CONN_LOG(CE_WARN, "idm_so_rx_rtt: read from outside " 1775 "buffer"); 1776 idm_pdu_rx_protocol_error(ic, pdu); 1777 return; 1778 } 1779 1780 idt->idt_r2t_ttt = rtt_hdr->ttt; 1781 idt->idt_exp_datasn = 0; 1782 1783 idm_so_send_rtt_data(ic, idt, idb, data_offset, 1784 ntohl(rtt_hdr->data_length)); 1785 /* 1786 * the idt_mutex is released in idm_so_send_rtt_data 1787 */ 1788 1789 idm_pdu_complete(pdu, IDM_STATUS_SUCCESS); 1790 idm_task_rele(idt); 1791 1792 } 1793 1794 idm_status_t 1795 idm_sorecvdata(idm_conn_t *ic, idm_pdu_t *pdu) 1796 { 1797 uint8_t pad[ISCSI_PAD_WORD_LEN]; 1798 int pad_len; 1799 uint32_t data_digest_crc; 1800 uint32_t crc_calculated; 1801 int total_len; 1802 idm_so_conn_t *so_conn; 1803 1804 so_conn = ic->ic_transport_private; 1805 1806 pad_len = ((ISCSI_PAD_WORD_LEN - 1807 (pdu->isp_datalen & (ISCSI_PAD_WORD_LEN - 1))) & 1808 (ISCSI_PAD_WORD_LEN - 1)); 1809 1810 ASSERT(pdu->isp_iovlen < (PDU_MAX_IOVLEN - 2)); /* pad + data digest */ 1811 1812 total_len = pdu->isp_datalen; 1813 1814 if (pad_len) { 1815 pdu->isp_iov[pdu->isp_iovlen].iov_base = (char *)&pad; 1816 pdu->isp_iov[pdu->isp_iovlen].iov_len = pad_len; 1817 total_len += pad_len; 1818 pdu->isp_iovlen++; 1819 } 1820 1821 /* setup data digest */ 1822 if ((ic->ic_conn_flags & IDM_CONN_DATA_DIGEST) != 0) { 1823 pdu->isp_iov[pdu->isp_iovlen].iov_base = 1824 (char *)&data_digest_crc; 1825 pdu->isp_iov[pdu->isp_iovlen].iov_len = 1826 sizeof (data_digest_crc); 1827 total_len += sizeof (data_digest_crc); 1828 pdu->isp_iovlen++; 1829 } 1830 1831 pdu->isp_data = (uint8_t *)(uintptr_t)pdu->isp_iov[0].iov_base; 1832 1833 if (idm_iov_sorecv(so_conn->ic_so, &pdu->isp_iov[0], 1834 pdu->isp_iovlen, total_len) != 0) { 1835 return (IDM_STATUS_IO); 1836 } 1837 1838 if ((ic->ic_conn_flags & IDM_CONN_DATA_DIGEST) != 0) { 1839 crc_calculated = idm_crc32c(pdu->isp_data, 1840 pdu->isp_datalen); 1841 if (pad_len) { 1842 crc_calculated = idm_crc32c_continued((char *)&pad, 1843 pad_len, crc_calculated); 1844 } 1845 if (crc_calculated != data_digest_crc) { 1846 IDM_CONN_LOG(CE_WARN, 1847 "idm_sorecvdata: " 1848 "CRC error: actual 0x%x, calc 0x%x", 1849 data_digest_crc, crc_calculated); 1850 1851 /* Invalid Data Digest */ 1852 return (IDM_STATUS_DATA_DIGEST); 1853 } 1854 } 1855 1856 return (IDM_STATUS_SUCCESS); 1857 } 1858 1859 /* 1860 * idm_sorecv_scsidata() is used to receive scsi data from the socket. The 1861 * Data-type PDU header must be read into the idm_pdu_t structure prior to 1862 * calling this function. 1863 */ 1864 idm_status_t 1865 idm_sorecv_scsidata(idm_conn_t *ic, idm_pdu_t *pdu) 1866 { 1867 iscsi_data_hdr_t *bhs; 1868 idm_task_t *task; 1869 uint32_t offset; 1870 uint8_t opcode; 1871 uint32_t dlength; 1872 list_t *buflst; 1873 uint32_t xfer_bytes; 1874 idm_status_t status; 1875 1876 ASSERT(ic != NULL); 1877 ASSERT(pdu != NULL); 1878 1879 bhs = (iscsi_data_hdr_t *)pdu->isp_hdr; 1880 1881 offset = ntohl(bhs->offset); 1882 opcode = bhs->opcode; 1883 dlength = n2h24(bhs->dlength); 1884 1885 ASSERT((opcode == ISCSI_OP_SCSI_DATA_RSP) || 1886 (opcode == ISCSI_OP_SCSI_DATA)); 1887 1888 /* 1889 * Successful lookup implicitly gets a "hold" on the task. This 1890 * hold must be released before leaving this function. At one 1891 * point we were caching this task context and retaining the hold 1892 * but it turned out to be very difficult to release the hold properly. 1893 * The task can be aborted and the connection shutdown between this 1894 * call and the subsequent expected call to idm_so_rx_datain/ 1895 * idm_so_rx_dataout (in which case those functions are not called). 1896 * Releasing the hold in the PDU callback doesn't work well either 1897 * because the whole task may be completed by then at which point 1898 * it is too late to release the hold -- for better or worse this 1899 * code doesn't wait on the refcnts during normal operation. 1900 * idm_task_find() is very fast and it is not a huge burden if we 1901 * have to do it twice. 1902 */ 1903 task = idm_task_find(ic, bhs->itt, bhs->ttt); 1904 if (task == NULL) { 1905 IDM_CONN_LOG(CE_WARN, 1906 "idm_sorecv_scsidata: could not find task"); 1907 return (IDM_STATUS_FAIL); 1908 } 1909 1910 mutex_enter(&task->idt_mutex); 1911 buflst = (opcode == ISCSI_OP_SCSI_DATA_RSP) ? 1912 &task->idt_inbufv : &task->idt_outbufv; 1913 pdu->isp_sorx_buf = idm_buf_find(buflst, offset); 1914 mutex_exit(&task->idt_mutex); 1915 1916 if (pdu->isp_sorx_buf == NULL) { 1917 idm_task_rele(task); 1918 IDM_CONN_LOG(CE_WARN, "idm_sorecv_scsidata: could not find " 1919 "buffer for offset %x opcode=%x", 1920 offset, opcode); 1921 return (IDM_STATUS_FAIL); 1922 } 1923 1924 xfer_bytes = idm_fill_iov(pdu, pdu->isp_sorx_buf, offset, dlength); 1925 ASSERT(xfer_bytes != 0); 1926 if (xfer_bytes != dlength) { 1927 idm_task_rele(task); 1928 /* 1929 * Buffer overflow, connection error. The PDU data is still 1930 * sitting in the socket so we can't use the connection 1931 * again until that data is drained. 1932 */ 1933 return (IDM_STATUS_FAIL); 1934 } 1935 1936 status = idm_sorecvdata(ic, pdu); 1937 1938 idm_task_rele(task); 1939 1940 return (status); 1941 } 1942 1943 static uint32_t 1944 idm_fill_iov(idm_pdu_t *pdu, idm_buf_t *idb, uint32_t ro, uint32_t dlength) 1945 { 1946 uint32_t buf_ro = ro - idb->idb_bufoffset; 1947 uint32_t xfer_len = min(dlength, idb->idb_buflen - buf_ro); 1948 1949 ASSERT(ro >= idb->idb_bufoffset); 1950 1951 pdu->isp_iov[pdu->isp_iovlen].iov_base = 1952 (caddr_t)idb->idb_buf + buf_ro; 1953 pdu->isp_iov[pdu->isp_iovlen].iov_len = xfer_len; 1954 pdu->isp_iovlen++; 1955 1956 return (xfer_len); 1957 } 1958 1959 int 1960 idm_sorecv_nonscsidata(idm_conn_t *ic, idm_pdu_t *pdu) 1961 { 1962 pdu->isp_data = kmem_alloc(pdu->isp_datalen, KM_SLEEP); 1963 ASSERT(pdu->isp_data != NULL); 1964 1965 pdu->isp_databuflen = pdu->isp_datalen; 1966 pdu->isp_iov[0].iov_base = (caddr_t)pdu->isp_data; 1967 pdu->isp_iov[0].iov_len = pdu->isp_datalen; 1968 pdu->isp_iovlen = 1; 1969 /* 1970 * Since we are associating a new data buffer with this received 1971 * PDU we need to set a specific callback to free the data 1972 * after the PDU is processed. 1973 */ 1974 pdu->isp_flags |= IDM_PDU_ADDL_DATA; 1975 pdu->isp_callback = idm_sorx_addl_pdu_cb; 1976 1977 return (idm_sorecvdata(ic, pdu)); 1978 } 1979 1980 void 1981 idm_sorx_thread(void *arg) 1982 { 1983 boolean_t conn_failure = B_FALSE; 1984 idm_conn_t *ic = (idm_conn_t *)arg; 1985 idm_so_conn_t *so_conn; 1986 idm_pdu_t *pdu; 1987 idm_status_t rc; 1988 1989 idm_conn_hold(ic); 1990 1991 mutex_enter(&ic->ic_mutex); 1992 1993 so_conn = ic->ic_transport_private; 1994 so_conn->ic_rx_thread_running = B_TRUE; 1995 so_conn->ic_rx_thread_did = so_conn->ic_rx_thread->t_did; 1996 cv_signal(&ic->ic_cv); 1997 1998 while (so_conn->ic_rx_thread_running) { 1999 mutex_exit(&ic->ic_mutex); 2000 2001 /* 2002 * Get PDU with default header size (large enough for 2003 * BHS plus any anticipated AHS). PDU from 2004 * the cache will have all values set correctly 2005 * for sockets RX including callback. 2006 */ 2007 pdu = kmem_cache_alloc(idm.idm_sorx_pdu_cache, KM_SLEEP); 2008 pdu->isp_ic = ic; 2009 pdu->isp_flags = 0; 2010 pdu->isp_transport_hdrlen = 0; 2011 2012 if ((rc = idm_sorecvhdr(ic, pdu)) != 0) { 2013 /* 2014 * Call idm_pdu_complete so that we call the callback 2015 * and ensure any memory allocated in idm_sorecvhdr 2016 * gets freed up. 2017 */ 2018 idm_pdu_complete(pdu, IDM_STATUS_FAIL); 2019 2020 /* 2021 * If ic_rx_thread_running is still set then 2022 * this is some kind of connection problem 2023 * on the socket. In this case we want to 2024 * generate an event. Otherwise some other 2025 * thread closed the socket due to another 2026 * issue in which case we don't need to 2027 * generate an event. 2028 */ 2029 mutex_enter(&ic->ic_mutex); 2030 if (so_conn->ic_rx_thread_running) { 2031 conn_failure = B_TRUE; 2032 so_conn->ic_rx_thread_running = B_FALSE; 2033 } 2034 2035 continue; 2036 } 2037 2038 /* 2039 * Header has been read and validated. Now we need 2040 * to read the PDU data payload (if present). SCSI data 2041 * need to be transferred from the socket directly into 2042 * the associated transfer buffer for the SCSI task. 2043 */ 2044 if (pdu->isp_datalen != 0) { 2045 if ((IDM_PDU_OPCODE(pdu) == ISCSI_OP_SCSI_DATA) || 2046 (IDM_PDU_OPCODE(pdu) == ISCSI_OP_SCSI_DATA_RSP)) { 2047 rc = idm_sorecv_scsidata(ic, pdu); 2048 /* 2049 * All SCSI errors are fatal to the 2050 * connection right now since we have no 2051 * place to put the data. What we need 2052 * is some kind of sink to dispose of unwanted 2053 * SCSI data. For example an invalid task tag 2054 * should not kill the connection (although 2055 * we may want to drop the connection). 2056 */ 2057 } else { 2058 /* 2059 * Not data PDUs so allocate a buffer for the 2060 * data segment and read the remaining data. 2061 */ 2062 rc = idm_sorecv_nonscsidata(ic, pdu); 2063 } 2064 if (rc != 0) { 2065 /* 2066 * Call idm_pdu_complete so that we call the 2067 * callback and ensure any memory allocated 2068 * in idm_sorecvhdr gets freed up. 2069 */ 2070 idm_pdu_complete(pdu, IDM_STATUS_FAIL); 2071 2072 /* 2073 * If ic_rx_thread_running is still set then 2074 * this is some kind of connection problem 2075 * on the socket. In this case we want to 2076 * generate an event. Otherwise some other 2077 * thread closed the socket due to another 2078 * issue in which case we don't need to 2079 * generate an event. 2080 */ 2081 mutex_enter(&ic->ic_mutex); 2082 if (so_conn->ic_rx_thread_running) { 2083 conn_failure = B_TRUE; 2084 so_conn->ic_rx_thread_running = B_FALSE; 2085 } 2086 continue; 2087 } 2088 } 2089 2090 /* 2091 * Process RX PDU 2092 */ 2093 idm_pdu_rx(ic, pdu); 2094 2095 mutex_enter(&ic->ic_mutex); 2096 } 2097 2098 mutex_exit(&ic->ic_mutex); 2099 2100 /* 2101 * If we dropped out of the RX processing loop because of 2102 * a socket problem or other connection failure (including 2103 * digest errors) then we need to generate a state machine 2104 * event to shut the connection down. 2105 * If the state machine is already in, for example, INIT_ERROR, this 2106 * event will get dropped, and the TX thread will never be notified 2107 * to shut down. To be safe, we'll just notify it here. 2108 */ 2109 if (conn_failure) { 2110 if (so_conn->ic_tx_thread_running) { 2111 so_conn->ic_tx_thread_running = B_FALSE; 2112 mutex_enter(&so_conn->ic_tx_mutex); 2113 cv_signal(&so_conn->ic_tx_cv); 2114 mutex_exit(&so_conn->ic_tx_mutex); 2115 } 2116 2117 idm_conn_event(ic, CE_TRANSPORT_FAIL, rc); 2118 } 2119 2120 idm_conn_rele(ic); 2121 2122 thread_exit(); 2123 } 2124 2125 /* 2126 * idm_so_tx 2127 * 2128 * This is the implementation of idm_transport_ops_t's it_tx_pdu entry 2129 * point. By definition, it is supposed to be fast. So, simply queue 2130 * the entry and return. The real work is done by idm_i_so_tx() via 2131 * idm_sotx_thread(). 2132 */ 2133 2134 static void 2135 idm_so_tx(idm_conn_t *ic, idm_pdu_t *pdu) 2136 { 2137 idm_so_conn_t *so_conn = ic->ic_transport_private; 2138 2139 ASSERT(pdu->isp_ic == ic); 2140 mutex_enter(&so_conn->ic_tx_mutex); 2141 2142 if (!so_conn->ic_tx_thread_running) { 2143 mutex_exit(&so_conn->ic_tx_mutex); 2144 idm_pdu_complete(pdu, IDM_STATUS_ABORTED); 2145 return; 2146 } 2147 2148 list_insert_tail(&so_conn->ic_tx_list, (void *)pdu); 2149 cv_signal(&so_conn->ic_tx_cv); 2150 mutex_exit(&so_conn->ic_tx_mutex); 2151 } 2152 2153 static idm_status_t 2154 idm_i_so_tx(idm_pdu_t *pdu) 2155 { 2156 idm_conn_t *ic = pdu->isp_ic; 2157 idm_status_t status = IDM_STATUS_SUCCESS; 2158 uint8_t pad[ISCSI_PAD_WORD_LEN]; 2159 int pad_len; 2160 uint32_t hdr_digest_crc; 2161 uint32_t data_digest_crc = 0; 2162 int total_len = 0; 2163 int iovlen = 0; 2164 struct iovec iov[6]; 2165 idm_so_conn_t *so_conn; 2166 2167 so_conn = ic->ic_transport_private; 2168 2169 /* Setup BHS */ 2170 iov[iovlen].iov_base = (caddr_t)pdu->isp_hdr; 2171 iov[iovlen].iov_len = pdu->isp_hdrlen; 2172 total_len += iov[iovlen].iov_len; 2173 iovlen++; 2174 2175 /* Setup header digest */ 2176 if (((pdu->isp_flags & IDM_PDU_LOGIN_TX) == 0) && 2177 (ic->ic_conn_flags & IDM_CONN_HEADER_DIGEST)) { 2178 hdr_digest_crc = idm_crc32c(pdu->isp_hdr, pdu->isp_hdrlen); 2179 2180 iov[iovlen].iov_base = (caddr_t)&hdr_digest_crc; 2181 iov[iovlen].iov_len = sizeof (hdr_digest_crc); 2182 total_len += iov[iovlen].iov_len; 2183 iovlen++; 2184 } 2185 2186 /* Setup the data */ 2187 if (pdu->isp_datalen) { 2188 idm_task_t *idt; 2189 idm_buf_t *idb; 2190 iscsi_data_hdr_t *ihp; 2191 ihp = (iscsi_data_hdr_t *)pdu->isp_hdr; 2192 /* Write of immediate data */ 2193 if (ic->ic_ffp && 2194 (ihp->opcode == ISCSI_OP_SCSI_CMD || 2195 ihp->opcode == ISCSI_OP_SCSI_DATA)) { 2196 idt = idm_task_find(ic, ihp->itt, ihp->ttt); 2197 if (idt) { 2198 mutex_enter(&idt->idt_mutex); 2199 idb = idm_buf_find(&idt->idt_outbufv, 0); 2200 mutex_exit(&idt->idt_mutex); 2201 /* 2202 * If the initiator call to idm_buf_alloc 2203 * failed then we can get to this point 2204 * without a bound buffer. The associated 2205 * connection failure will clean things up 2206 * later. It would be nice to come up with 2207 * a cleaner way to handle this. In 2208 * particular it seems absurd to look up 2209 * the task and the buffer just to update 2210 * this counter. 2211 */ 2212 if (idb) 2213 idb->idb_xfer_len += pdu->isp_datalen; 2214 idm_task_rele(idt); 2215 } 2216 } 2217 2218 iov[iovlen].iov_base = (caddr_t)pdu->isp_data; 2219 iov[iovlen].iov_len = pdu->isp_datalen; 2220 total_len += iov[iovlen].iov_len; 2221 iovlen++; 2222 } 2223 2224 /* Setup the data pad if necessary */ 2225 pad_len = ((ISCSI_PAD_WORD_LEN - 2226 (pdu->isp_datalen & (ISCSI_PAD_WORD_LEN - 1))) & 2227 (ISCSI_PAD_WORD_LEN - 1)); 2228 2229 if (pad_len) { 2230 bzero(pad, sizeof (pad)); 2231 iov[iovlen].iov_base = (void *)&pad; 2232 iov[iovlen].iov_len = pad_len; 2233 total_len += iov[iovlen].iov_len; 2234 iovlen++; 2235 } 2236 2237 /* 2238 * Setup the data digest if enabled. Data-digest is not sent 2239 * for login-phase PDUs. 2240 */ 2241 if ((ic->ic_conn_flags & IDM_CONN_DATA_DIGEST) && 2242 ((pdu->isp_flags & IDM_PDU_LOGIN_TX) == 0) && 2243 (pdu->isp_datalen || pad_len)) { 2244 /* 2245 * RFC3720/10.2.3: A zero-length Data Segment also 2246 * implies a zero-length data digest. 2247 */ 2248 if (pdu->isp_datalen) { 2249 data_digest_crc = idm_crc32c(pdu->isp_data, 2250 pdu->isp_datalen); 2251 } 2252 if (pad_len) { 2253 data_digest_crc = idm_crc32c_continued(&pad, 2254 pad_len, data_digest_crc); 2255 } 2256 2257 iov[iovlen].iov_base = (caddr_t)&data_digest_crc; 2258 iov[iovlen].iov_len = sizeof (data_digest_crc); 2259 total_len += iov[iovlen].iov_len; 2260 iovlen++; 2261 } 2262 2263 /* Transmit the PDU */ 2264 if (idm_iov_sosend(so_conn->ic_so, &iov[0], iovlen, 2265 total_len) != 0) { 2266 /* Set error status */ 2267 IDM_CONN_LOG(CE_WARN, 2268 "idm_so_tx: failed to transmit the PDU, so: %p ic: %p " 2269 "data: %p", (void *) so_conn->ic_so, (void *) ic, 2270 (void *) pdu->isp_data); 2271 status = IDM_STATUS_IO; 2272 } 2273 2274 /* 2275 * Success does not mean that the PDU actually reached the 2276 * remote node since it could get dropped along the way. 2277 */ 2278 idm_pdu_complete(pdu, status); 2279 2280 return (status); 2281 } 2282 2283 /* 2284 * The idm_so_buf_tx_to_ini() is used by the target iSCSI layer to transmit the 2285 * Data-In PDUs using sockets. Based on the negotiated MaxRecvDataSegmentLength, 2286 * the buffer is segmented into a sequence of Data-In PDUs, ordered by DataSN. 2287 * A target can invoke this function multiple times for a single read command 2288 * (identified by the same ITT) to split the input into several sequences. 2289 * 2290 * DataSN starts with 0 for the first data PDU of an input command and advances 2291 * by 1 for each subsequent data PDU. Each sequence will have its own F bit, 2292 * which is set to 1 for the last data PDU of a sequence. 2293 * If the initiator supports phase collapse, the status bit must be set along 2294 * with the F bit to indicate that the status is shipped together with the last 2295 * Data-In PDU. 2296 * 2297 * The data PDUs within a sequence will be sent in order with the buffer offset 2298 * in increasing order. i.e. initiator and target must have negotiated the 2299 * "DataPDUInOrder" to "Yes". The order between sequences is not enforced. 2300 * 2301 * Caller holds idt->idt_mutex 2302 */ 2303 static idm_status_t 2304 idm_so_buf_tx_to_ini(idm_task_t *idt, idm_buf_t *idb) 2305 { 2306 idm_so_conn_t *so_conn = idb->idb_ic->ic_transport_private; 2307 idm_pdu_t tmppdu; 2308 2309 ASSERT(mutex_owned(&idt->idt_mutex)); 2310 2311 /* 2312 * Put the idm_buf_t on the tx queue. It will be transmitted by 2313 * idm_sotx_thread. 2314 */ 2315 mutex_enter(&so_conn->ic_tx_mutex); 2316 2317 DTRACE_ISCSI_8(xfer__start, idm_conn_t *, idt->idt_ic, 2318 uintptr_t, idb->idb_buf, uint32_t, idb->idb_bufoffset, 2319 uint64_t, 0, uint32_t, 0, uint32_t, 0, 2320 uint32_t, idb->idb_xfer_len, int, XFER_BUF_TX_TO_INI); 2321 2322 if (!so_conn->ic_tx_thread_running) { 2323 mutex_exit(&so_conn->ic_tx_mutex); 2324 /* 2325 * Don't release idt->idt_mutex since we're supposed to hold 2326 * in when calling idm_buf_tx_to_ini_done 2327 */ 2328 DTRACE_ISCSI_8(xfer__done, idm_conn_t *, idt->idt_ic, 2329 uintptr_t, idb->idb_buf, uint32_t, idb->idb_bufoffset, 2330 uint64_t, 0, uint32_t, 0, uint32_t, 0, 2331 uint32_t, idb->idb_xfer_len, 2332 int, XFER_BUF_TX_TO_INI); 2333 idm_buf_tx_to_ini_done(idt, idb, IDM_STATUS_ABORTED); 2334 return (IDM_STATUS_FAIL); 2335 } 2336 2337 /* 2338 * Build a template for the data PDU headers we will use so that 2339 * the SN values will stay consistent with other PDU's we are 2340 * transmitting like R2T and SCSI status. 2341 */ 2342 bzero(&idb->idb_data_hdr_tmpl, sizeof (iscsi_hdr_t)); 2343 tmppdu.isp_hdr = &idb->idb_data_hdr_tmpl; 2344 (*idt->idt_ic->ic_conn_ops.icb_build_hdr)(idt, &tmppdu, 2345 ISCSI_OP_SCSI_DATA_RSP); 2346 idb->idb_tx_thread = B_TRUE; 2347 list_insert_tail(&so_conn->ic_tx_list, (void *)idb); 2348 cv_signal(&so_conn->ic_tx_cv); 2349 mutex_exit(&so_conn->ic_tx_mutex); 2350 mutex_exit(&idt->idt_mutex); 2351 2352 /* 2353 * Returning success here indicates the transfer was successfully 2354 * dispatched -- it does not mean that the transfer completed 2355 * successfully. 2356 */ 2357 return (IDM_STATUS_SUCCESS); 2358 } 2359 2360 /* 2361 * The idm_so_buf_rx_from_ini() is used by the target iSCSI layer to specify the 2362 * data blocks it is ready to receive from the initiator in response to a WRITE 2363 * SCSI command. The target iSCSI layer passes the information about the desired 2364 * data blocks to the initiator in one R2T PDU. The receiving buffer, the buffer 2365 * offset and datalen are passed via the 'idb' argument. 2366 * 2367 * Scope for Prototype build: 2368 * R2Ts are required for any Data-Out PDU, i.e. initiator and target must have 2369 * negotiated the "InitialR2T" to "Yes". 2370 * 2371 * Caller holds idt->idt_mutex 2372 */ 2373 static idm_status_t 2374 idm_so_buf_rx_from_ini(idm_task_t *idt, idm_buf_t *idb) 2375 { 2376 idm_pdu_t *pdu; 2377 iscsi_rtt_hdr_t *rtt; 2378 2379 ASSERT(mutex_owned(&idt->idt_mutex)); 2380 2381 DTRACE_ISCSI_8(xfer__start, idm_conn_t *, idt->idt_ic, 2382 uintptr_t, idb->idb_buf, uint32_t, idb->idb_bufoffset, 2383 uint64_t, 0, uint32_t, 0, uint32_t, 0, 2384 uint32_t, idb->idb_xfer_len, int, XFER_BUF_RX_FROM_INI); 2385 2386 pdu = kmem_cache_alloc(idm.idm_sotx_pdu_cache, KM_SLEEP); 2387 pdu->isp_ic = idt->idt_ic; 2388 pdu->isp_flags = IDM_PDU_SET_STATSN; 2389 bzero(pdu->isp_hdr, sizeof (iscsi_rtt_hdr_t)); 2390 2391 /* iSCSI layer fills the TTT, ITT, ExpCmdSN, MaxCmdSN */ 2392 (*idt->idt_ic->ic_conn_ops.icb_build_hdr)(idt, pdu, ISCSI_OP_RTT_RSP); 2393 2394 /* set the rttsn, rtt.flags, rtt.data_offset and rtt.data_length */ 2395 rtt = (iscsi_rtt_hdr_t *)(pdu->isp_hdr); 2396 2397 rtt->opcode = ISCSI_OP_RTT_RSP; 2398 rtt->flags = ISCSI_FLAG_FINAL; 2399 rtt->data_offset = htonl(idb->idb_bufoffset); 2400 rtt->data_length = htonl(idb->idb_xfer_len); 2401 rtt->rttsn = htonl(idt->idt_exp_rttsn++); 2402 2403 /* Keep track of buffer offsets */ 2404 idb->idb_exp_offset = idb->idb_bufoffset; 2405 mutex_exit(&idt->idt_mutex); 2406 2407 /* 2408 * Transmit the PDU. 2409 */ 2410 idm_pdu_tx(pdu); 2411 2412 return (IDM_STATUS_SUCCESS); 2413 } 2414 2415 static idm_status_t 2416 idm_so_buf_alloc(idm_buf_t *idb, uint64_t buflen) 2417 { 2418 if ((buflen > IDM_SO_BUF_CACHE_LB) && (buflen <= IDM_SO_BUF_CACHE_UB)) { 2419 idb->idb_buf = kmem_cache_alloc(idm.idm_so_128k_buf_cache, 2420 KM_NOSLEEP); 2421 idb->idb_buf_private = idm.idm_so_128k_buf_cache; 2422 } else { 2423 idb->idb_buf = kmem_alloc(buflen, KM_NOSLEEP); 2424 idb->idb_buf_private = NULL; 2425 } 2426 2427 if (idb->idb_buf == NULL) { 2428 IDM_CONN_LOG(CE_NOTE, 2429 "idm_so_buf_alloc: failed buffer allocation"); 2430 return (IDM_STATUS_FAIL); 2431 } 2432 2433 return (IDM_STATUS_SUCCESS); 2434 } 2435 2436 /* ARGSUSED */ 2437 static idm_status_t 2438 idm_so_buf_setup(idm_buf_t *idb) 2439 { 2440 /* Ensure bufalloc'd flag is unset */ 2441 idb->idb_bufalloc = B_FALSE; 2442 2443 return (IDM_STATUS_SUCCESS); 2444 } 2445 2446 /* ARGSUSED */ 2447 static void 2448 idm_so_buf_teardown(idm_buf_t *idb) 2449 { 2450 /* nothing to do here */ 2451 } 2452 2453 static void 2454 idm_so_buf_free(idm_buf_t *idb) 2455 { 2456 if (idb->idb_buf_private == NULL) { 2457 kmem_free(idb->idb_buf, idb->idb_buflen); 2458 } else { 2459 kmem_cache_free(idb->idb_buf_private, idb->idb_buf); 2460 } 2461 } 2462 2463 static void 2464 idm_so_send_rtt_data(idm_conn_t *ic, idm_task_t *idt, idm_buf_t *idb, 2465 uint32_t offset, uint32_t length) 2466 { 2467 idm_so_conn_t *so_conn = ic->ic_transport_private; 2468 idm_pdu_t tmppdu; 2469 idm_buf_t *rtt_buf; 2470 2471 ASSERT(mutex_owned(&idt->idt_mutex)); 2472 2473 /* 2474 * Allocate a buffer to represent the RTT transfer. We could further 2475 * optimize this by allocating the buffers internally from an rtt 2476 * specific buffer cache since this is socket-specific code but for 2477 * now we will keep it simple. 2478 */ 2479 rtt_buf = idm_buf_alloc(ic, (uint8_t *)idb->idb_buf + offset, length); 2480 if (rtt_buf == NULL) { 2481 /* 2482 * If we're in FFP then the failure was likely a resource 2483 * allocation issue and we should close the connection by 2484 * sending a CE_TRANSPORT_FAIL event. 2485 * 2486 * If we're not in FFP then idm_buf_alloc will always 2487 * fail and the state is transitioning to "complete" anyway 2488 * so we won't bother to send an event. 2489 */ 2490 mutex_enter(&ic->ic_state_mutex); 2491 if (ic->ic_ffp) 2492 idm_conn_event_locked(ic, CE_TRANSPORT_FAIL, 2493 NULL, CT_NONE); 2494 mutex_exit(&ic->ic_state_mutex); 2495 mutex_exit(&idt->idt_mutex); 2496 return; 2497 } 2498 2499 rtt_buf->idb_buf_cb = NULL; 2500 rtt_buf->idb_cb_arg = NULL; 2501 rtt_buf->idb_bufoffset = offset; 2502 rtt_buf->idb_xfer_len = length; 2503 rtt_buf->idb_ic = idt->idt_ic; 2504 rtt_buf->idb_task_binding = idt; 2505 2506 /* 2507 * The new buffer (if any) represents an additional 2508 * reference on the task 2509 */ 2510 idm_task_hold(idt); 2511 mutex_exit(&idt->idt_mutex); 2512 2513 /* 2514 * Put the idm_buf_t on the tx queue. It will be transmitted by 2515 * idm_sotx_thread. 2516 */ 2517 mutex_enter(&so_conn->ic_tx_mutex); 2518 2519 if (!so_conn->ic_tx_thread_running) { 2520 idm_buf_free(rtt_buf); 2521 mutex_exit(&so_conn->ic_tx_mutex); 2522 idm_task_rele(idt); 2523 return; 2524 } 2525 2526 /* 2527 * Build a template for the data PDU headers we will use so that 2528 * the SN values will stay consistent with other PDU's we are 2529 * transmitting like R2T and SCSI status. 2530 */ 2531 bzero(&rtt_buf->idb_data_hdr_tmpl, sizeof (iscsi_hdr_t)); 2532 tmppdu.isp_hdr = &rtt_buf->idb_data_hdr_tmpl; 2533 (*idt->idt_ic->ic_conn_ops.icb_build_hdr)(idt, &tmppdu, 2534 ISCSI_OP_SCSI_DATA); 2535 rtt_buf->idb_tx_thread = B_TRUE; 2536 rtt_buf->idb_in_transport = B_TRUE; 2537 list_insert_tail(&so_conn->ic_tx_list, (void *)rtt_buf); 2538 cv_signal(&so_conn->ic_tx_cv); 2539 mutex_exit(&so_conn->ic_tx_mutex); 2540 } 2541 2542 static void 2543 idm_so_send_rtt_data_done(idm_task_t *idt, idm_buf_t *idb) 2544 { 2545 /* 2546 * Don't worry about status -- we assume any error handling 2547 * is performed by the caller (idm_sotx_thread). 2548 */ 2549 idb->idb_in_transport = B_FALSE; 2550 idm_task_rele(idt); 2551 idm_buf_free(idb); 2552 } 2553 2554 static idm_status_t 2555 idm_so_send_buf_region(idm_task_t *idt, idm_buf_t *idb, 2556 uint32_t buf_region_offset, uint32_t buf_region_length) 2557 { 2558 idm_conn_t *ic; 2559 uint32_t max_dataseglen; 2560 size_t remainder, chunk; 2561 uint32_t data_offset = buf_region_offset; 2562 iscsi_data_hdr_t *bhs; 2563 idm_pdu_t *pdu; 2564 idm_status_t tx_status; 2565 2566 ASSERT(mutex_owned(&idt->idt_mutex)); 2567 2568 ic = idt->idt_ic; 2569 2570 max_dataseglen = ic->ic_conn_params.max_xmit_dataseglen; 2571 remainder = buf_region_length; 2572 2573 while (remainder) { 2574 if (idt->idt_state != TASK_ACTIVE) { 2575 ASSERT((idt->idt_state != TASK_IDLE) && 2576 (idt->idt_state != TASK_COMPLETE)); 2577 return (IDM_STATUS_ABORTED); 2578 } 2579 2580 /* check to see if we need to chunk the data */ 2581 if (remainder > max_dataseglen) { 2582 chunk = max_dataseglen; 2583 } else { 2584 chunk = remainder; 2585 } 2586 2587 /* Data PDU headers will always be sizeof (iscsi_hdr_t) */ 2588 pdu = kmem_cache_alloc(idm.idm_sotx_pdu_cache, KM_SLEEP); 2589 pdu->isp_ic = ic; 2590 pdu->isp_flags = 0; /* initialize isp_flags */ 2591 2592 /* 2593 * We've already built a build a header template 2594 * to use during the transfer. Use this template so that 2595 * the SN values stay consistent with any unrelated PDU's 2596 * being transmitted. 2597 */ 2598 bcopy(&idb->idb_data_hdr_tmpl, pdu->isp_hdr, 2599 sizeof (iscsi_hdr_t)); 2600 2601 /* 2602 * Set DataSN, data offset, and flags in BHS 2603 * For the prototype build, A = 0, S = 0, U = 0 2604 */ 2605 bhs = (iscsi_data_hdr_t *)(pdu->isp_hdr); 2606 2607 bhs->datasn = htonl(idt->idt_exp_datasn++); 2608 2609 hton24(bhs->dlength, chunk); 2610 bhs->offset = htonl(idb->idb_bufoffset + data_offset); 2611 2612 /* setup data */ 2613 pdu->isp_data = (uint8_t *)idb->idb_buf + data_offset; 2614 pdu->isp_datalen = (uint_t)chunk; 2615 2616 if (chunk == remainder) { 2617 bhs->flags = ISCSI_FLAG_FINAL; /* F bit set to 1 */ 2618 /* Piggyback the status with the last data PDU */ 2619 if (idt->idt_flags & IDM_TASK_PHASECOLLAPSE_REQ) { 2620 pdu->isp_flags |= IDM_PDU_SET_STATSN | 2621 IDM_PDU_ADVANCE_STATSN; 2622 (*idt->idt_ic->ic_conn_ops.icb_update_statsn) 2623 (idt, pdu); 2624 idt->idt_flags |= 2625 IDM_TASK_PHASECOLLAPSE_SUCCESS; 2626 2627 } 2628 } 2629 2630 remainder -= chunk; 2631 data_offset += chunk; 2632 2633 /* Instrument the data-send DTrace probe. */ 2634 if (IDM_PDU_OPCODE(pdu) == ISCSI_OP_SCSI_DATA_RSP) { 2635 DTRACE_ISCSI_2(data__send, 2636 idm_conn_t *, idt->idt_ic, 2637 iscsi_data_rsp_hdr_t *, 2638 (iscsi_data_rsp_hdr_t *)pdu->isp_hdr); 2639 } 2640 2641 /* 2642 * Now that we're done working with idt_exp_datasn, 2643 * idt->idt_state and idb->idb_bufoffset we can release 2644 * the task lock -- don't want to hold it across the 2645 * call to idm_i_so_tx since we could block. 2646 */ 2647 mutex_exit(&idt->idt_mutex); 2648 2649 /* 2650 * Transmit the PDU. Call the internal routine directly 2651 * as there is already implicit ordering. 2652 */ 2653 if ((tx_status = idm_i_so_tx(pdu)) != IDM_STATUS_SUCCESS) { 2654 mutex_enter(&idt->idt_mutex); 2655 return (tx_status); 2656 } 2657 2658 mutex_enter(&idt->idt_mutex); 2659 idt->idt_tx_bytes += chunk; 2660 } 2661 2662 return (IDM_STATUS_SUCCESS); 2663 } 2664 2665 /* 2666 * TX PDU cache 2667 */ 2668 /* ARGSUSED */ 2669 int 2670 idm_sotx_pdu_constructor(void *hdl, void *arg, int flags) 2671 { 2672 idm_pdu_t *pdu = hdl; 2673 2674 bzero(pdu, sizeof (idm_pdu_t)); 2675 pdu->isp_hdr = (iscsi_hdr_t *)(pdu + 1); /* Ptr arithmetic */ 2676 pdu->isp_hdrlen = sizeof (iscsi_hdr_t); 2677 pdu->isp_callback = idm_sotx_cache_pdu_cb; 2678 pdu->isp_magic = IDM_PDU_MAGIC; 2679 bzero(pdu->isp_hdr, sizeof (iscsi_hdr_t)); 2680 2681 return (0); 2682 } 2683 2684 /* ARGSUSED */ 2685 void 2686 idm_sotx_cache_pdu_cb(idm_pdu_t *pdu, idm_status_t status) 2687 { 2688 /* reset values between use */ 2689 pdu->isp_datalen = 0; 2690 2691 kmem_cache_free(idm.idm_sotx_pdu_cache, pdu); 2692 } 2693 2694 /* 2695 * RX PDU cache 2696 */ 2697 /* ARGSUSED */ 2698 int 2699 idm_sorx_pdu_constructor(void *hdl, void *arg, int flags) 2700 { 2701 idm_pdu_t *pdu = hdl; 2702 2703 bzero(pdu, sizeof (idm_pdu_t)); 2704 pdu->isp_magic = IDM_PDU_MAGIC; 2705 pdu->isp_hdr = (iscsi_hdr_t *)(pdu + 1); /* Ptr arithmetic */ 2706 pdu->isp_callback = idm_sorx_cache_pdu_cb; 2707 2708 return (0); 2709 } 2710 2711 /* ARGSUSED */ 2712 static void 2713 idm_sorx_cache_pdu_cb(idm_pdu_t *pdu, idm_status_t status) 2714 { 2715 pdu->isp_iovlen = 0; 2716 pdu->isp_sorx_buf = 0; 2717 kmem_cache_free(idm.idm_sorx_pdu_cache, pdu); 2718 } 2719 2720 static void 2721 idm_sorx_addl_pdu_cb(idm_pdu_t *pdu, idm_status_t status) 2722 { 2723 /* 2724 * We had to modify our cached RX PDU with a longer header buffer 2725 * and/or a longer data buffer. Release the new buffers and fix 2726 * the fields back to what we would expect for a cached RX PDU. 2727 */ 2728 if (pdu->isp_flags & IDM_PDU_ADDL_HDR) { 2729 kmem_free(pdu->isp_hdr, pdu->isp_hdrlen); 2730 } 2731 if (pdu->isp_flags & IDM_PDU_ADDL_DATA) { 2732 kmem_free(pdu->isp_data, pdu->isp_datalen); 2733 } 2734 pdu->isp_hdr = (iscsi_hdr_t *)(pdu + 1); 2735 pdu->isp_hdrlen = sizeof (iscsi_hdr_t); 2736 pdu->isp_data = NULL; 2737 pdu->isp_datalen = 0; 2738 pdu->isp_sorx_buf = 0; 2739 pdu->isp_callback = idm_sorx_cache_pdu_cb; 2740 idm_sorx_cache_pdu_cb(pdu, status); 2741 } 2742 2743 /* 2744 * This thread is only active when I/O is queued for transmit 2745 * because the socket is busy. 2746 */ 2747 void 2748 idm_sotx_thread(void *arg) 2749 { 2750 idm_conn_t *ic = arg; 2751 idm_tx_obj_t *object, *next; 2752 idm_so_conn_t *so_conn; 2753 idm_status_t status = IDM_STATUS_SUCCESS; 2754 2755 idm_conn_hold(ic); 2756 2757 mutex_enter(&ic->ic_mutex); 2758 so_conn = ic->ic_transport_private; 2759 so_conn->ic_tx_thread_running = B_TRUE; 2760 so_conn->ic_tx_thread_did = so_conn->ic_tx_thread->t_did; 2761 cv_signal(&ic->ic_cv); 2762 mutex_exit(&ic->ic_mutex); 2763 2764 mutex_enter(&so_conn->ic_tx_mutex); 2765 2766 while (so_conn->ic_tx_thread_running) { 2767 while (list_is_empty(&so_conn->ic_tx_list)) { 2768 DTRACE_PROBE1(soconn__tx__sleep, idm_conn_t *, ic); 2769 cv_wait(&so_conn->ic_tx_cv, &so_conn->ic_tx_mutex); 2770 DTRACE_PROBE1(soconn__tx__wakeup, idm_conn_t *, ic); 2771 2772 if (!so_conn->ic_tx_thread_running) { 2773 goto tx_bail; 2774 } 2775 } 2776 2777 object = (idm_tx_obj_t *)list_head(&so_conn->ic_tx_list); 2778 list_remove(&so_conn->ic_tx_list, object); 2779 mutex_exit(&so_conn->ic_tx_mutex); 2780 2781 switch (object->idm_tx_obj_magic) { 2782 case IDM_PDU_MAGIC: { 2783 idm_pdu_t *pdu = (idm_pdu_t *)object; 2784 DTRACE_PROBE2(soconn__tx__pdu, idm_conn_t *, ic, 2785 idm_pdu_t *, (idm_pdu_t *)object); 2786 2787 if (pdu->isp_flags & IDM_PDU_SET_STATSN) { 2788 /* No IDM task */ 2789 (ic->ic_conn_ops.icb_update_statsn)(NULL, pdu); 2790 } 2791 status = idm_i_so_tx((idm_pdu_t *)object); 2792 break; 2793 } 2794 case IDM_BUF_MAGIC: { 2795 idm_buf_t *idb = (idm_buf_t *)object; 2796 idm_task_t *idt = idb->idb_task_binding; 2797 2798 DTRACE_PROBE2(soconn__tx__buf, idm_conn_t *, ic, 2799 idm_buf_t *, idb); 2800 2801 mutex_enter(&idt->idt_mutex); 2802 status = idm_so_send_buf_region(idt, 2803 idb, 0, idb->idb_xfer_len); 2804 2805 /* 2806 * TX thread owns the buffer so we expect it to 2807 * be "in transport" 2808 */ 2809 ASSERT(idb->idb_in_transport); 2810 if (IDM_CONN_ISTGT(ic)) { 2811 /* 2812 * idm_buf_tx_to_ini_done releases 2813 * idt->idt_mutex 2814 */ 2815 DTRACE_ISCSI_8(xfer__done, 2816 idm_conn_t *, idt->idt_ic, 2817 uintptr_t, idb->idb_buf, 2818 uint32_t, idb->idb_bufoffset, 2819 uint64_t, 0, uint32_t, 0, uint32_t, 0, 2820 uint32_t, idb->idb_xfer_len, 2821 int, XFER_BUF_TX_TO_INI); 2822 idm_buf_tx_to_ini_done(idt, idb, status); 2823 } else { 2824 idm_so_send_rtt_data_done(idt, idb); 2825 mutex_exit(&idt->idt_mutex); 2826 } 2827 break; 2828 } 2829 2830 default: 2831 IDM_CONN_LOG(CE_WARN, "idm_sotx_thread: Unknown magic " 2832 "(0x%08x)", object->idm_tx_obj_magic); 2833 status = IDM_STATUS_FAIL; 2834 } 2835 2836 mutex_enter(&so_conn->ic_tx_mutex); 2837 2838 if (status != IDM_STATUS_SUCCESS) { 2839 so_conn->ic_tx_thread_running = B_FALSE; 2840 idm_conn_event(ic, CE_TRANSPORT_FAIL, status); 2841 } 2842 } 2843 2844 /* 2845 * Before we leave, we need to abort every item remaining in the 2846 * TX list. 2847 */ 2848 2849 tx_bail: 2850 object = (idm_tx_obj_t *)list_head(&so_conn->ic_tx_list); 2851 2852 while (object != NULL) { 2853 next = list_next(&so_conn->ic_tx_list, object); 2854 2855 list_remove(&so_conn->ic_tx_list, object); 2856 switch (object->idm_tx_obj_magic) { 2857 case IDM_PDU_MAGIC: 2858 idm_pdu_complete((idm_pdu_t *)object, 2859 IDM_STATUS_ABORTED); 2860 break; 2861 2862 case IDM_BUF_MAGIC: { 2863 idm_buf_t *idb = (idm_buf_t *)object; 2864 idm_task_t *idt = idb->idb_task_binding; 2865 mutex_exit(&so_conn->ic_tx_mutex); 2866 mutex_enter(&idt->idt_mutex); 2867 /* 2868 * TX thread owns the buffer so we expect it to 2869 * be "in transport" 2870 */ 2871 ASSERT(idb->idb_in_transport); 2872 if (IDM_CONN_ISTGT(ic)) { 2873 /* 2874 * idm_buf_tx_to_ini_done releases 2875 * idt->idt_mutex 2876 */ 2877 DTRACE_ISCSI_8(xfer__done, 2878 idm_conn_t *, idt->idt_ic, 2879 uintptr_t, idb->idb_buf, 2880 uint32_t, idb->idb_bufoffset, 2881 uint64_t, 0, uint32_t, 0, uint32_t, 0, 2882 uint32_t, idb->idb_xfer_len, 2883 int, XFER_BUF_TX_TO_INI); 2884 idm_buf_tx_to_ini_done(idt, idb, 2885 IDM_STATUS_ABORTED); 2886 } else { 2887 idm_so_send_rtt_data_done(idt, idb); 2888 mutex_exit(&idt->idt_mutex); 2889 } 2890 mutex_enter(&so_conn->ic_tx_mutex); 2891 break; 2892 } 2893 default: 2894 IDM_CONN_LOG(CE_WARN, 2895 "idm_sotx_thread: Unexpected magic " 2896 "(0x%08x)", object->idm_tx_obj_magic); 2897 } 2898 2899 object = next; 2900 } 2901 2902 mutex_exit(&so_conn->ic_tx_mutex); 2903 idm_conn_rele(ic); 2904 thread_exit(); 2905 /*NOTREACHED*/ 2906 } 2907 2908 static void 2909 idm_so_socket_set_nonblock(struct sonode *node) 2910 { 2911 (void) VOP_SETFL(node->so_vnode, node->so_flag, 2912 (node->so_state | FNONBLOCK), CRED(), NULL); 2913 } 2914 2915 static void 2916 idm_so_socket_set_block(struct sonode *node) 2917 { 2918 (void) VOP_SETFL(node->so_vnode, node->so_flag, 2919 (node->so_state & (~FNONBLOCK)), CRED(), NULL); 2920 } 2921 2922 2923 /* 2924 * Called by kernel sockets when the connection has been accepted or 2925 * rejected. In early volo, a "disconnect" callback was sent instead of 2926 * "connectfailed", so we check for both. 2927 */ 2928 /* ARGSUSED */ 2929 void 2930 idm_so_timed_socket_connect_cb(ksocket_t ks, 2931 ksocket_callback_event_t ev, void *arg, uintptr_t info) 2932 { 2933 idm_so_timed_socket_t *itp = arg; 2934 ASSERT(itp != NULL); 2935 ASSERT(ev == KSOCKET_EV_CONNECTED || 2936 ev == KSOCKET_EV_CONNECTFAILED || 2937 ev == KSOCKET_EV_DISCONNECTED); 2938 2939 mutex_enter(&idm_so_timed_socket_mutex); 2940 itp->it_callback_called = B_TRUE; 2941 if (ev == KSOCKET_EV_CONNECTED) { 2942 itp->it_socket_error_code = 0; 2943 } else { 2944 /* Make sure the error code is non-zero on error */ 2945 if (info == 0) 2946 info = ECONNRESET; 2947 itp->it_socket_error_code = (int)info; 2948 } 2949 cv_signal(&itp->it_cv); 2950 mutex_exit(&idm_so_timed_socket_mutex); 2951 } 2952 2953 int 2954 idm_so_timed_socket_connect(ksocket_t ks, 2955 struct sockaddr_storage *sa, int sa_sz, int login_max_usec) 2956 { 2957 clock_t conn_login_max; 2958 int rc, nonblocking, rval; 2959 idm_so_timed_socket_t it; 2960 ksocket_callbacks_t ks_cb; 2961 2962 conn_login_max = ddi_get_lbolt() + drv_usectohz(login_max_usec); 2963 2964 /* 2965 * Set to non-block socket mode, with callback on connect 2966 * Early volo used "disconnected" instead of "connectfailed", 2967 * so set callback to look for both. 2968 */ 2969 bzero(&it, sizeof (it)); 2970 ks_cb.ksock_cb_flags = KSOCKET_CB_CONNECTED | 2971 KSOCKET_CB_CONNECTFAILED | KSOCKET_CB_DISCONNECTED; 2972 ks_cb.ksock_cb_connected = idm_so_timed_socket_connect_cb; 2973 ks_cb.ksock_cb_connectfailed = idm_so_timed_socket_connect_cb; 2974 ks_cb.ksock_cb_disconnected = idm_so_timed_socket_connect_cb; 2975 cv_init(&it.it_cv, NULL, CV_DEFAULT, NULL); 2976 rc = ksocket_setcallbacks(ks, &ks_cb, &it, CRED()); 2977 if (rc != 0) 2978 return (rc); 2979 2980 /* Set to non-blocking mode */ 2981 nonblocking = 1; 2982 rc = ksocket_ioctl(ks, FIONBIO, (intptr_t)&nonblocking, &rval, 2983 CRED()); 2984 if (rc != 0) 2985 goto cleanup; 2986 2987 bzero(&it, sizeof (it)); 2988 for (;;) { 2989 /* 2990 * Warning -- in a loopback scenario, the call to 2991 * the connect_cb can occur inside the call to 2992 * ksocket_connect. Do not hold the mutex around the 2993 * call to ksocket_connect. 2994 */ 2995 rc = ksocket_connect(ks, (struct sockaddr *)sa, sa_sz, CRED()); 2996 if (rc == 0 || rc == EISCONN) { 2997 /* socket success or already success */ 2998 rc = 0; 2999 break; 3000 } 3001 if ((rc != EINPROGRESS) && (rc != EALREADY)) { 3002 break; 3003 } 3004 3005 /* TCP connect still in progress. See if out of time. */ 3006 if (ddi_get_lbolt() > conn_login_max) { 3007 /* 3008 * Connection retry timeout, 3009 * failed connect to target. 3010 */ 3011 rc = ETIMEDOUT; 3012 break; 3013 } 3014 3015 /* 3016 * TCP connect still in progress. Sleep until callback. 3017 * Do NOT go to sleep if the callback already occurred! 3018 */ 3019 mutex_enter(&idm_so_timed_socket_mutex); 3020 if (!it.it_callback_called) { 3021 (void) cv_timedwait(&it.it_cv, 3022 &idm_so_timed_socket_mutex, conn_login_max); 3023 } 3024 if (it.it_callback_called) { 3025 rc = it.it_socket_error_code; 3026 mutex_exit(&idm_so_timed_socket_mutex); 3027 break; 3028 } 3029 /* If timer expires, go call ksocket_connect one last time. */ 3030 mutex_exit(&idm_so_timed_socket_mutex); 3031 } 3032 3033 /* resume blocking mode */ 3034 nonblocking = 0; 3035 (void) ksocket_ioctl(ks, FIONBIO, (intptr_t)&nonblocking, &rval, 3036 CRED()); 3037 cleanup: 3038 (void) ksocket_setcallbacks(ks, NULL, NULL, CRED()); 3039 cv_destroy(&it.it_cv); 3040 if (rc != 0) { 3041 idm_soshutdown(ks); 3042 } 3043 return (rc); 3044 } 3045 3046 3047 void 3048 idm_addr_to_sa(idm_addr_t *dportal, struct sockaddr_storage *sa) 3049 { 3050 int dp_addr_size; 3051 struct sockaddr_in *sin; 3052 struct sockaddr_in6 *sin6; 3053 3054 /* Build sockaddr_storage for this portal (idm_addr_t) */ 3055 bzero(sa, sizeof (*sa)); 3056 dp_addr_size = dportal->a_addr.i_insize; 3057 if (dp_addr_size == sizeof (struct in_addr)) { 3058 /* IPv4 */ 3059 sa->ss_family = AF_INET; 3060 sin = (struct sockaddr_in *)sa; 3061 sin->sin_port = htons(dportal->a_port); 3062 bcopy(&dportal->a_addr.i_addr.in4, 3063 &sin->sin_addr, sizeof (struct in_addr)); 3064 } else if (dp_addr_size == sizeof (struct in6_addr)) { 3065 /* IPv6 */ 3066 sa->ss_family = AF_INET6; 3067 sin6 = (struct sockaddr_in6 *)sa; 3068 sin6->sin6_port = htons(dportal->a_port); 3069 bcopy(&dportal->a_addr.i_addr.in6, 3070 &sin6->sin6_addr, sizeof (struct in6_addr)); 3071 } else { 3072 ASSERT(0); 3073 } 3074 } 3075 3076 3077 /* 3078 * return a human-readable form of a sockaddr_storage, in the form 3079 * [ip-address]:port. This is used in calls to logging functions. 3080 * If several calls to idm_sa_ntop are made within the same invocation 3081 * of a logging function, then each one needs its own buf. 3082 */ 3083 const char * 3084 idm_sa_ntop(const struct sockaddr_storage *sa, 3085 char *buf, size_t size) 3086 { 3087 static const char bogus_ip[] = "[0].-1"; 3088 char tmp[INET6_ADDRSTRLEN]; 3089 3090 switch (sa->ss_family) { 3091 case AF_INET6: 3092 { 3093 const struct sockaddr_in6 *in6 = 3094 (const struct sockaddr_in6 *) sa; 3095 3096 if (inet_ntop(in6->sin6_family, 3097 &in6->sin6_addr, tmp, sizeof (tmp)) == NULL) { 3098 goto err; 3099 } 3100 if (strlen(tmp) + sizeof ("[].65535") > size) { 3101 goto err; 3102 } 3103 /* struct sockaddr_storage gets port info from v4 loc */ 3104 (void) snprintf(buf, size, "[%s].%u", tmp, 3105 ntohs(in6->sin6_port)); 3106 return (buf); 3107 } 3108 case AF_INET: 3109 { 3110 const struct sockaddr_in *in = 3111 (const struct sockaddr_in *) sa; 3112 3113 if (inet_ntop(in->sin_family, &in->sin_addr, 3114 tmp, sizeof (tmp)) == NULL) { 3115 goto err; 3116 } 3117 if (strlen(tmp) + sizeof ("[].65535") > size) { 3118 goto err; 3119 } 3120 (void) snprintf(buf, size, "[%s].%u", tmp, 3121 ntohs(in->sin_port)); 3122 return (buf); 3123 } 3124 default: 3125 break; 3126 } 3127 err: 3128 (void) snprintf(buf, size, "%s", bogus_ip); 3129 return (buf); 3130 } 3131