/* $NetBSD: iscsi_main.c,v 1.42 2023/12/28 15:58:24 mlelstv Exp $ */

/* $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 <sys/systm.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/kmem.h>
#include <sys/socketvar.h>
#include <sys/sysctl.h>

#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 <sys/module.h>

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;
}
}