iscsi_main.c revision 1.18
1 /* $netBSD: iscsi_main.c,v 1.1.1.1 2011/05/02 07:01:11 agc Exp $ */ 2 3 /*- 4 * Copyright (c) 2004,2005,2006,2011 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Wasabi Systems, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 #include "iscsi_globals.h" 32 33 #include <sys/systm.h> 34 #include <sys/buf.h> 35 #include <sys/file.h> 36 #include <sys/filedesc.h> 37 #include <sys/kmem.h> 38 #include <sys/socketvar.h> 39 #include <sys/sysctl.h> 40 41 #include "ioconf.h" 42 43 /*------------------------- Global Variables ------------------------*/ 44 45 extern struct cfdriver iscsi_cd; 46 47 #if defined(ISCSI_DEBUG) 48 int iscsi_debug_level = ISCSI_DEBUG; 49 #endif 50 51 bool iscsi_detaching; 52 53 /* the list of sessions */ 54 session_list_t iscsi_sessions = TAILQ_HEAD_INITIALIZER(iscsi_sessions); 55 56 /* the number of active send threads (for cleanup thread) */ 57 uint32_t iscsi_num_send_threads = 0; 58 59 /* Our node name, alias, and ISID */ 60 uint8_t iscsi_InitiatorName[ISCSI_STRING_LENGTH] = ""; 61 uint8_t iscsi_InitiatorAlias[ISCSI_STRING_LENGTH] = ""; 62 login_isid_t iscsi_InitiatorISID; 63 64 /******************************************************************************/ 65 66 /* 67 System interface: autoconf and device structures 68 */ 69 70 static void iscsi_attach(device_t parent, device_t self, void *aux); 71 static int iscsi_match(device_t, cfdata_t, void *); 72 static int iscsi_detach(device_t, int); 73 74 struct iscsi_softc { 75 device_t dev; 76 kmutex_t lock; 77 TAILQ_HEAD(, iscsifd) fds; 78 }; 79 80 CFATTACH_DECL_NEW(iscsi, sizeof(struct iscsi_softc), iscsi_match, iscsi_attach, 81 iscsi_detach, NULL); 82 83 84 static dev_type_open(iscsiopen); 85 static int iscsiclose(struct file *); 86 87 static const struct fileops iscsi_fileops = { 88 .fo_ioctl = iscsiioctl, 89 .fo_close = iscsiclose, 90 }; 91 92 struct cdevsw iscsi_cdevsw = { 93 .d_open = iscsiopen, 94 .d_close = noclose, 95 .d_read = noread, 96 .d_write = nowrite, 97 .d_ioctl = noioctl, 98 .d_stop = nostop, 99 .d_tty = notty, 100 .d_poll = nopoll, 101 .d_mmap = nommap, 102 .d_kqfilter = nokqfilter, 103 .d_discard = nodiscard, 104 .d_flag = D_OTHER 105 }; 106 107 /******************************************************************************/ 108 109 STATIC void iscsi_scsipi_request(struct scsipi_channel *, 110 scsipi_adapter_req_t, void *); 111 STATIC void iscsi_minphys(struct buf *); 112 113 /******************************************************************************/ 114 115 /******************************************************************************* 116 * Open and Close device interfaces. We don't really need them, because we don't 117 * have to keep track of device opens and closes from userland. But apps can't 118 * call ioctl without a handle to the device, and the kernel doesn't hand out 119 * handles without an open routine in the driver. So here they are in all their 120 * glory... 121 *******************************************************************************/ 122 123 int 124 iscsiopen(dev_t dev, int flag, int mode, struct lwp *l) 125 { 126 struct iscsifd *d; 127 struct iscsi_softc *sc; 128 struct file *fp; 129 int error, fd, unit; 130 131 unit = minor(dev); 132 133 DEB(99, ("ISCSI Open unit=%d\n",unit)); 134 135 sc = device_lookup_private(&iscsi_cd, unit); 136 if (sc == NULL) 137 return ENXIO; 138 139 if ((error = fd_allocfile(&fp, &fd)) != 0) 140 return error; 141 142 d = kmem_alloc(sizeof(*d), KM_SLEEP); 143 d->dev = sc->dev; 144 d->unit = unit; 145 146 mutex_enter(&sc->lock); 147 if (iscsi_detaching) { 148 mutex_exit(&sc->lock); 149 kmem_free(d, sizeof(*d)); 150 DEB(99, ("ISCSI Open aborting\n")); 151 fd_abort(curproc, fp, fd); 152 return ENXIO; 153 } 154 TAILQ_INSERT_TAIL(&sc->fds, d, link); 155 mutex_exit(&sc->lock); 156 157 return fd_clone(fp, fd, flag, &iscsi_fileops, d); 158 } 159 160 static int 161 iscsiclose(struct file *fp) 162 { 163 struct iscsifd *d = fp->f_iscsi; 164 struct iscsi_softc *sc; 165 166 sc = device_lookup_private(&iscsi_cd, d->unit); 167 if (sc == NULL) { 168 DEBOUT(("%s: Cannot find private data\n",__func__)); 169 return ENXIO; 170 } 171 172 mutex_enter(&sc->lock); 173 TAILQ_REMOVE(&sc->fds, d, link); 174 mutex_exit(&sc->lock); 175 176 kmem_free(d, sizeof(*d)); 177 fp->f_iscsi = NULL; 178 179 DEB(99, ("ISCSI Close\n")); 180 return 0; 181 } 182 183 /******************************************************************************/ 184 185 /* 186 * The config Match routine. 187 * Not much to do here, either - this is a pseudo-device. 188 */ 189 190 static int 191 iscsi_match(device_t self, cfdata_t cfdata, void *arg) 192 { 193 return 1; 194 } 195 196 /* 197 * iscsiattach: 198 * Only called when statically configured into a kernel 199 */ 200 void 201 iscsiattach(int n) 202 { 203 int err; 204 cfdata_t cf; 205 206 err = config_cfattach_attach(iscsi_cd.cd_name, &iscsi_ca); 207 if (err) { 208 aprint_error("%s: couldn't register cfattach: %d\n", 209 iscsi_cd.cd_name, err); 210 config_cfdriver_detach(&iscsi_cd); 211 return; 212 } 213 214 if (n > 1) 215 aprint_error("%s: only one device supported\n", 216 iscsi_cd.cd_name); 217 218 cf = kmem_alloc(sizeof(struct cfdata), KM_NOSLEEP); 219 if (cf == NULL) { 220 aprint_error("%s: couldn't allocate cfdata\n", 221 iscsi_cd.cd_name); 222 return; 223 } 224 cf->cf_name = iscsi_cd.cd_name; 225 cf->cf_atname = iscsi_cd.cd_name; 226 cf->cf_unit = 0; 227 cf->cf_fstate = FSTATE_NOTFOUND; 228 229 (void)config_attach_pseudo(cf); 230 return; 231 } 232 233 /* 234 * iscsi_attach: 235 * One-time inits go here. Not much for now, probably even less later. 236 */ 237 static void 238 iscsi_attach(device_t parent, device_t self, void *aux) 239 { 240 struct iscsi_softc *sc; 241 242 DEB(1, ("ISCSI: iscsi_attach, parent=%p, self=%p, aux=%p\n", parent, 243 self, aux)); 244 sc = (struct iscsi_softc *) device_private(self); 245 sc->dev = self; 246 247 TAILQ_INIT(&sc->fds); 248 mutex_init(&sc->lock, MUTEX_DEFAULT, IPL_NONE); 249 250 iscsi_detaching = false; 251 iscsi_init_cleanup(); 252 253 aprint_normal("%s: attached. major = %d\n", iscsi_cd.cd_name, 254 cdevsw_lookup_major(&iscsi_cdevsw)); 255 } 256 257 /* 258 * iscsi_detach: 259 * Cleanup. 260 */ 261 static int 262 iscsi_detach(device_t self, int flags) 263 { 264 struct iscsi_softc *sc; 265 266 DEB(1, ("ISCSI: detach\n")); 267 sc = (struct iscsi_softc *) device_private(self); 268 269 mutex_enter(&sc->lock); 270 if (!TAILQ_EMPTY(&sc->fds)) { 271 mutex_exit(&sc->lock); 272 return EBUSY; 273 } 274 iscsi_detaching = true; 275 mutex_exit(&sc->lock); 276 277 kill_all_sessions(); 278 iscsi_destroy_cleanup(); 279 280 mutex_destroy(&sc->lock); 281 282 return 0; 283 } 284 285 /******************************************************************************/ 286 287 typedef struct quirktab_t { 288 const char *tgt; 289 const char *iqn; 290 uint32_t quirks; 291 } quirktab_t; 292 293 static const quirktab_t quirktab[] = { 294 { "StarWind", "iqn.2008-08.com.starwindsoftware", PQUIRK_ONLYBIG }, 295 { "UNH", "iqn.2002-10.edu.unh.", 296 PQUIRK_NOBIGMODESENSE | 297 PQUIRK_NOMODESENSE | 298 PQUIRK_NOSYNCCACHE }, 299 { "NetBSD", "iqn.1994-04.org.netbsd.", 0 }, 300 { "Unknown", "unknown", 0 }, 301 { NULL, NULL, 0 } 302 }; 303 304 /* loop through the quirktab looking for a match on target name */ 305 static const quirktab_t * 306 getquirks(const char *iqn) 307 { 308 const quirktab_t *qp; 309 size_t iqnlen, quirklen; 310 311 if (iqn == NULL) 312 iqn = "unknown"; 313 iqnlen = strlen(iqn); 314 for (qp = quirktab ; qp->iqn ; qp++) { 315 quirklen = strlen(qp->iqn); 316 if (quirklen > iqnlen) 317 continue; 318 if (memcmp(qp->iqn, iqn, quirklen) == 0) 319 break; 320 } 321 return qp; 322 } 323 324 /******************************************************************************/ 325 326 /* 327 * map_session 328 * This (indirectly) maps the existing LUNs for a target to SCSI devices 329 * by going through config_found to tell any child drivers that there's 330 * a new adapter. 331 * Note that each session is equivalent to a SCSI adapter. 332 * 333 * Parameter: the session pointer 334 * 335 * Returns: 1 on success, 0 on failure 336 * 337 * ToDo: Figuring out how to handle more than one LUN. It appears that 338 * the NetBSD SCSI LUN discovery doesn't use "report LUNs", and instead 339 * goes through the LUNs sequentially, stopping somewhere on the way if it 340 * gets an error. We may have to do some LUN mapping in here if this is 341 * really how things work. 342 */ 343 344 int 345 map_session(session_t *session, device_t dev) 346 { 347 struct scsipi_adapter *adapt = &session->sc_adapter; 348 struct scsipi_channel *chan = &session->sc_channel; 349 const quirktab_t *tgt; 350 351 /* 352 * Fill in the scsipi_adapter. 353 */ 354 adapt->adapt_dev = dev; 355 adapt->adapt_nchannels = 1; 356 adapt->adapt_request = iscsi_scsipi_request; 357 adapt->adapt_minphys = iscsi_minphys; 358 adapt->adapt_openings = CCBS_PER_SESSION; 359 adapt->adapt_max_periph = CCBS_PER_SESSION; 360 361 /* 362 * Fill in the scsipi_channel. 363 */ 364 if ((tgt = getquirks(chan->chan_name)) == NULL) { 365 tgt = getquirks("unknown"); 366 } 367 chan->chan_name = tgt->tgt; 368 chan->chan_defquirks = tgt->quirks; 369 chan->chan_adapter = adapt; 370 chan->chan_bustype = &scsi_bustype; 371 chan->chan_channel = 0; 372 chan->chan_flags = SCSIPI_CHAN_NOSETTLE; 373 chan->chan_ntargets = 1; 374 chan->chan_nluns = 16; /* ToDo: ??? */ 375 chan->chan_id = session->id; 376 377 session->child_dev = config_found(dev, chan, scsiprint); 378 379 return session->child_dev != NULL; 380 } 381 382 383 /* 384 * unmap_session 385 * This (indirectly) unmaps the existing all LUNs for a target by 386 * telling the config system that the adapter has detached. 387 * 388 * Parameter: the session pointer 389 * 390 * Returns: 1 on success, 0 on failure 391 */ 392 393 int 394 unmap_session(session_t *session) 395 { 396 device_t dev; 397 int rv = 1; 398 399 if ((dev = session->child_dev) != NULL) { 400 session->child_dev = NULL; 401 if (config_detach(dev, 0)) 402 rv = 0; 403 } 404 405 return rv; 406 } 407 408 /******************************************************************************/ 409 410 /***************************************************************************** 411 * SCSI interface routines 412 *****************************************************************************/ 413 414 /* 415 * iscsi_scsipi_request: 416 * Perform a request for the SCSIPI layer. 417 */ 418 419 void 420 iscsi_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, 421 void *arg) 422 { 423 struct scsipi_adapter *adapt = chan->chan_adapter; 424 struct scsipi_xfer *xs; 425 session_t *session; 426 int flags; 427 struct scsipi_xfer_mode *xm; 428 429 session = (session_t *) adapt; /* adapter is first field in session */ 430 431 switch (req) { 432 case ADAPTER_REQ_RUN_XFER: 433 DEB(9, ("ISCSI: scsipi_request RUN_XFER\n")); 434 xs = arg; 435 flags = xs->xs_control; 436 437 if ((flags & XS_CTL_POLL) != 0) { 438 xs->error = XS_DRIVER_STUFFUP; 439 DEBOUT(("Run Xfer request with polling\n")); 440 scsipi_done(xs); 441 return; 442 } 443 /* 444 * NOTE: It appears that XS_CTL_DATA_UIO is not actually used anywhere. 445 * Since it really would complicate matters to handle offsets 446 * into scatter-gather lists, and a number of other drivers don't 447 * handle uio-based data as well, XS_CTL_DATA_UIO isn't 448 * implemented in this driver (at least for now). 449 */ 450 if (flags & XS_CTL_DATA_UIO) { 451 xs->error = XS_DRIVER_STUFFUP; 452 DEBOUT(("Run Xfer with data in UIO\n")); 453 scsipi_done(xs); 454 return; 455 } 456 457 send_run_xfer(session, xs); 458 DEB(9, ("scsipi_req returns\n")); 459 return; 460 461 case ADAPTER_REQ_GROW_RESOURCES: 462 DEB(5, ("ISCSI: scsipi_request GROW_RESOURCES\n")); 463 return; 464 465 case ADAPTER_REQ_SET_XFER_MODE: 466 DEB(5, ("ISCSI: scsipi_request SET_XFER_MODE\n")); 467 xm = (struct scsipi_xfer_mode *)arg; 468 xm->xm_mode = PERIPH_CAP_TQING; 469 scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm); 470 return; 471 472 default: 473 break; 474 } 475 DEBOUT(("ISCSI: scsipi_request with invalid REQ code %d\n", req)); 476 } 477 478 /* cap the transfer at 64K */ 479 #define ISCSI_MAX_XFER 65536 480 481 /* 482 * iscsi_minphys: 483 * Limit a transfer to our maximum transfer size. 484 */ 485 486 void 487 iscsi_minphys(struct buf *bp) 488 { 489 if (bp->b_bcount > ISCSI_MAX_XFER) { 490 bp->b_bcount = ISCSI_MAX_XFER; 491 } 492 } 493 494 /***************************************************************************** 495 * SCSI job execution helper routines 496 *****************************************************************************/ 497 498 /* 499 * iscsi_done: 500 * 501 * A CCB has completed execution. Pass the status back to the 502 * upper layer. 503 */ 504 void 505 iscsi_done(ccb_t *ccb) 506 { 507 struct scsipi_xfer *xs = ccb->xs; 508 DEB(9, ("iscsi_done\n")); 509 510 if (xs != NULL) { 511 xs->resid = ccb->residual; 512 513 switch (ccb->status) { 514 case ISCSI_STATUS_SUCCESS: 515 xs->error = XS_NOERROR; 516 xs->status = SCSI_OK; 517 break; 518 519 case ISCSI_STATUS_CHECK_CONDITION: 520 xs->error = XS_SENSE; 521 xs->status = SCSI_CHECK; 522 break; 523 524 case ISCSI_STATUS_TARGET_BUSY: 525 xs->error = XS_BUSY; 526 xs->status = SCSI_BUSY; 527 break; 528 529 case ISCSI_STATUS_SOCKET_ERROR: 530 case ISCSI_STATUS_TIMEOUT: 531 xs->error = XS_SELTIMEOUT; 532 xs->status = SCSI_BUSY; 533 break; 534 535 case ISCSI_STATUS_NO_RESOURCES: 536 xs->error = XS_BUSY; 537 xs->status = SCSI_QUEUE_FULL; 538 break; 539 540 default: 541 xs->error = XS_DRIVER_STUFFUP; 542 break; 543 } 544 545 DEB(99, ("Calling scsipi_done (%p), err = %d\n", xs, xs->error)); 546 KERNEL_LOCK(1, curlwp); 547 scsipi_done(xs); 548 KERNEL_UNLOCK_ONE(curlwp); 549 DEB(99, ("scsipi_done returned\n")); 550 } else { 551 DEBOUT(("ISCSI: iscsi_done CCB %p without XS\n", ccb)); 552 } 553 } 554 555 SYSCTL_SETUP(sysctl_iscsi_setup, "ISCSI subtree setup") 556 { 557 const struct sysctlnode *node = NULL; 558 559 sysctl_createv(clog, 0, NULL, &node, 560 CTLFLAG_PERMANENT, 561 CTLTYPE_NODE, "iscsi", 562 SYSCTL_DESCR("iscsi controls"), 563 NULL, 0, NULL, 0, 564 CTL_HW, CTL_CREATE, CTL_EOL); 565 566 #ifdef ISCSI_DEBUG 567 sysctl_createv(clog, 0, &node, NULL, 568 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 569 CTLTYPE_INT, "debug", 570 SYSCTL_DESCR("debug level"), 571 NULL, 0, &iscsi_debug_level, sizeof(iscsi_debug_level), 572 CTL_CREATE, CTL_EOL); 573 #endif 574 } 575 576 577 /* Kernel Module support */ 578 579 #include <sys/module.h> 580 581 MODULE(MODULE_CLASS_DRIVER, iscsi, NULL); /* Possibly a builtin module */ 582 583 #ifdef _MODULE 584 static const struct cfiattrdata ibescsi_info = { "scsi", 1, 585 {{"channel", "-1", -1},} 586 }; 587 588 static const struct cfiattrdata *const iscsi_attrs[] = { &ibescsi_info, NULL }; 589 590 CFDRIVER_DECL(iscsi, DV_DULL, iscsi_attrs); 591 592 static struct cfdata iscsi_cfdata[] = { 593 { 594 .cf_name = "iscsi", 595 .cf_atname = "iscsi", 596 .cf_unit = 0, /* Only unit 0 is ever used */ 597 .cf_fstate = FSTATE_NOTFOUND, 598 .cf_loc = NULL, 599 .cf_flags = 0, 600 .cf_pspec = NULL, 601 }, 602 { NULL, NULL, 0, 0, NULL, 0, NULL } 603 }; 604 #endif 605 606 static int 607 iscsi_modcmd(modcmd_t cmd, void *arg) 608 { 609 #ifdef _MODULE 610 devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR; 611 int error; 612 static struct sysctllog *clog; 613 #endif 614 615 switch (cmd) { 616 case MODULE_CMD_INIT: 617 #ifdef _MODULE 618 error = config_cfdriver_attach(&iscsi_cd); 619 if (error) { 620 return error; 621 } 622 623 error = config_cfattach_attach(iscsi_cd.cd_name, &iscsi_ca); 624 if (error) { 625 config_cfdriver_detach(&iscsi_cd); 626 aprint_error("%s: unable to register cfattach\n", 627 iscsi_cd.cd_name); 628 return error; 629 } 630 631 error = config_cfdata_attach(iscsi_cfdata, 1); 632 if (error) { 633 aprint_error("%s: unable to attach cfdata\n", 634 iscsi_cd.cd_name); 635 config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca); 636 config_cfdriver_detach(&iscsi_cd); 637 return error; 638 } 639 640 error = devsw_attach(iscsi_cd.cd_name, NULL, &bmajor, 641 &iscsi_cdevsw, &cmajor); 642 if (error) { 643 aprint_error("%s: unable to register devsw\n", 644 iscsi_cd.cd_name); 645 config_cfdata_detach(iscsi_cfdata); 646 config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca); 647 config_cfdriver_detach(&iscsi_cd); 648 return error; 649 } 650 651 if (config_attach_pseudo(iscsi_cfdata) == NULL) { 652 aprint_error("%s: config_attach_pseudo failed\n", 653 iscsi_cd.cd_name); 654 config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca); 655 config_cfdriver_detach(&iscsi_cd); 656 return ENXIO; 657 } 658 659 sysctl_iscsi_setup(&clog); 660 #endif 661 return 0; 662 break; 663 664 case MODULE_CMD_FINI: 665 #ifdef _MODULE 666 sysctl_teardown(&clog); 667 668 error = config_cfdata_detach(iscsi_cfdata); 669 if (error) 670 return error; 671 672 config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca); 673 config_cfdriver_detach(&iscsi_cd); 674 devsw_detach(NULL, &iscsi_cdevsw); 675 #endif 676 return 0; 677 break; 678 679 case MODULE_CMD_AUTOUNLOAD: 680 return EBUSY; 681 break; 682 683 default: 684 return ENOTTY; 685 break; 686 } 687 } 688
Indexes created Wed Sep 24 15:09:51 GMT 2025