/* $NetBSD: iscsi_main.c,v 1.42 2023/12/28 15:58:24 mlelstv Exp $ */ /*- * Copyright (c) 2004,2005,2006,2011 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Wasabi Systems, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include "iscsi_globals.h" #include #include #include #include #include #include #include #include "ioconf.h" /*------------------------- Global Variables ------------------------*/ extern struct cfdriver iscsi_cd; #if defined(ISCSI_DEBUG) int iscsi_debug_level = ISCSI_DEBUG; #endif bool iscsi_hex_bignums = false; bool iscsi_detaching; /* the list of sessions */ session_list_t iscsi_sessions = TAILQ_HEAD_INITIALIZER(iscsi_sessions); /* the number of active send threads (for cleanup thread) */ uint32_t iscsi_num_send_threads = 0; /* Our node name, alias, and ISID */ uint8_t iscsi_InitiatorName[ISCSI_STRING_LENGTH] = ""; uint8_t iscsi_InitiatorAlias[ISCSI_STRING_LENGTH] = ""; login_isid_t iscsi_InitiatorISID; /******************************************************************************/ /* System interface: autoconf and device structures */ static void iscsi_attach(device_t parent, device_t self, void *aux); static int iscsi_match(device_t, cfdata_t, void *); static int iscsi_detach(device_t, int); struct iscsi_softc { device_t dev; kmutex_t lock; TAILQ_HEAD(, iscsifd) fds; }; CFATTACH_DECL_NEW(iscsi, sizeof(struct iscsi_softc), iscsi_match, iscsi_attach, iscsi_detach, NULL); static dev_type_open(iscsiopen); static int iscsiclose(struct file *); static const struct fileops iscsi_fileops = { .fo_name = "iscsi", .fo_read = fbadop_read, .fo_write = fbadop_write, .fo_ioctl = iscsiioctl, .fo_fcntl = fnullop_fcntl, .fo_poll = fnullop_poll, .fo_stat = fbadop_stat, .fo_close = iscsiclose, .fo_kqfilter = fnullop_kqfilter, .fo_restart = fnullop_restart }; struct cdevsw iscsi_cdevsw = { .d_open = iscsiopen, .d_close = noclose, .d_read = noread, .d_write = nowrite, .d_ioctl = noioctl, .d_stop = nostop, .d_tty = notty, .d_poll = nopoll, .d_mmap = nommap, .d_kqfilter = nokqfilter, .d_discard = nodiscard, .d_flag = D_OTHER }; /******************************************************************************/ STATIC void iscsi_scsipi_request(struct scsipi_channel *, scsipi_adapter_req_t, void *); STATIC void iscsi_minphys(struct buf *); /******************************************************************************/ /******************************************************************************* * Open and Close device interfaces. We don't really need them, because we don't * have to keep track of device opens and closes from userland. But apps can't * call ioctl without a handle to the device, and the kernel doesn't hand out * handles without an open routine in the driver. So here they are in all their * glory... *******************************************************************************/ int iscsiopen(dev_t dev, int flag, int mode, struct lwp *l) { struct iscsifd *d; struct iscsi_softc *sc; struct file *fp; int error, fd, unit; unit = minor(dev); DEB(99, ("ISCSI Open unit=%d\n",unit)); sc = device_lookup_private(&iscsi_cd, unit); if (sc == NULL) return ENXIO; if ((error = fd_allocfile(&fp, &fd)) != 0) return error; d = kmem_alloc(sizeof(*d), KM_SLEEP); d->fd_dev = sc->dev; d->fd_unit = unit; mutex_enter(&sc->lock); if (iscsi_detaching) { mutex_exit(&sc->lock); kmem_free(d, sizeof(*d)); DEB(99, ("ISCSI Open aborting\n")); fd_abort(curproc, fp, fd); return ENXIO; } TAILQ_INSERT_TAIL(&sc->fds, d, fd_link); mutex_exit(&sc->lock); return fd_clone(fp, fd, flag, &iscsi_fileops, d); } static int iscsiclose(struct file *fp) { struct iscsifd *d = fp->f_iscsi; struct iscsi_softc *sc; sc = device_lookup_private(&iscsi_cd, d->fd_unit); if (sc != NULL) { mutex_enter(&sc->lock); TAILQ_REMOVE(&sc->fds, d, fd_link); mutex_exit(&sc->lock); } kmem_free(d, sizeof(*d)); fp->f_iscsi = NULL; DEB(99, ("ISCSI Close\n")); return 0; } /******************************************************************************/ /* * The config Match routine. * Not much to do here, either - this is a pseudo-device. */ static int iscsi_match(device_t self, cfdata_t cfdata, void *arg) { return 1; } /* * iscsiattach: * Only called when statically configured into a kernel */ void iscsiattach(int n) { int err; cfdata_t cf; err = config_cfattach_attach(iscsi_cd.cd_name, &iscsi_ca); if (err) { aprint_error("%s: couldn't register cfattach: %d\n", iscsi_cd.cd_name, err); config_cfdriver_detach(&iscsi_cd); return; } if (n > 1) aprint_error("%s: only one device supported\n", iscsi_cd.cd_name); cf = kmem_alloc(sizeof(struct cfdata), KM_SLEEP); cf->cf_name = iscsi_cd.cd_name; cf->cf_atname = iscsi_cd.cd_name; cf->cf_unit = 0; cf->cf_fstate = FSTATE_NOTFOUND; (void)config_attach_pseudo(cf); return; } /* * iscsi_attach: * One-time inits go here. Not much for now, probably even less later. */ static void iscsi_attach(device_t parent, device_t self, void *aux) { struct iscsi_softc *sc; DEB(1, ("ISCSI: iscsi_attach, parent=%p, self=%p, aux=%p\n", parent, self, aux)); sc = (struct iscsi_softc *) device_private(self); sc->dev = self; TAILQ_INIT(&sc->fds); mutex_init(&sc->lock, MUTEX_DEFAULT, IPL_NONE); iscsi_detaching = false; iscsi_init_cleanup(); if (!pmf_device_register(self, NULL, NULL)) aprint_error_dev(self, "couldn't establish power handler\n"); aprint_verbose("%s: attached. major = %d\n", iscsi_cd.cd_name, cdevsw_lookup_major(&iscsi_cdevsw)); } /* * iscsi_detach: * Cleanup. */ static int iscsi_detach(device_t self, int flags) { struct iscsi_softc *sc; int error; DEB(1, ("ISCSI: detach\n")); sc = (struct iscsi_softc *) device_private(self); mutex_enter(&sc->lock); if (!TAILQ_EMPTY(&sc->fds)) { mutex_exit(&sc->lock); return EBUSY; } iscsi_detaching = true; mutex_exit(&sc->lock); error = kill_all_sessions(); if (error) return error; error = iscsi_destroy_cleanup(); if (error) return error; pmf_device_deregister(sc->dev); mutex_destroy(&sc->lock); return 0; } /******************************************************************************/ typedef struct quirktab_t { const char *tgt; const char *iqn; uint32_t quirks; } quirktab_t; static const quirktab_t quirktab[] = { { "StarWind", "iqn.2008-08.com.starwindsoftware", PQUIRK_ONLYBIG }, { "UNH", "iqn.2002-10.edu.unh.", PQUIRK_NOBIGMODESENSE | PQUIRK_NOMODESENSE | PQUIRK_NOSYNCCACHE }, { "NetBSD", "iqn.1994-04.org.netbsd.", 0 }, { "Unknown", "unknown", 0 }, { NULL, NULL, 0 } }; /* loop through the quirktab looking for a match on target name */ static const quirktab_t * getquirks(const char *iqn) { const quirktab_t *qp; size_t iqnlen, quirklen; if (iqn == NULL) iqn = "unknown"; iqnlen = strlen(iqn); for (qp = quirktab ; qp->iqn ; qp++) { quirklen = strlen(qp->iqn); if (quirklen > iqnlen) continue; if (memcmp(qp->iqn, iqn, quirklen) == 0) break; } return qp; } /******************************************************************************/ /* * map_session * This (indirectly) maps the existing LUNs for a target to SCSI devices * by going through config_found to tell any child drivers that there's * a new adapter. * Note that each session is equivalent to a SCSI adapter. * * Parameter: the session pointer * * Returns: 1 on success, 0 on failure * * ToDo: Figuring out how to handle more than one LUN. It appears that * the NetBSD SCSI LUN discovery doesn't use "report LUNs", and instead * goes through the LUNs sequentially, stopping somewhere on the way if it * gets an error. We may have to do some LUN mapping in here if this is * really how things work. */ int map_session(session_t *sess, device_t dev) { struct scsipi_adapter *adapt = &sess->s_sc_adapter; struct scsipi_channel *chan = &sess->s_sc_channel; const quirktab_t *tgt; int found; mutex_enter(&sess->s_lock); sess->s_send_window = max(2, window_size(sess, CCBS_FOR_SCSIPI)); mutex_exit(&sess->s_lock); /* * Fill in the scsipi_adapter. */ adapt->adapt_dev = dev; adapt->adapt_nchannels = 1; adapt->adapt_request = iscsi_scsipi_request; adapt->adapt_minphys = iscsi_minphys; adapt->adapt_openings = sess->s_send_window; adapt->adapt_max_periph = CCBS_FOR_SCSIPI; adapt->adapt_flags = SCSIPI_ADAPT_MPSAFE; /* * Fill in the scsipi_channel. */ if ((tgt = getquirks(chan->chan_name)) == NULL) { tgt = getquirks("unknown"); } chan->chan_name = tgt->tgt; chan->chan_defquirks = tgt->quirks; chan->chan_adapter = adapt; chan->chan_bustype = &scsi_bustype; chan->chan_channel = 0; chan->chan_flags = SCSIPI_CHAN_NOSETTLE | SCSIPI_CHAN_CANGROW; chan->chan_ntargets = 1; chan->chan_nluns = 16; chan->chan_id = sess->s_id; KERNEL_LOCK(1, NULL); sess->s_child_dev = config_found(dev, chan, scsiprint, CFARGS_NONE); found = (sess->s_child_dev != NULL); KERNEL_UNLOCK_ONE(NULL); return found; } /* * unmap_session * This (indirectly) unmaps the existing all LUNs for a target by * telling the config system that the adapter has detached. * * Parameter: the session pointer * * Returns: 1 on success, 0 on failure */ int unmap_session(session_t *sess) { device_t dev; int rv = 1; if ((dev = sess->s_child_dev) != NULL) { if (config_detach(dev, 0)) rv = 0; if (rv) sess->s_child_dev = NULL; } return rv; } /* * grow_resources * Try to grow openings up to current window size */ static int grow_resources(session_t *sess) { struct scsipi_adapter *adapt = &sess->s_sc_adapter; int win; int rc = -1; mutex_enter(&sess->s_lock); if (sess->s_refcount < CCBS_FOR_SCSIPI && sess->s_send_window < CCBS_FOR_SCSIPI) { win = window_size(sess, CCBS_FOR_SCSIPI - sess->s_refcount); if (win > sess->s_send_window) { sess->s_send_window++; adapt->adapt_openings++; rc = 0; DEB(5, ("Grow send window to %d\n", sess->s_send_window)); } } mutex_exit(&sess->s_lock); return rc; } /******************************************************************************/ /***************************************************************************** * SCSI interface routines *****************************************************************************/ /* * iscsi_scsipi_request: * Perform a request for the SCSIPI layer. */ void iscsi_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, void *arg) { struct scsipi_adapter *adapt = chan->chan_adapter; struct scsipi_xfer *xs; session_t *sess; int flags; struct scsipi_xfer_mode *xm; int error; sess = (session_t *) adapt; /* adapter is first field in session */ error = ref_session(sess); switch (req) { case ADAPTER_REQ_RUN_XFER: DEB(9, ("ISCSI: scsipi_request RUN_XFER\n")); xs = arg; flags = xs->xs_control; if (error) { DEB(9, ("ISCSI: refcount too high: %d, winsize %d\n", sess->s_refcount, sess->s_send_window)); xs->error = XS_BUSY; xs->status = SCSI_BUSY; scsipi_done(xs); return; } if ((flags & XS_CTL_POLL) != 0) { xs->error = XS_DRIVER_STUFFUP; DEBOUT(("Run Xfer request with polling\n")); scsipi_done(xs); break; } /* * NOTE: It appears that XS_CTL_DATA_UIO is not actually used anywhere. * Since it really would complicate matters to handle offsets * into scatter-gather lists, and a number of other drivers don't * handle uio-based data as well, XS_CTL_DATA_UIO isn't * implemented in this driver (at least for now). */ if (flags & XS_CTL_DATA_UIO) { xs->error = XS_DRIVER_STUFFUP; DEBOUT(("Run Xfer with data in UIO\n")); scsipi_done(xs); break; } send_run_xfer(sess, xs); DEB(15, ("scsipi_req returns, refcount = %d\n", sess->s_refcount)); return; case ADAPTER_REQ_GROW_RESOURCES: DEB(5, ("ISCSI: scsipi_request GROW_RESOURCES\n")); if (grow_resources(sess)) { /* reached maximum */ chan->chan_flags &= ~SCSIPI_CHAN_CANGROW; } break; case ADAPTER_REQ_SET_XFER_MODE: DEB(5, ("ISCSI: scsipi_request SET_XFER_MODE\n")); xm = (struct scsipi_xfer_mode *)arg; xm->xm_mode = PERIPH_CAP_TQING; scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm); break; default: DEBOUT(("ISCSI: scsipi_request with invalid REQ code %d\n", req)); break; } if (!error) unref_session(sess); } /* cap the transfer at 64K */ #define ISCSI_MAX_XFER 65536 /* * iscsi_minphys: * Limit a transfer to our maximum transfer size. */ void iscsi_minphys(struct buf *bp) { if (bp->b_bcount > ISCSI_MAX_XFER) { bp->b_bcount = ISCSI_MAX_XFER; } } /***************************************************************************** * SCSI job execution helper routines *****************************************************************************/ /* * iscsi_done: * * A CCB has completed execution. Pass the status back to the * upper layer. */ void iscsi_done(ccb_t *ccb) { struct scsipi_xfer *xs = ccb->ccb_xs; DEB(9, ("iscsi_done\n")); if (xs != NULL) { xs->resid = ccb->ccb_residual; ccb->ccb_xs = NULL; xs->resid = ccb->ccb_residual; switch (ccb->ccb_status) { case ISCSI_STATUS_SUCCESS: xs->error = XS_NOERROR; xs->status = SCSI_OK; break; case ISCSI_STATUS_CHECK_CONDITION: xs->error = XS_SENSE; xs->status = SCSI_CHECK; break; case ISCSI_STATUS_TARGET_BUSY: case ISCSI_STATUS_NO_RESOURCES: DEBC(ccb->ccb_connection, 5, ("target busy, ccb %p\n", ccb)); xs->error = XS_BUSY; xs->status = SCSI_BUSY; break; case ISCSI_STATUS_SOCKET_ERROR: case ISCSI_STATUS_TIMEOUT: xs->error = XS_SELTIMEOUT; xs->status = SCSI_BUSY; break; case ISCSI_STATUS_QUEUE_FULL: DEBC(ccb->ccb_connection, 5, ("queue full, ccb %p\n", ccb)); xs->error = XS_BUSY; xs->status = SCSI_QUEUE_FULL; break; default: xs->error = XS_DRIVER_STUFFUP; break; } unref_session(ccb->ccb_session); DEB(99, ("Calling scsipi_done (%p), err = %d\n", xs, xs->error)); scsipi_done(xs); DEB(99, ("scsipi_done returned\n")); } else { DEBOUT(("ISCSI: iscsi_done CCB %p without XS\n", ccb)); } } SYSCTL_SETUP(sysctl_iscsi_setup, "ISCSI subtree setup") { const struct sysctlnode *node = NULL; sysctl_createv(clog, 0, NULL, &node, CTLFLAG_PERMANENT, CTLTYPE_NODE, "iscsi", SYSCTL_DESCR("iscsi controls"), NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL); sysctl_createv(clog, 0, &node, NULL, CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_BOOL, "hexbignums", SYSCTL_DESCR("encode parameters in hex"), NULL, 0, &iscsi_hex_bignums, 0, CTL_CREATE, CTL_EOL); #ifdef ISCSI_DEBUG sysctl_createv(clog, 0, &node, NULL, CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, "debug", SYSCTL_DESCR("debug level"), NULL, 0, &iscsi_debug_level, sizeof(iscsi_debug_level), CTL_CREATE, CTL_EOL); #endif } /* Kernel Module support */ #include MODULE(MODULE_CLASS_DRIVER, iscsi, "scsi_subr"); /* Possibly a builtin module */ #ifdef _MODULE static const struct cfiattrdata ibescsi_info = { "scsi", 1, {{"channel", "-1", -1},} }; static const struct cfiattrdata *const iscsi_attrs[] = { &ibescsi_info, NULL }; CFDRIVER_DECL(iscsi, DV_DULL, iscsi_attrs); static struct cfdata iscsi_cfdata[] = { { .cf_name = "iscsi", .cf_atname = "iscsi", .cf_unit = 0, /* Only unit 0 is ever used */ .cf_fstate = FSTATE_NOTFOUND, .cf_loc = NULL, .cf_flags = 0, .cf_pspec = NULL, }, { NULL, NULL, 0, 0, NULL, 0, NULL } }; #endif static int iscsi_modcmd(modcmd_t cmd, void *arg) { #ifdef _MODULE devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR; int error; #endif switch (cmd) { case MODULE_CMD_INIT: #ifdef _MODULE error = devsw_attach(iscsi_cd.cd_name, NULL, &bmajor, &iscsi_cdevsw, &cmajor); if (error) { aprint_error("%s: unable to register devsw\n", iscsi_cd.cd_name); return error; } error = config_cfdriver_attach(&iscsi_cd); if (error) { devsw_detach(NULL, &iscsi_cdevsw); return error; } error = config_cfattach_attach(iscsi_cd.cd_name, &iscsi_ca); if (error) { config_cfdriver_detach(&iscsi_cd); devsw_detach(NULL, &iscsi_cdevsw); aprint_error("%s: unable to register cfattach\n", iscsi_cd.cd_name); return error; } error = config_cfdata_attach(iscsi_cfdata, 1); if (error) { aprint_error("%s: unable to attach cfdata\n", iscsi_cd.cd_name); config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca); config_cfdriver_detach(&iscsi_cd); devsw_detach(NULL, &iscsi_cdevsw); return error; } if (config_attach_pseudo(iscsi_cfdata) == NULL) { aprint_error("%s: config_attach_pseudo failed\n", iscsi_cd.cd_name); config_cfdata_detach(iscsi_cfdata); config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca); config_cfdriver_detach(&iscsi_cd); devsw_detach(NULL, &iscsi_cdevsw); return ENXIO; } #endif return 0; break; case MODULE_CMD_FINI: #ifdef _MODULE error = config_cfdata_detach(iscsi_cfdata); if (error) return error; config_cfdata_detach(iscsi_cfdata); config_cfattach_detach(iscsi_cd.cd_name, &iscsi_ca); config_cfdriver_detach(&iscsi_cd); devsw_detach(NULL, &iscsi_cdevsw); #endif return 0; break; case MODULE_CMD_AUTOUNLOAD: return EBUSY; break; default: return ENOTTY; break; } }