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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/conf.h> 28 #include <sys/modctl.h> 29 #include <sys/stat.h> 30 #include <sys/stream.h> 31 #include <sys/strsun.h> 32 #include <sys/ddi.h> 33 #include <sys/sunddi.h> 34 #include <sys/priv_names.h> 35 #include <inet/common.h> 36 37 #define _SUN_TPI_VERSION 2 38 #include <sys/tihdr.h> 39 #include <sys/timod.h> 40 #include <sys/tiuser.h> 41 #include <sys/suntpi.h> 42 #include <inet/common.h> 43 #include <inet/ip.h> 44 #include <inet/mi.h> 45 #include <inet/proto_set.h> 46 #include <sys/ib/clients/rds/rds.h> 47 #include <sys/policy.h> 48 #include <inet/ipclassifier.h> 49 #include <sys/ib/clients/rds/rds_kstat.h> 50 #include "sys/random.h" 51 #include <sys/ib/clients/rds/rds_transport.h> 52 #include <sys/ib/ibtl/ibti.h> 53 54 55 #define RDS_NAME "rds" 56 #define RDS_STRTAB rdsinfo 57 #define RDS_DEVDESC "RDS STREAMS driver" 58 #define RDS_DEVMINOR 0 59 #define RDS_DEVMTFLAGS D_MP | D_SYNCSTR 60 #define RDS_DEFAULT_PRIV_MODE 0666 61 62 #define rds_smallest_port 1 63 #define rds_largest_port 65535 64 65 #define RDS_RECV_HIWATER (56 * 1024) 66 #define RDS_RECV_LOWATER 128 67 #define RDS_XMIT_HIWATER (56 * 1024) 68 #define RDS_XMIT_LOWATER 1024 69 70 #define RDS_DPRINTF2 0 && 71 #define LABEL "RDS" 72 73 typedef struct rdsahdr_s { 74 in_port_t uha_src_port; /* Source port */ 75 in_port_t uha_dst_port; /* Destination port */ 76 } rdsha_t; 77 78 #define RDSH_SIZE 4 79 80 int rds_recv_hiwat = RDS_RECV_HIWATER; 81 int rds_recv_lowat = RDS_RECV_LOWATER; 82 int rds_xmit_hiwat = RDS_XMIT_HIWATER; 83 int rds_xmit_lowat = RDS_XMIT_LOWATER; 84 85 int rdsdebug; 86 87 static dev_info_t *rds_dev_info; 88 89 /* Hint not protected by any lock */ 90 static in_port_t rds_next_port_to_try; 91 92 ldi_ident_t rds_li; 93 static int loopmax = rds_largest_port - rds_smallest_port + 1; 94 95 /* global configuration variables */ 96 uint_t UserBufferSize; 97 uint_t rds_rx_pkts_pending_hwm; 98 99 extern void rds_ioctl(queue_t *, mblk_t *); 100 extern void rds_ioctl_copyin_done(queue_t *q, mblk_t *mp); 101 102 int rds_open_transport_driver(); 103 int rds_close_transport_driver(); 104 105 #define RDS_CURRENT_PORT_QUOTA() \ 106 (rds_rx_pkts_pending_hwm/RDS_GET_NPORT()) 107 108 krwlock_t rds_transport_lock; 109 ldi_handle_t rds_transport_handle = NULL; 110 rds_transport_ops_t *rds_transport_ops = NULL; 111 112 static int 113 rds_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 114 { 115 int ret; 116 117 if (cmd != DDI_ATTACH) 118 return (DDI_FAILURE); 119 120 rds_dev_info = devi; 121 122 ret = ddi_create_minor_node(devi, RDS_NAME, S_IFCHR, 123 RDS_DEVMINOR, DDI_PSEUDO, 0); 124 if (ret != DDI_SUCCESS) { 125 return (ret); 126 } 127 128 return (DDI_SUCCESS); 129 } 130 131 static int 132 rds_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) 133 { 134 if (cmd != DDI_DETACH) 135 return (DDI_FAILURE); 136 137 ASSERT(devi == rds_dev_info); 138 139 ddi_remove_minor_node(devi, NULL); 140 141 return (DDI_SUCCESS); 142 } 143 144 /* ARGSUSED */ 145 static int 146 rds_info(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) 147 { 148 int error = DDI_FAILURE; 149 150 switch (cmd) { 151 case DDI_INFO_DEVT2DEVINFO: 152 if (rds_dev_info != NULL) { 153 *result = (void *)rds_dev_info; 154 error = DDI_SUCCESS; 155 } 156 break; 157 158 case DDI_INFO_DEVT2INSTANCE: 159 *result = NULL; 160 error = DDI_SUCCESS; 161 break; 162 163 default: 164 break; 165 } 166 167 return (error); 168 } 169 170 171 /*ARGSUSED*/ 172 static int 173 rds_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp) 174 { 175 rds_t *rds; 176 int ret; 177 178 if (is_system_labeled()) { 179 /* 180 * RDS socket is not supported on labeled systems 181 */ 182 return (ESOCKTNOSUPPORT); 183 } 184 185 /* Open the transport driver if IB HW is present */ 186 rw_enter(&rds_transport_lock, RW_READER); 187 if (rds_transport_handle == NULL) { 188 rw_exit(&rds_transport_lock); 189 ret = rds_open_transport_driver(); 190 rw_enter(&rds_transport_lock, RW_READER); 191 192 if (ret != 0) { 193 /* Transport driver failed to load */ 194 rw_exit(&rds_transport_lock); 195 return (ret); 196 } 197 } 198 rw_exit(&rds_transport_lock); 199 200 if (sflag == MODOPEN) { 201 return (EINVAL); 202 } 203 204 /* Reopen not supported */ 205 if (q->q_ptr != NULL) { 206 dprint(2, ("%s: Reopen is not supported: %p", LABEL, q->q_ptr)); 207 return (0); 208 } 209 210 rds = rds_create(q, credp); 211 if (rds == NULL) { 212 dprint(2, ("%s: rds_create failed", LABEL)); 213 return (0); 214 } 215 216 q->q_ptr = WR(q)->q_ptr = rds; 217 rds->rds_state = TS_UNBND; 218 rds->rds_family = AF_INET_OFFLOAD; 219 220 q->q_hiwat = rds_recv_hiwat; 221 q->q_lowat = rds_recv_lowat; 222 223 qprocson(q); 224 225 WR(q)->q_hiwat = rds_xmit_hiwat; 226 WR(q)->q_lowat = rds_xmit_lowat; 227 228 /* Set the Stream head watermarks */ 229 (void) proto_set_rx_hiwat(q, NULL, rds_recv_hiwat); 230 (void) proto_set_rx_lowat(q, NULL, rds_recv_lowat); 231 232 return (0); 233 } 234 235 /* ARGSUSED */ 236 static int 237 rds_close(queue_t *q, int flags __unused, cred_t *credp __unused) 238 { 239 rds_t *rdsp = (rds_t *)q->q_ptr; 240 241 qprocsoff(q); 242 243 /* 244 * NPORT should be decremented only if this socket was previously 245 * bound to an RDS port. 246 */ 247 if (rdsp->rds_state >= TS_IDLE) { 248 RDS_DECR_NPORT(); 249 RDS_SET_PORT_QUOTA(RDS_CURRENT_PORT_QUOTA()); 250 rds_transport_ops-> 251 rds_transport_resume_port(ntohs(rdsp->rds_port)); 252 } 253 254 /* close the transport driver if this is the last socket */ 255 if (RDS_GET_NPORT() == 1) { 256 (void) rds_close_transport_driver(); 257 } 258 259 /* 260 * We set the flags without holding a lock as this is 261 * just a hint for the fanout lookup to skip this rds. 262 * We dont free the struct until it's out of the hash and 263 * the ref count goes down. 264 */ 265 rdsp->rds_flags |= RDS_CLOSING; 266 rds_bind_hash_remove(rdsp, B_FALSE); 267 mutex_enter(&rdsp->rds_lock); 268 ASSERT(rdsp->rds_refcnt > 0); 269 if (rdsp->rds_refcnt != 1) { 270 cv_wait(&rdsp->rds_refcv, &rdsp->rds_lock); 271 } 272 mutex_exit(&rdsp->rds_lock); 273 RDS_DEC_REF_CNT(rdsp); 274 RD(q)->q_ptr = NULL; 275 WR(q)->q_ptr = NULL; 276 return (0); 277 } 278 279 /* 280 * Add a new message to the socket 281 */ 282 int 283 rds_deliver_new_msg(mblk_t *mp, ipaddr_t local_addr, ipaddr_t rem_addr, 284 in_port_t local_port, in_port_t rem_port, zoneid_t zoneid) 285 { 286 rds_t *rds; 287 struct T_unitdata_ind *tudi; 288 int udi_size; /* Size of T_unitdata_ind */ 289 mblk_t *mp1; 290 sin_t *sin; 291 int error = 0; 292 293 local_port = htons(local_port); 294 rem_port = htons(rem_port); 295 296 ASSERT(mp->b_datap->db_type == M_DATA); 297 rds = rds_fanout(local_addr, rem_addr, local_port, rem_port, zoneid); 298 if (rds == NULL) { 299 dprint(2, ("%s: rds_fanout failed: (0x%x 0x%x %d %d)", LABEL, 300 local_addr, rem_addr, ntohs(local_port), ntohs(rem_port))); 301 freemsg(mp); 302 return (error); 303 } 304 305 udi_size = sizeof (struct T_unitdata_ind) + sizeof (sin_t); 306 307 /* Allocate a message block for the T_UNITDATA_IND structure. */ 308 mp1 = allocb(udi_size, BPRI_MED); 309 if (mp1 == NULL) { 310 dprint(2, ("%s: allocb failed", LABEL)); 311 freemsg(mp); 312 return (ENOMEM); 313 } 314 315 mp1->b_cont = mp; 316 mp = mp1; 317 mp->b_datap->db_type = M_PROTO; 318 tudi = (struct T_unitdata_ind *)(uintptr_t)mp->b_rptr; 319 mp->b_wptr = (uchar_t *)tudi + udi_size; 320 tudi->PRIM_type = T_UNITDATA_IND; 321 tudi->SRC_length = sizeof (sin_t); 322 tudi->SRC_offset = sizeof (struct T_unitdata_ind); 323 tudi->OPT_offset = sizeof (struct T_unitdata_ind) + sizeof (sin_t); 324 udi_size -= (sizeof (struct T_unitdata_ind) + sizeof (sin_t)); 325 tudi->OPT_length = udi_size; 326 sin = (sin_t *)&tudi[1]; 327 sin->sin_addr.s_addr = rem_addr; 328 sin->sin_port = ntohs(rem_port); 329 sin->sin_family = rds->rds_family; 330 *(uint32_t *)(uintptr_t)&sin->sin_zero[0] = 0; 331 *(uint32_t *)(uintptr_t)&sin->sin_zero[4] = 0; 332 333 putnext(rds->rds_ulpd, mp); 334 335 /* check port quota */ 336 if (RDS_GET_RXPKTS_PEND() > rds_rx_pkts_pending_hwm) { 337 ulong_t current_port_quota = RDS_GET_PORT_QUOTA(); 338 if (rds->rds_port_quota > current_port_quota) { 339 /* this may result in stalling the port */ 340 rds->rds_port_quota = current_port_quota; 341 (void) proto_set_rx_hiwat(rds->rds_ulpd, NULL, 342 rds->rds_port_quota * UserBufferSize); 343 RDS_INCR_PORT_QUOTA_ADJUSTED(); 344 } 345 } 346 347 /* 348 * canputnext() check is done after putnext as the protocol does 349 * not allow dropping any received packet. 350 */ 351 if (!canputnext(rds->rds_ulpd)) { 352 error = ENOSPC; 353 } 354 355 RDS_DEC_REF_CNT(rds); 356 return (error); 357 } 358 359 360 /* Default structure copied into T_INFO_ACK messages */ 361 static struct T_info_ack rds_g_t_info_ack_ipv4 = { 362 T_INFO_ACK, 363 65535, /* TSDU_size. Excl. headers */ 364 T_INVALID, /* ETSU_size. rds does not support expedited data. */ 365 T_INVALID, /* CDATA_size. rds does not support connect data. */ 366 T_INVALID, /* DDATA_size. rds does not support disconnect data. */ 367 sizeof (sin_t), /* ADDR_size. */ 368 0, /* OPT_size - not initialized here */ 369 65535, /* TIDU_size. Excl. headers */ 370 T_CLTS, /* SERV_type. rds supports connection-less. */ 371 TS_UNBND, /* CURRENT_state. This is set from rds_state. */ 372 (XPG4_1|SENDZERO) /* PROVIDER_flag */ 373 }; 374 375 static in_port_t 376 rds_update_next_port(in_port_t port) 377 { 378 (void) random_get_pseudo_bytes((uint8_t *)&port, sizeof (in_port_t)); 379 if (port < rds_smallest_port) 380 port = rds_smallest_port; 381 return (port); 382 } 383 384 /* This routine creates a T_ERROR_ACK message and passes it upstream. */ 385 static void 386 rds_err_ack(queue_t *q, mblk_t *mp, t_scalar_t t_error, int sys_error) 387 { 388 if ((mp = mi_tpi_err_ack_alloc(mp, t_error, sys_error)) != NULL) 389 qreply(q, mp); 390 } 391 392 static void 393 rds_capability_req(queue_t *q, mblk_t *mp) 394 { 395 t_uscalar_t cap_bits1; 396 struct T_capability_ack *tcap; 397 398 cap_bits1 = 399 ((struct T_capability_req *)(uintptr_t)mp->b_rptr)->CAP_bits1; 400 401 mp = tpi_ack_alloc(mp, sizeof (struct T_capability_ack), 402 mp->b_datap->db_type, T_CAPABILITY_ACK); 403 if (mp == NULL) 404 return; 405 tcap = (struct T_capability_ack *)(uintptr_t)mp->b_rptr; 406 tcap->CAP_bits1 = 0; 407 408 if (cap_bits1 & TC1_INFO) { 409 tcap->CAP_bits1 |= TC1_INFO; 410 *(&tcap->INFO_ack) = rds_g_t_info_ack_ipv4; 411 } 412 413 qreply(q, mp); 414 } 415 416 static void 417 rds_info_req(queue_t *q, mblk_t *omp) 418 { 419 rds_t *rds = (rds_t *)q->q_ptr; 420 struct T_info_ack *tap; 421 mblk_t *mp; 422 423 /* Create a T_INFO_ACK message. */ 424 mp = tpi_ack_alloc(omp, sizeof (struct T_info_ack), M_PCPROTO, 425 T_INFO_ACK); 426 if (mp == NULL) 427 return; 428 tap = (struct T_info_ack *)(uintptr_t)mp->b_rptr; 429 *tap = rds_g_t_info_ack_ipv4; 430 tap->CURRENT_state = rds->rds_state; 431 tap->OPT_size = 128; 432 qreply(q, mp); 433 } 434 435 /* 436 * NO locking protection here as sockfs will only send down 437 * one bind operation at a time. 438 */ 439 static void 440 rds_bind(queue_t *q, mblk_t *mp) 441 { 442 sin_t *sin; 443 rds_t *rds; 444 struct T_bind_req *tbr; 445 in_port_t port; /* Host byte order */ 446 in_port_t requested_port; /* Host byte order */ 447 struct T_bind_ack *tba; 448 int count; 449 rds_bf_t *rdsbf; 450 in_port_t lport; /* Network byte order */ 451 452 rds = (rds_t *)q->q_ptr; 453 if (((uintptr_t)mp->b_wptr - (uintptr_t)mp->b_rptr) < sizeof (*tbr)) { 454 rds_err_ack(q, mp, TPROTO, 0); 455 return; 456 } 457 458 /* 459 * We don't allow multiple binds 460 */ 461 if (rds->rds_state != TS_UNBND) { 462 rds_err_ack(q, mp, TOUTSTATE, 0); 463 return; 464 } 465 466 tbr = (struct T_bind_req *)(uintptr_t)mp->b_rptr; 467 switch (tbr->ADDR_length) { 468 case sizeof (sin_t): /* Complete IPv4 address */ 469 sin = (sin_t *)(uintptr_t)mi_offset_param(mp, tbr->ADDR_offset, 470 sizeof (sin_t)); 471 if (sin == NULL || !OK_32PTR((char *)sin)) { 472 rds_err_ack(q, mp, TSYSERR, EINVAL); 473 return; 474 } 475 if (rds->rds_family != AF_INET_OFFLOAD || 476 sin->sin_family != AF_INET_OFFLOAD) { 477 rds_err_ack(q, mp, TSYSERR, EAFNOSUPPORT); 478 return; 479 } 480 if (sin->sin_addr.s_addr == INADDR_ANY) { 481 rds_err_ack(q, mp, TBADADDR, 0); 482 return; 483 } 484 485 /* 486 * verify that the address is hosted on IB 487 * only exception is the loopback address. 488 */ 489 if ((sin->sin_addr.s_addr != INADDR_LOOPBACK) && 490 !rds_verify_bind_address(sin->sin_addr.s_addr)) { 491 rds_err_ack(q, mp, TBADADDR, 0); 492 return; 493 } 494 495 port = ntohs(sin->sin_port); 496 break; 497 default: /* Invalid request */ 498 rds_err_ack(q, mp, TBADADDR, 0); 499 return; 500 } 501 502 requested_port = port; 503 504 /* 505 * TPI only sends down T_BIND_REQ for AF_INET and AF_INET6 506 * since RDS socket is of type AF_INET_OFFLOAD a O_T_BIND_REQ 507 * will be sent down. Treat O_T_BIND_REQ as T_BIND_REQ 508 */ 509 510 if (requested_port == 0) { 511 /* 512 * If the application passed in zero for the port number, it 513 * doesn't care which port number we bind to. Get one in the 514 * valid range. 515 */ 516 port = rds_update_next_port(rds_next_port_to_try); 517 } 518 519 ASSERT(port != 0); 520 count = 0; 521 for (;;) { 522 rds_t *rds1; 523 ASSERT(sin->sin_addr.s_addr != INADDR_ANY); 524 /* 525 * Walk through the list of rds streams bound to 526 * requested port with the same IP address. 527 */ 528 lport = htons(port); 529 rdsbf = &rds_bind_fanout[RDS_BIND_HASH(lport)]; 530 mutex_enter(&rdsbf->rds_bf_lock); 531 for (rds1 = rdsbf->rds_bf_rds; rds1 != NULL; 532 rds1 = rds1->rds_bind_hash) { 533 if (lport != rds1->rds_port || 534 rds1->rds_src != sin->sin_addr.s_addr || 535 rds1->rds_zoneid != rds->rds_zoneid) 536 537 continue; 538 break; 539 } 540 541 if (rds1 == NULL) { 542 /* 543 * No other stream has this IP address 544 * and port number. We can use it. 545 */ 546 break; 547 } 548 mutex_exit(&rdsbf->rds_bf_lock); 549 if (requested_port != 0) { 550 /* 551 * We get here only when requested port 552 * is bound (and only first of the for() 553 * loop iteration). 554 * 555 * The semantics of this bind request 556 * require it to fail so we return from 557 * the routine (and exit the loop). 558 * 559 */ 560 rds_err_ack(q, mp, TADDRBUSY, 0); 561 return; 562 } 563 564 port = rds_update_next_port(port + 1); 565 566 if (++count >= loopmax) { 567 /* 568 * We've tried every possible port number and 569 * there are none available, so send an error 570 * to the user. 571 */ 572 rds_err_ack(q, mp, TNOADDR, 0); 573 return; 574 } 575 } 576 577 /* 578 * Copy the source address into our rds structure. 579 */ 580 rds->rds_src = sin->sin_addr.s_addr; 581 rds->rds_port = lport; 582 583 /* 584 * reset the next port if we choose the port 585 */ 586 if (requested_port == 0) { 587 rds_next_port_to_try = port + 1; 588 } 589 590 rds->rds_state = TS_IDLE; 591 rds_bind_hash_insert(rdsbf, rds); 592 mutex_exit(&rdsbf->rds_bf_lock); 593 594 /* Reset the message type in preparation for shipping it back. */ 595 mp->b_datap->db_type = M_PCPROTO; 596 tba = (struct T_bind_ack *)(uintptr_t)mp->b_rptr; 597 tba->PRIM_type = T_BIND_ACK; 598 599 /* Increment the number of ports and set the port quota */ 600 RDS_INCR_NPORT(); 601 rds->rds_port_quota = RDS_CURRENT_PORT_QUOTA(); 602 RDS_SET_PORT_QUOTA(rds->rds_port_quota); 603 (void) proto_set_rx_hiwat(RD(q), NULL, 604 rds->rds_port_quota * UserBufferSize); 605 606 qreply(q, mp); 607 } 608 609 static void 610 rds_wput_other(queue_t *q, mblk_t *mp) 611 { 612 uchar_t *rptr = mp->b_rptr; 613 struct datab *db; 614 cred_t *cr; 615 616 db = mp->b_datap; 617 switch (db->db_type) { 618 case M_DATA: 619 /* Not connected */ 620 freemsg(mp); 621 return; 622 case M_PROTO: 623 case M_PCPROTO: 624 if ((uintptr_t)mp->b_wptr - (uintptr_t)rptr < 625 sizeof (t_scalar_t)) { 626 freemsg(mp); 627 return; 628 } 629 switch (((union T_primitives *)(uintptr_t)rptr)->type) { 630 case T_CAPABILITY_REQ: 631 rds_capability_req(q, mp); 632 return; 633 634 case T_INFO_REQ: 635 rds_info_req(q, mp); 636 return; 637 case O_T_BIND_REQ: 638 case T_BIND_REQ: 639 rds_bind(q, mp); 640 return; 641 case T_SVR4_OPTMGMT_REQ: 642 case T_OPTMGMT_REQ: 643 /* 644 * All Solaris components should pass a db_credp 645 * for this TPI message, hence we ASSERT. 646 * But in case there is some other M_PROTO that looks 647 * like a TPI message sent by some other kernel 648 * component, we check and return an error. 649 */ 650 cr = msg_getcred(mp, NULL); 651 ASSERT(cr != NULL); 652 if (cr == NULL) { 653 rds_err_ack(q, mp, TSYSERR, EINVAL); 654 return; 655 } 656 if (((union T_primitives *)(uintptr_t)rptr)->type == 657 T_SVR4_OPTMGMT_REQ) { 658 svr4_optcom_req(q, mp, cr, &rds_opt_obj); 659 } else { 660 tpi_optcom_req(q, mp, cr, &rds_opt_obj); 661 } 662 return; 663 case T_CONN_REQ: 664 /* 665 * We should not receive T_CONN_REQ as sockfs only 666 * sends down T_CONN_REQ if family == AF_INET/AF_INET6 667 * and type == SOCK_DGRAM/SOCK_RAW. For all others 668 * it simply calls soisconnected. see sotpi_connect() 669 * for details. 670 */ 671 /* FALLTHRU */ 672 default: 673 cmn_err(CE_PANIC, "type %d \n", 674 ((union T_primitives *)(uintptr_t)rptr)->type); 675 } 676 break; 677 case M_FLUSH: 678 if (*rptr & FLUSHW) 679 flushq(q, FLUSHDATA); 680 break; 681 case M_IOCTL: 682 rds_ioctl(q, mp); 683 break; 684 case M_IOCDATA: 685 /* IOCTL continuation following copyin or copyout. */ 686 if (mi_copy_state(q, mp, NULL) == -1) { 687 /* 688 * The copy operation failed. mi_copy_state already 689 * cleaned up, so we're out of here. 690 */ 691 return; 692 } 693 /* 694 * If we just completed a copy in, continue processing 695 * in rds_ioctl_copyin_done. If it was a copy out, we call 696 * mi_copyout again. If there is nothing more to copy out, 697 * it will complete the IOCTL. 698 */ 699 700 if (MI_COPY_DIRECTION(mp) == MI_COPY_IN) 701 rds_ioctl_copyin_done(q, mp); 702 else 703 mi_copyout(q, mp); 704 return; 705 706 default: 707 cmn_err(CE_PANIC, "types %d \n", db->db_type); 708 } 709 } 710 711 static int 712 rds_wput(queue_t *q, mblk_t *mp) 713 { 714 struct datab *db; 715 uchar_t *rptr = mp->b_rptr; 716 717 db = mp->b_datap; 718 switch (db->db_type) { 719 case M_PROTO: 720 case M_PCPROTO: 721 ASSERT(((uintptr_t)mp->b_wptr - (uintptr_t)rptr) <= 722 (uintptr_t)INT_MAX); 723 if ((uintptr_t)mp->b_wptr - (uintptr_t)rptr >= 724 sizeof (struct T_unitdata_req)) { 725 if (((union T_primitives *)(uintptr_t)rptr)->type 726 == T_UNITDATA_REQ) { 727 /* 728 * We should never come here for T_UNITDATA_REQ 729 */ 730 cmn_err(CE_PANIC, "rds_wput T_UNITDATA_REQ \n"); 731 } 732 } 733 /* FALLTHRU */ 734 default: 735 rds_wput_other(q, mp); 736 return (0); 737 } 738 } 739 740 static int 741 rds_wput_data(queue_t *q, mblk_t *mp, uio_t *uiop) 742 { 743 uchar_t *rptr = mp->b_rptr; 744 rds_t *rds; 745 mblk_t *mp1; 746 sin_t *sin; 747 ipaddr_t dst; 748 uint16_t port; 749 int ret = 0; 750 751 #define tudr ((struct T_unitdata_req *)(uintptr_t)rptr) 752 753 rds = (rds_t *)q->q_ptr; 754 /* Handle UNITDATA_REQ messages here */ 755 if (rds->rds_state == TS_UNBND) { 756 /* If a port has not been bound to the stream, fail. */ 757 dprint(2, ("%s: socket is not bound to a port", LABEL)); 758 freemsg(mp); 759 return (EPROTO); 760 } 761 762 mp1 = mp->b_cont; 763 mp->b_cont = NULL; 764 if (mp1 == NULL) { 765 dprint(2, ("%s: No message to send", LABEL)); 766 freemsg(mp); 767 return (EPROTO); 768 } 769 770 /* 771 * No options allowed 772 */ 773 if (tudr->OPT_length != 0) { 774 ret = EINVAL; 775 goto done; 776 } 777 778 ASSERT(mp1->b_datap->db_ref == 1); 779 780 if ((rptr + tudr->DEST_offset + tudr->DEST_length) > 781 mp->b_wptr) { 782 ret = EDESTADDRREQ; 783 goto done; 784 } 785 786 sin = (sin_t *)(uintptr_t)&rptr[tudr->DEST_offset]; 787 if (!OK_32PTR((char *)sin) || tudr->DEST_length != 788 sizeof (sin_t) || sin->sin_family != AF_INET_OFFLOAD) { 789 ret = EDESTADDRREQ; 790 goto done; 791 } 792 /* Extract port and ipaddr */ 793 port = sin->sin_port; 794 dst = sin->sin_addr.s_addr; 795 796 if (port == 0 || dst == INADDR_ANY) { 797 ret = EDESTADDRREQ; 798 goto done; 799 } 800 801 ASSERT(rds_transport_ops != NULL); 802 ret = rds_transport_ops->rds_transport_sendmsg(uiop, rds->rds_src, dst, 803 ntohs(rds->rds_port), ntohs(port), rds->rds_zoneid); 804 if (ret != 0) { 805 if ((ret != ENOBUFS) && (ret != ENOMEM)) { 806 /* ENOMEM is actually EWOULDBLOCK */ 807 dprint(2, ("%s: rds_sendmsg returned %d", LABEL, ret)); 808 goto done; 809 } 810 } 811 done: 812 freemsg(mp1); 813 freemsg(mp); 814 return (ret); 815 } 816 817 /* 818 * Make sure we dont return EINVAL and EWOULDBLOCK as it has 819 * special meanings for the synchronous streams (rwnext()). 820 * We should return ENOMEM which is changed to EWOULDBLOCK by kstrputmsg() 821 */ 822 static int 823 rds_wrw(queue_t *q, struiod_t *dp) 824 { 825 mblk_t *mp = dp->d_mp; 826 int error = 0; 827 struct datab *db; 828 uchar_t *rptr; 829 830 db = mp->b_datap; 831 rptr = mp->b_rptr; 832 switch (db->db_type) { 833 case M_PROTO: 834 case M_PCPROTO: 835 ASSERT(((uintptr_t)mp->b_wptr - (uintptr_t)rptr) <= 836 (uintptr_t)INT_MAX); 837 if ((uintptr_t)mp->b_wptr - (uintptr_t)rptr >= 838 sizeof (struct T_unitdata_req)) { 839 /* Detect valid T_UNITDATA_REQ here */ 840 if (((union T_primitives *)(uintptr_t)rptr)->type 841 == T_UNITDATA_REQ) 842 break; 843 } 844 /* FALLTHRU */ 845 default: 846 847 if (isuioq(q) && (error = struioget(q, mp, dp, 0))) { 848 /* 849 * Uio error of some sort, so just return the error. 850 */ 851 goto done; 852 } 853 dp->d_mp = 0; 854 rds_wput_other(q, mp); 855 return (0); 856 } 857 858 dp->d_mp = 0; 859 error = rds_wput_data(q, mp, &dp->d_uio); 860 done: 861 if (error == EWOULDBLOCK || error == EINVAL) 862 error = EIO; 863 864 return (error); 865 } 866 867 static void 868 rds_rsrv(queue_t *q) 869 { 870 rds_t *rds = (rds_t *)q->q_ptr; 871 ulong_t current_port_quota; 872 873 /* update the port quota to the current level */ 874 current_port_quota = RDS_GET_PORT_QUOTA(); 875 if (rds->rds_port_quota != current_port_quota) { 876 rds->rds_port_quota = current_port_quota; 877 (void) proto_set_rx_hiwat(q, NULL, 878 rds->rds_port_quota * UserBufferSize); 879 } 880 881 /* No more messages in the q, unstall the socket */ 882 rds_transport_ops->rds_transport_resume_port(ntohs(rds->rds_port)); 883 } 884 885 int 886 rds_close_transport_driver() 887 { 888 ASSERT(rds_transport_ops != NULL); 889 890 rw_enter(&rds_transport_lock, RW_WRITER); 891 if (rds_transport_handle != NULL) { 892 rds_transport_ops->rds_transport_close_ib(); 893 (void) ldi_close(rds_transport_handle, FNDELAY, kcred); 894 rds_transport_handle = NULL; 895 } 896 rw_exit(&rds_transport_lock); 897 898 return (0); 899 } 900 901 902 int 903 rds_open_transport_driver() 904 { 905 int ret = 0; 906 907 rw_enter(&rds_transport_lock, RW_WRITER); 908 if (rds_transport_handle != NULL) { 909 /* 910 * Someone beat us to it. 911 */ 912 goto done; 913 } 914 915 if (ibt_hw_is_present() == 0) { 916 ret = ENODEV; 917 goto done; 918 } 919 920 if (rds_li == NULL) { 921 ret = EPROTONOSUPPORT; 922 goto done; 923 } 924 925 ret = ldi_open_by_name("/devices/ib/rdsib@0:rdsib", 926 FREAD | FWRITE, kcred, &rds_transport_handle, rds_li); 927 if (ret != 0) { 928 ret = EPROTONOSUPPORT; 929 rds_transport_handle = NULL; 930 goto done; 931 } 932 933 ret = rds_transport_ops->rds_transport_open_ib(); 934 if (ret != 0) { 935 (void) ldi_close(rds_transport_handle, FNDELAY, kcred); 936 rds_transport_handle = NULL; 937 } 938 done: 939 rw_exit(&rds_transport_lock); 940 return (ret); 941 } 942 943 static struct module_info info = { 944 0, "rds", 1, INFPSZ, 65536, 1024 945 }; 946 947 static struct qinit rinit = { 948 NULL, (pfi_t)rds_rsrv, rds_open, rds_close, NULL, &info 949 }; 950 951 static struct qinit winit = { 952 (pfi_t)rds_wput, NULL, rds_open, rds_close, NULL, &info, 953 NULL, rds_wrw, NULL, STRUIOT_STANDARD 954 }; 955 956 struct streamtab rdsinfo = { 957 &rinit, &winit, NULL, NULL 958 }; 959 960 DDI_DEFINE_STREAM_OPS(rds_devops, nulldev, nulldev, rds_attach, rds_detach, 961 nulldev, rds_info, RDS_DEVMTFLAGS, &RDS_STRTAB, ddi_quiesce_not_supported); 962 963 /* 964 * Module linkage information for the kernel. 965 */ 966 static struct modldrv modldrv = { 967 &mod_driverops, 968 RDS_DEVDESC, 969 &rds_devops 970 }; 971 972 static struct modlinkage modlinkage = { 973 MODREV_1, 974 &modldrv, 975 NULL 976 }; 977 978 int 979 _init(void) 980 { 981 int ret; 982 983 rds_init(); 984 985 ret = mod_install(&modlinkage); 986 if (ret != 0) 987 goto done; 988 ret = ldi_ident_from_mod(&modlinkage, &rds_li); 989 if (ret != 0) 990 rds_li = NULL; 991 done: 992 return (ret); 993 } 994 995 int 996 _fini(void) 997 { 998 int ret; 999 1000 ret = mod_remove(&modlinkage); 1001 if (ret != 0) { 1002 return (ret); 1003 } 1004 1005 rds_fini(); 1006 1007 ldi_ident_release(rds_li); 1008 return (0); 1009 } 1010 1011 int 1012 _info(struct modinfo *modinfop) 1013 { 1014 return (mod_info(&modlinkage, modinfop)); 1015 } 1016