9c6a092060
drivers. - change daprevent() to set CAM_RETRY_SELTO and SF_RETRY_UA when it calls cam_periph_runccb(). - change the pt(4) driver to ignore unit attentions - change the targ(4) driver to retry selection timeouts - clean up a few formatting glitches in the targ(4) driver Reviewed by: gibbs
2294 lines
59 KiB
C
2294 lines
59 KiB
C
/*
|
|
* Implementation of a simple Target Mode SCSI Proccessor Target driver for CAM.
|
|
*
|
|
* Copyright (c) 1998, 1999 Justin T. Gibbs.
|
|
* All rights reserved.
|
|
*
|
|
* 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,
|
|
* without modification, immediately at the beginning of the file.
|
|
* 2. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/types.h>
|
|
#include <sys/bio.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/devicestat.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/poll.h>
|
|
#include <sys/selinfo.h>
|
|
#include <sys/uio.h>
|
|
|
|
#include <cam/cam.h>
|
|
#include <cam/cam_ccb.h>
|
|
#include <cam/cam_extend.h>
|
|
#include <cam/cam_periph.h>
|
|
#include <cam/cam_queue.h>
|
|
#include <cam/cam_xpt_periph.h>
|
|
#include <cam/cam_debug.h>
|
|
|
|
#include <cam/scsi/scsi_all.h>
|
|
#include <cam/scsi/scsi_pt.h>
|
|
#include <cam/scsi/scsi_targetio.h>
|
|
#include <cam/scsi/scsi_message.h>
|
|
|
|
typedef enum {
|
|
TARG_STATE_NORMAL,
|
|
TARG_STATE_EXCEPTION,
|
|
TARG_STATE_TEARDOWN
|
|
} targ_state;
|
|
|
|
typedef enum {
|
|
TARG_FLAG_NONE = 0x00,
|
|
TARG_FLAG_SEND_EOF = 0x01,
|
|
TARG_FLAG_RECEIVE_EOF = 0x02,
|
|
TARG_FLAG_LUN_ENABLED = 0x04
|
|
} targ_flags;
|
|
|
|
typedef enum {
|
|
TARG_CCB_NONE = 0x00,
|
|
TARG_CCB_WAITING = 0x01,
|
|
TARG_CCB_HELDQ = 0x02,
|
|
TARG_CCB_ABORT_TO_HELDQ = 0x04
|
|
} targ_ccb_flags;
|
|
|
|
#define MAX_ACCEPT 16
|
|
#define MAX_IMMEDIATE 16
|
|
#define MAX_BUF_SIZE 256 /* Max inquiry/sense/mode page transfer */
|
|
#define MAX_INITIATORS 256 /* includes widest fibre channel for now */
|
|
|
|
#define MIN(a, b) ((a > b) ? b : a)
|
|
|
|
#define TARG_CONTROL_UNIT 0xffff00ff
|
|
#define TARG_IS_CONTROL_DEV(unit) ((unit) == TARG_CONTROL_UNIT)
|
|
|
|
#define TARG_TAG_WILDCARD ((u_int)~0)
|
|
|
|
/* Offsets into our private CCB area for storing accept information */
|
|
#define ccb_flags ppriv_field0
|
|
#define ccb_descr ppriv_ptr1
|
|
|
|
/* We stick a pointer to the originating accept TIO in each continue I/O CCB */
|
|
#define ccb_atio ppriv_ptr1
|
|
|
|
struct targ_softc {
|
|
/* CTIOs pending on the controller */
|
|
struct ccb_queue pending_queue;
|
|
|
|
/* ATIOs awaiting CTIO resources from the XPT */
|
|
struct ccb_queue work_queue;
|
|
|
|
/*
|
|
* ATIOs for SEND operations waiting for 'write'
|
|
* buffer resources from our userland daemon.
|
|
*/
|
|
struct ccb_queue snd_ccb_queue;
|
|
|
|
/*
|
|
* ATIOs for RCV operations waiting for 'read'
|
|
* buffer resources from our userland daemon.
|
|
*/
|
|
struct ccb_queue rcv_ccb_queue;
|
|
|
|
/*
|
|
* ATIOs for commands unknown to the kernel driver.
|
|
* These are queued for the userland daemon to
|
|
* consume.
|
|
*/
|
|
struct ccb_queue unknown_atio_queue;
|
|
|
|
/*
|
|
* Userland buffers for SEND commands waiting for
|
|
* SEND ATIOs to be queued by an initiator.
|
|
*/
|
|
struct bio_queue_head snd_bio_queue;
|
|
|
|
/*
|
|
* Userland buffers for RCV commands waiting for
|
|
* RCV ATIOs to be queued by an initiator.
|
|
*/
|
|
struct bio_queue_head rcv_bio_queue;
|
|
struct devstat device_stats;
|
|
dev_t targ_dev;
|
|
struct selinfo snd_select;
|
|
struct selinfo rcv_select;
|
|
targ_state state;
|
|
targ_flags flags;
|
|
targ_exception exceptions;
|
|
u_int init_level;
|
|
u_int inq_data_len;
|
|
struct scsi_inquiry_data *inq_data;
|
|
struct ccb_accept_tio *accept_tio_list;
|
|
struct ccb_hdr_slist immed_notify_slist;
|
|
struct initiator_state istate[MAX_INITIATORS];
|
|
};
|
|
|
|
struct targ_cmd_desc {
|
|
struct ccb_accept_tio* atio_link;
|
|
u_int data_resid; /* How much left to transfer */
|
|
u_int data_increment;/* Amount to send before next disconnect */
|
|
void* data; /* The data. Can be from backing_store or not */
|
|
void* backing_store;/* Backing store allocated for this descriptor*/
|
|
struct bio *bp; /* Buffer for this transfer */
|
|
u_int max_size; /* Size of backing_store */
|
|
u_int32_t timeout;
|
|
u_int8_t status; /* Status to return to initiator */
|
|
};
|
|
|
|
static d_open_t targopen;
|
|
static d_close_t targclose;
|
|
static d_read_t targread;
|
|
static d_write_t targwrite;
|
|
static d_ioctl_t targioctl;
|
|
static d_poll_t targpoll;
|
|
static d_strategy_t targstrategy;
|
|
|
|
#define TARG_CDEV_MAJOR 65
|
|
static struct cdevsw targ_cdevsw = {
|
|
/* open */ targopen,
|
|
/* close */ targclose,
|
|
/* read */ targread,
|
|
/* write */ targwrite,
|
|
/* ioctl */ targioctl,
|
|
/* poll */ targpoll,
|
|
/* mmap */ nommap,
|
|
/* strategy */ targstrategy,
|
|
/* name */ "targ",
|
|
/* maj */ TARG_CDEV_MAJOR,
|
|
/* dump */ nodump,
|
|
/* psize */ nopsize,
|
|
/* flags */ 0,
|
|
};
|
|
|
|
static int targsendccb(struct cam_periph *periph, union ccb *ccb,
|
|
union ccb *inccb);
|
|
static periph_init_t targinit;
|
|
static void targasync(void *callback_arg, u_int32_t code,
|
|
struct cam_path *path, void *arg);
|
|
static int targallocinstance(struct ioc_alloc_unit *alloc_unit);
|
|
static int targfreeinstance(struct ioc_alloc_unit *alloc_unit);
|
|
static cam_status targenlun(struct cam_periph *periph);
|
|
static cam_status targdislun(struct cam_periph *periph);
|
|
static periph_ctor_t targctor;
|
|
static periph_dtor_t targdtor;
|
|
static void targrunqueue(struct cam_periph *periph,
|
|
struct targ_softc *softc);
|
|
static periph_start_t targstart;
|
|
static void targdone(struct cam_periph *periph,
|
|
union ccb *done_ccb);
|
|
static void targfireexception(struct cam_periph *periph,
|
|
struct targ_softc *softc);
|
|
static void targinoterror(struct cam_periph *periph,
|
|
struct targ_softc *softc,
|
|
struct ccb_immed_notify *inot);
|
|
static int targerror(union ccb *ccb, u_int32_t cam_flags,
|
|
u_int32_t sense_flags);
|
|
static struct targ_cmd_desc* allocdescr(void);
|
|
static void freedescr(struct targ_cmd_desc *buf);
|
|
static void fill_sense(struct targ_softc *softc,
|
|
u_int initiator_id, u_int error_code,
|
|
u_int sense_key, u_int asc, u_int ascq);
|
|
static void copy_sense(struct targ_softc *softc,
|
|
struct initiator_state *istate,
|
|
u_int8_t *sense_buffer, size_t sense_len);
|
|
static void set_unit_attention_cond(struct cam_periph *periph,
|
|
u_int initiator_id, ua_types ua);
|
|
static void set_ca_condition(struct cam_periph *periph,
|
|
u_int initiator_id, ca_types ca);
|
|
static void abort_pending_transactions(struct cam_periph *periph,
|
|
u_int initiator_id, u_int tag_id,
|
|
int errno, int to_held_queue);
|
|
|
|
static struct periph_driver targdriver =
|
|
{
|
|
targinit, "targ",
|
|
TAILQ_HEAD_INITIALIZER(targdriver.units), /* generation */ 0
|
|
};
|
|
|
|
PERIPHDRIVER_DECLARE(targ, targdriver);
|
|
|
|
static struct extend_array *targperiphs;
|
|
static dev_t targ_ctl_dev;
|
|
|
|
static void
|
|
targinit(void)
|
|
{
|
|
/*
|
|
* Create our extend array for storing the devices we attach to.
|
|
*/
|
|
targperiphs = cam_extend_new();
|
|
if (targperiphs == NULL) {
|
|
printf("targ: Failed to alloc extend array!\n");
|
|
return;
|
|
}
|
|
targ_ctl_dev = make_dev(&targ_cdevsw, TARG_CONTROL_UNIT, UID_ROOT,
|
|
GID_OPERATOR, 0600, "%s.ctl", "targ");
|
|
if (targ_ctl_dev == (dev_t) 0) {
|
|
printf("targ: failed to create control dev\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
targasync(void *callback_arg, u_int32_t code,
|
|
struct cam_path *path, void *arg)
|
|
{
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
|
|
periph = (struct cam_periph *)callback_arg;
|
|
softc = (struct targ_softc *)periph->softc;
|
|
switch (code) {
|
|
case AC_PATH_DEREGISTERED:
|
|
{
|
|
/* XXX Implement */
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Attempt to enable our lun */
|
|
static cam_status
|
|
targenlun(struct cam_periph *periph)
|
|
{
|
|
union ccb immed_ccb;
|
|
struct targ_softc *softc;
|
|
cam_status status;
|
|
int i;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
if ((softc->flags & TARG_FLAG_LUN_ENABLED) != 0)
|
|
return (CAM_REQ_CMP);
|
|
|
|
xpt_setup_ccb(&immed_ccb.ccb_h, periph->path, /*priority*/1);
|
|
immed_ccb.ccb_h.func_code = XPT_EN_LUN;
|
|
|
|
/* Don't need support for any vendor specific commands */
|
|
immed_ccb.cel.grp6_len = 0;
|
|
immed_ccb.cel.grp7_len = 0;
|
|
immed_ccb.cel.enable = 1;
|
|
xpt_action(&immed_ccb);
|
|
status = immed_ccb.ccb_h.status;
|
|
if (status != CAM_REQ_CMP) {
|
|
xpt_print_path(periph->path);
|
|
printf("targenlun - Enable Lun Rejected with status 0x%x\n",
|
|
status);
|
|
return (status);
|
|
}
|
|
|
|
softc->flags |= TARG_FLAG_LUN_ENABLED;
|
|
|
|
/*
|
|
* Build up a buffer of accept target I/O
|
|
* operations for incoming selections.
|
|
*/
|
|
for (i = 0; i < MAX_ACCEPT; i++) {
|
|
struct ccb_accept_tio *atio;
|
|
|
|
atio = (struct ccb_accept_tio*)malloc(sizeof(*atio), M_DEVBUF,
|
|
M_NOWAIT);
|
|
if (atio == NULL) {
|
|
status = CAM_RESRC_UNAVAIL;
|
|
break;
|
|
}
|
|
|
|
atio->ccb_h.ccb_descr = allocdescr();
|
|
|
|
if (atio->ccb_h.ccb_descr == NULL) {
|
|
free(atio, M_DEVBUF);
|
|
status = CAM_RESRC_UNAVAIL;
|
|
break;
|
|
}
|
|
|
|
xpt_setup_ccb(&atio->ccb_h, periph->path, /*priority*/1);
|
|
atio->ccb_h.func_code = XPT_ACCEPT_TARGET_IO;
|
|
atio->ccb_h.cbfcnp = targdone;
|
|
atio->ccb_h.ccb_flags = TARG_CCB_NONE;
|
|
xpt_action((union ccb *)atio);
|
|
status = atio->ccb_h.status;
|
|
if (status != CAM_REQ_INPROG) {
|
|
xpt_print_path(periph->path);
|
|
printf("Queue of atio failed\n");
|
|
freedescr(atio->ccb_h.ccb_descr);
|
|
free(atio, M_DEVBUF);
|
|
break;
|
|
}
|
|
((struct targ_cmd_desc*)atio->ccb_h.ccb_descr)->atio_link =
|
|
softc->accept_tio_list;
|
|
softc->accept_tio_list = atio;
|
|
}
|
|
|
|
if (i == 0) {
|
|
xpt_print_path(periph->path);
|
|
printf("targenlun - Could not allocate accept tio CCBs: "
|
|
"status = 0x%x\n", status);
|
|
targdislun(periph);
|
|
return (CAM_REQ_CMP_ERR);
|
|
}
|
|
|
|
/*
|
|
* Build up a buffer of immediate notify CCBs
|
|
* so the SIM can tell us of asynchronous target mode events.
|
|
*/
|
|
for (i = 0; i < MAX_ACCEPT; i++) {
|
|
struct ccb_immed_notify *inot;
|
|
|
|
inot = (struct ccb_immed_notify*)malloc(sizeof(*inot), M_DEVBUF,
|
|
M_NOWAIT);
|
|
|
|
if (inot == NULL) {
|
|
status = CAM_RESRC_UNAVAIL;
|
|
break;
|
|
}
|
|
|
|
xpt_setup_ccb(&inot->ccb_h, periph->path, /*priority*/1);
|
|
inot->ccb_h.func_code = XPT_IMMED_NOTIFY;
|
|
inot->ccb_h.cbfcnp = targdone;
|
|
SLIST_INSERT_HEAD(&softc->immed_notify_slist, &inot->ccb_h,
|
|
periph_links.sle);
|
|
xpt_action((union ccb *)inot);
|
|
}
|
|
|
|
if (i == 0) {
|
|
xpt_print_path(periph->path);
|
|
printf("targenlun - Could not allocate immediate notify CCBs: "
|
|
"status = 0x%x\n", status);
|
|
targdislun(periph);
|
|
return (CAM_REQ_CMP_ERR);
|
|
}
|
|
|
|
return (CAM_REQ_CMP);
|
|
}
|
|
|
|
static cam_status
|
|
targdislun(struct cam_periph *periph)
|
|
{
|
|
union ccb ccb;
|
|
struct targ_softc *softc;
|
|
struct ccb_accept_tio* atio;
|
|
struct ccb_hdr *ccb_h;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
if ((softc->flags & TARG_FLAG_LUN_ENABLED) == 0)
|
|
return CAM_REQ_CMP;
|
|
|
|
/* XXX Block for Continue I/O completion */
|
|
|
|
/* Kill off all ACCECPT and IMMEDIATE CCBs */
|
|
while ((atio = softc->accept_tio_list) != NULL) {
|
|
|
|
softc->accept_tio_list =
|
|
((struct targ_cmd_desc*)atio->ccb_h.ccb_descr)->atio_link;
|
|
xpt_setup_ccb(&ccb.cab.ccb_h, periph->path, /*priority*/1);
|
|
ccb.cab.ccb_h.func_code = XPT_ABORT;
|
|
ccb.cab.abort_ccb = (union ccb *)atio;
|
|
xpt_action(&ccb);
|
|
}
|
|
|
|
while ((ccb_h = SLIST_FIRST(&softc->immed_notify_slist)) != NULL) {
|
|
SLIST_REMOVE_HEAD(&softc->immed_notify_slist, periph_links.sle);
|
|
xpt_setup_ccb(&ccb.cab.ccb_h, periph->path, /*priority*/1);
|
|
ccb.cab.ccb_h.func_code = XPT_ABORT;
|
|
ccb.cab.abort_ccb = (union ccb *)ccb_h;
|
|
xpt_action(&ccb);
|
|
}
|
|
|
|
/*
|
|
* Dissable this lun.
|
|
*/
|
|
xpt_setup_ccb(&ccb.cel.ccb_h, periph->path, /*priority*/1);
|
|
ccb.cel.ccb_h.func_code = XPT_EN_LUN;
|
|
ccb.cel.enable = 0;
|
|
xpt_action(&ccb);
|
|
|
|
if (ccb.cel.ccb_h.status != CAM_REQ_CMP)
|
|
printf("targdislun - Disabling lun on controller failed "
|
|
"with status 0x%x\n", ccb.cel.ccb_h.status);
|
|
else
|
|
softc->flags &= ~TARG_FLAG_LUN_ENABLED;
|
|
return (ccb.cel.ccb_h.status);
|
|
}
|
|
|
|
static cam_status
|
|
targctor(struct cam_periph *periph, void *arg)
|
|
{
|
|
struct ccb_pathinq *cpi;
|
|
struct targ_softc *softc;
|
|
int i;
|
|
|
|
cpi = (struct ccb_pathinq *)arg;
|
|
|
|
/* Allocate our per-instance private storage */
|
|
softc = (struct targ_softc *)malloc(sizeof(*softc), M_DEVBUF, M_NOWAIT);
|
|
if (softc == NULL) {
|
|
printf("targctor: unable to malloc softc\n");
|
|
return (CAM_REQ_CMP_ERR);
|
|
}
|
|
|
|
bzero(softc, sizeof(*softc));
|
|
TAILQ_INIT(&softc->pending_queue);
|
|
TAILQ_INIT(&softc->work_queue);
|
|
TAILQ_INIT(&softc->snd_ccb_queue);
|
|
TAILQ_INIT(&softc->rcv_ccb_queue);
|
|
TAILQ_INIT(&softc->unknown_atio_queue);
|
|
bioq_init(&softc->snd_bio_queue);
|
|
bioq_init(&softc->rcv_bio_queue);
|
|
softc->accept_tio_list = NULL;
|
|
SLIST_INIT(&softc->immed_notify_slist);
|
|
softc->state = TARG_STATE_NORMAL;
|
|
periph->softc = softc;
|
|
softc->init_level++;
|
|
|
|
cam_extend_set(targperiphs, periph->unit_number, periph);
|
|
|
|
/*
|
|
* We start out life with a UA to indicate power-on/reset.
|
|
*/
|
|
for (i = 0; i < MAX_INITIATORS; i++)
|
|
softc->istate[i].pending_ua = UA_POWER_ON;
|
|
|
|
/*
|
|
* Allocate an initial inquiry data buffer. We might allow the
|
|
* user to override this later via an ioctl.
|
|
*/
|
|
softc->inq_data_len = sizeof(*softc->inq_data);
|
|
softc->inq_data = malloc(softc->inq_data_len, M_DEVBUF, M_NOWAIT);
|
|
if (softc->inq_data == NULL) {
|
|
printf("targctor - Unable to malloc inquiry data\n");
|
|
targdtor(periph);
|
|
return (CAM_RESRC_UNAVAIL);
|
|
}
|
|
bzero(softc->inq_data, softc->inq_data_len);
|
|
softc->inq_data->device = T_PROCESSOR | (SID_QUAL_LU_CONNECTED << 5);
|
|
softc->inq_data->version = 2;
|
|
softc->inq_data->response_format = 2; /* SCSI2 Inquiry Format */
|
|
softc->inq_data->flags =
|
|
cpi->hba_inquiry & (PI_SDTR_ABLE|PI_WIDE_16|PI_WIDE_32|PI_TAG_ABLE);
|
|
softc->inq_data->additional_length = softc->inq_data_len - 4;
|
|
strncpy(softc->inq_data->vendor, "FreeBSD ", SID_VENDOR_SIZE);
|
|
strncpy(softc->inq_data->product, "TM-PT ", SID_PRODUCT_SIZE);
|
|
strncpy(softc->inq_data->revision, "0.0 ", SID_REVISION_SIZE);
|
|
softc->targ_dev = make_dev(&targ_cdevsw, periph->unit_number, UID_ROOT,
|
|
GID_OPERATOR, 0600, "%s%d",
|
|
periph->periph_name, periph->unit_number);
|
|
softc->init_level++;
|
|
return (CAM_REQ_CMP);
|
|
}
|
|
|
|
static void
|
|
targdtor(struct cam_periph *periph)
|
|
{
|
|
struct targ_softc *softc;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
softc->state = TARG_STATE_TEARDOWN;
|
|
|
|
targdislun(periph);
|
|
|
|
cam_extend_release(targperiphs, periph->unit_number);
|
|
|
|
switch (softc->init_level) {
|
|
default:
|
|
/* FALLTHROUGH */
|
|
case 2:
|
|
free(softc->inq_data, M_DEVBUF);
|
|
destroy_dev(softc->targ_dev);
|
|
/* FALLTHROUGH */
|
|
case 1:
|
|
free(softc, M_DEVBUF);
|
|
break;
|
|
case 0:
|
|
panic("targdtor - impossible init level");;
|
|
}
|
|
}
|
|
|
|
static int
|
|
targopen(dev_t dev, int flags, int fmt, struct proc *p)
|
|
{
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
u_int unit;
|
|
cam_status status;
|
|
int error;
|
|
int s;
|
|
|
|
unit = minor(dev);
|
|
|
|
/* An open of the control device always succeeds */
|
|
if (TARG_IS_CONTROL_DEV(unit))
|
|
return 0;
|
|
|
|
s = splsoftcam();
|
|
periph = cam_extend_get(targperiphs, unit);
|
|
if (periph == NULL) {
|
|
splx(s);
|
|
return (ENXIO);
|
|
}
|
|
if ((error = cam_periph_lock(periph, PRIBIO | PCATCH)) != 0) {
|
|
splx(s);
|
|
return (error);
|
|
}
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
if ((softc->flags & TARG_FLAG_LUN_ENABLED) == 0) {
|
|
if (cam_periph_acquire(periph) != CAM_REQ_CMP) {
|
|
splx(s);
|
|
cam_periph_unlock(periph);
|
|
return(ENXIO);
|
|
}
|
|
}
|
|
splx(s);
|
|
|
|
status = targenlun(periph);
|
|
switch (status) {
|
|
case CAM_REQ_CMP:
|
|
error = 0;
|
|
break;
|
|
case CAM_RESRC_UNAVAIL:
|
|
error = ENOMEM;
|
|
break;
|
|
case CAM_LUN_ALRDY_ENA:
|
|
error = EADDRINUSE;
|
|
break;
|
|
default:
|
|
error = ENXIO;
|
|
break;
|
|
}
|
|
cam_periph_unlock(periph);
|
|
if (error) {
|
|
cam_periph_release(periph);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
targclose(dev_t dev, int flag, int fmt, struct proc *p)
|
|
{
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
u_int unit;
|
|
int s;
|
|
int error;
|
|
|
|
unit = minor(dev);
|
|
|
|
/* A close of the control device always succeeds */
|
|
if (TARG_IS_CONTROL_DEV(unit))
|
|
return 0;
|
|
|
|
s = splsoftcam();
|
|
periph = cam_extend_get(targperiphs, unit);
|
|
if (periph == NULL) {
|
|
splx(s);
|
|
return (ENXIO);
|
|
}
|
|
if ((error = cam_periph_lock(periph, PRIBIO)) != 0)
|
|
return (error);
|
|
softc = (struct targ_softc *)periph->softc;
|
|
splx(s);
|
|
|
|
targdislun(periph);
|
|
|
|
cam_periph_unlock(periph);
|
|
cam_periph_release(periph);
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
targallocinstance(struct ioc_alloc_unit *alloc_unit)
|
|
{
|
|
struct ccb_pathinq cpi;
|
|
struct cam_path *path;
|
|
struct cam_periph *periph;
|
|
cam_status status;
|
|
int free_path_on_return;
|
|
int error;
|
|
|
|
free_path_on_return = 0;
|
|
status = xpt_create_path(&path, /*periph*/NULL,
|
|
alloc_unit->path_id,
|
|
alloc_unit->target_id,
|
|
alloc_unit->lun_id);
|
|
if (status != CAM_REQ_CMP) {
|
|
printf("Couldn't Allocate Path %x\n", status);
|
|
goto fail;
|
|
}
|
|
|
|
free_path_on_return++;
|
|
|
|
|
|
xpt_setup_ccb(&cpi.ccb_h, path, /*priority*/1);
|
|
cpi.ccb_h.func_code = XPT_PATH_INQ;
|
|
xpt_action((union ccb *)&cpi);
|
|
status = cpi.ccb_h.status;
|
|
|
|
if (status != CAM_REQ_CMP) {
|
|
printf("Couldn't CPI %x\n", status);
|
|
goto fail;
|
|
}
|
|
|
|
/* Can only alloc units on controllers that support target mode */
|
|
if ((cpi.target_sprt & PIT_PROCESSOR) == 0) {
|
|
printf("Controller does not support target mode%x\n", status);
|
|
status = CAM_PATH_INVALID;
|
|
goto fail;
|
|
}
|
|
|
|
/* Ensure that we don't already have an instance for this unit. */
|
|
if ((periph = cam_periph_find(path, "targ")) != NULL) {
|
|
status = CAM_LUN_ALRDY_ENA;
|
|
goto fail;
|
|
}
|
|
|
|
/*
|
|
* Allocate a peripheral instance for
|
|
* this target instance.
|
|
*/
|
|
status = cam_periph_alloc(targctor, NULL, targdtor, targstart,
|
|
"targ", CAM_PERIPH_BIO, path, targasync,
|
|
0, &cpi);
|
|
|
|
fail:
|
|
switch (status) {
|
|
case CAM_REQ_CMP:
|
|
{
|
|
struct cam_periph *periph;
|
|
|
|
if ((periph = cam_periph_find(path, "targ")) == NULL)
|
|
panic("targallocinstance: Succeeded but no periph?");
|
|
error = 0;
|
|
alloc_unit->unit = periph->unit_number;
|
|
break;
|
|
}
|
|
case CAM_RESRC_UNAVAIL:
|
|
error = ENOMEM;
|
|
break;
|
|
case CAM_LUN_ALRDY_ENA:
|
|
error = EADDRINUSE;
|
|
break;
|
|
default:
|
|
printf("targallocinstance: Unexpected CAM status %x\n", status);
|
|
/* FALLTHROUGH */
|
|
case CAM_PATH_INVALID:
|
|
error = ENXIO;
|
|
break;
|
|
case CAM_PROVIDE_FAIL:
|
|
error = ENODEV;
|
|
break;
|
|
}
|
|
|
|
if (free_path_on_return != 0)
|
|
xpt_free_path(path);
|
|
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
targfreeinstance(struct ioc_alloc_unit *alloc_unit)
|
|
{
|
|
struct cam_path *path;
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
cam_status status;
|
|
int free_path_on_return;
|
|
int error;
|
|
|
|
periph = NULL;
|
|
free_path_on_return = 0;
|
|
status = xpt_create_path(&path, /*periph*/NULL,
|
|
alloc_unit->path_id,
|
|
alloc_unit->target_id,
|
|
alloc_unit->lun_id);
|
|
free_path_on_return++;
|
|
|
|
if (status != CAM_REQ_CMP)
|
|
goto fail;
|
|
|
|
/* Find our instance. */
|
|
if ((periph = cam_periph_find(path, "targ")) == NULL) {
|
|
xpt_print_path(path);
|
|
printf("Invalid path specified for freeing target instance\n");
|
|
status = CAM_PATH_INVALID;
|
|
goto fail;
|
|
}
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
if ((softc->flags & TARG_FLAG_LUN_ENABLED) != 0) {
|
|
status = CAM_BUSY;
|
|
goto fail;
|
|
}
|
|
|
|
fail:
|
|
if (free_path_on_return != 0)
|
|
xpt_free_path(path);
|
|
|
|
switch (status) {
|
|
case CAM_REQ_CMP:
|
|
if (periph != NULL)
|
|
cam_periph_invalidate(periph);
|
|
error = 0;
|
|
break;
|
|
case CAM_RESRC_UNAVAIL:
|
|
error = ENOMEM;
|
|
break;
|
|
case CAM_LUN_ALRDY_ENA:
|
|
error = EADDRINUSE;
|
|
break;
|
|
default:
|
|
printf("targfreeinstance: Unexpected CAM status %x\n", status);
|
|
/* FALLTHROUGH */
|
|
case CAM_PATH_INVALID:
|
|
error = ENODEV;
|
|
break;
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
targioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
|
|
{
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
u_int unit;
|
|
int error;
|
|
|
|
unit = minor(dev);
|
|
error = 0;
|
|
if (TARG_IS_CONTROL_DEV(unit)) {
|
|
switch (cmd) {
|
|
case TARGCTLIOALLOCUNIT:
|
|
error = targallocinstance((struct ioc_alloc_unit*)addr);
|
|
break;
|
|
case TARGCTLIOFREEUNIT:
|
|
error = targfreeinstance((struct ioc_alloc_unit*)addr);
|
|
break;
|
|
default:
|
|
error = EINVAL;
|
|
break;
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
periph = cam_extend_get(targperiphs, unit);
|
|
if (periph == NULL)
|
|
return (ENXIO);
|
|
softc = (struct targ_softc *)periph->softc;
|
|
switch (cmd) {
|
|
case TARGIOCFETCHEXCEPTION:
|
|
*((targ_exception *)addr) = softc->exceptions;
|
|
break;
|
|
case TARGIOCCLEAREXCEPTION:
|
|
{
|
|
targ_exception clear_mask;
|
|
|
|
clear_mask = *((targ_exception *)addr);
|
|
if ((clear_mask & TARG_EXCEPT_UNKNOWN_ATIO) != 0) {
|
|
struct ccb_hdr *ccbh;
|
|
|
|
ccbh = TAILQ_FIRST(&softc->unknown_atio_queue);
|
|
if (ccbh != NULL) {
|
|
TAILQ_REMOVE(&softc->unknown_atio_queue,
|
|
ccbh, periph_links.tqe);
|
|
/* Requeue the ATIO back to the controller */
|
|
ccbh->ccb_flags = TARG_CCB_NONE;
|
|
xpt_action((union ccb *)ccbh);
|
|
ccbh = TAILQ_FIRST(&softc->unknown_atio_queue);
|
|
}
|
|
if (ccbh != NULL)
|
|
clear_mask &= ~TARG_EXCEPT_UNKNOWN_ATIO;
|
|
}
|
|
softc->exceptions &= ~clear_mask;
|
|
if (softc->exceptions == TARG_EXCEPT_NONE
|
|
&& softc->state == TARG_STATE_EXCEPTION) {
|
|
softc->state = TARG_STATE_NORMAL;
|
|
targrunqueue(periph, softc);
|
|
}
|
|
break;
|
|
}
|
|
case TARGIOCFETCHATIO:
|
|
{
|
|
struct ccb_hdr *ccbh;
|
|
|
|
ccbh = TAILQ_FIRST(&softc->unknown_atio_queue);
|
|
if (ccbh != NULL) {
|
|
bcopy(ccbh, addr, sizeof(struct ccb_accept_tio));
|
|
} else {
|
|
error = ENOENT;
|
|
}
|
|
break;
|
|
}
|
|
case TARGIOCCOMMAND:
|
|
{
|
|
union ccb *inccb;
|
|
union ccb *ccb;
|
|
|
|
/*
|
|
* XXX JGibbs
|
|
* This code is lifted directly from the pass-thru driver.
|
|
* Perhaps this should be moved to a library????
|
|
*/
|
|
inccb = (union ccb *)addr;
|
|
ccb = cam_periph_getccb(periph, inccb->ccb_h.pinfo.priority);
|
|
|
|
error = targsendccb(periph, ccb, inccb);
|
|
|
|
xpt_release_ccb(ccb);
|
|
|
|
break;
|
|
}
|
|
case TARGIOCGETISTATE:
|
|
case TARGIOCSETISTATE:
|
|
{
|
|
struct ioc_initiator_state *ioc_istate;
|
|
|
|
ioc_istate = (struct ioc_initiator_state *)addr;
|
|
if (ioc_istate->initiator_id > MAX_INITIATORS) {
|
|
error = EINVAL;
|
|
break;
|
|
}
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("GET/SETISTATE for %d\n", ioc_istate->initiator_id));
|
|
if (cmd == TARGIOCGETISTATE) {
|
|
bcopy(&softc->istate[ioc_istate->initiator_id],
|
|
&ioc_istate->istate, sizeof(ioc_istate->istate));
|
|
} else {
|
|
bcopy(&ioc_istate->istate,
|
|
&softc->istate[ioc_istate->initiator_id],
|
|
sizeof(ioc_istate->istate));
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("pending_ca now %x\n",
|
|
softc->istate[ioc_istate->initiator_id].pending_ca));
|
|
}
|
|
break;
|
|
}
|
|
#ifdef CAMDEBUG
|
|
case TARGIODEBUG:
|
|
{
|
|
union ccb ccb;
|
|
bzero (&ccb, sizeof ccb);
|
|
if (xpt_create_path(&ccb.ccb_h.path, periph,
|
|
xpt_path_path_id(periph->path),
|
|
xpt_path_target_id(periph->path),
|
|
xpt_path_lun_id(periph->path)) != CAM_REQ_CMP) {
|
|
error = EINVAL;
|
|
break;
|
|
}
|
|
if (*((int *)addr)) {
|
|
ccb.cdbg.flags = CAM_DEBUG_PERIPH;
|
|
} else {
|
|
ccb.cdbg.flags = CAM_DEBUG_NONE;
|
|
}
|
|
xpt_setup_ccb(&ccb.ccb_h, ccb.ccb_h.path, 0);
|
|
ccb.ccb_h.func_code = XPT_DEBUG;
|
|
ccb.ccb_h.path_id = xpt_path_path_id(ccb.ccb_h.path);
|
|
ccb.ccb_h.target_id = xpt_path_target_id(ccb.ccb_h.path);
|
|
ccb.ccb_h.target_lun = xpt_path_lun_id(ccb.ccb_h.path);
|
|
ccb.ccb_h.cbfcnp = targdone;
|
|
xpt_action(&ccb);
|
|
if ((ccb.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
|
|
error = EIO;
|
|
} else {
|
|
error = 0;
|
|
}
|
|
xpt_free_path(ccb.ccb_h.path);
|
|
break;
|
|
}
|
|
#endif
|
|
default:
|
|
error = ENOTTY;
|
|
break;
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* XXX JGibbs lifted from pass-thru driver.
|
|
* Generally, "ccb" should be the CCB supplied by the kernel. "inccb"
|
|
* should be the CCB that is copied in from the user.
|
|
*/
|
|
static int
|
|
targsendccb(struct cam_periph *periph, union ccb *ccb, union ccb *inccb)
|
|
{
|
|
struct targ_softc *softc;
|
|
struct cam_periph_map_info mapinfo;
|
|
int error, need_unmap;
|
|
int s;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
need_unmap = 0;
|
|
|
|
/*
|
|
* There are some fields in the CCB header that need to be
|
|
* preserved, the rest we get from the user.
|
|
*/
|
|
xpt_merge_ccb(ccb, inccb);
|
|
|
|
/*
|
|
* There's no way for the user to have a completion
|
|
* function, so we put our own completion function in here.
|
|
*/
|
|
ccb->ccb_h.cbfcnp = targdone;
|
|
|
|
/*
|
|
* We only attempt to map the user memory into kernel space
|
|
* if they haven't passed in a physical memory pointer,
|
|
* and if there is actually an I/O operation to perform.
|
|
* Right now cam_periph_mapmem() only supports SCSI and device
|
|
* match CCBs. For the SCSI CCBs, we only pass the CCB in if
|
|
* there's actually data to map. cam_periph_mapmem() will do the
|
|
* right thing, even if there isn't data to map, but since CCBs
|
|
* without data are a reasonably common occurance (e.g. test unit
|
|
* ready), it will save a few cycles if we check for it here.
|
|
*/
|
|
if (((ccb->ccb_h.flags & CAM_DATA_PHYS) == 0)
|
|
&& (((ccb->ccb_h.func_code == XPT_CONT_TARGET_IO)
|
|
&& ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE))
|
|
|| (ccb->ccb_h.func_code == XPT_DEV_MATCH))) {
|
|
|
|
bzero(&mapinfo, sizeof(mapinfo));
|
|
|
|
error = cam_periph_mapmem(ccb, &mapinfo);
|
|
|
|
/*
|
|
* cam_periph_mapmem returned an error, we can't continue.
|
|
* Return the error to the user.
|
|
*/
|
|
if (error)
|
|
return(error);
|
|
|
|
/*
|
|
* We successfully mapped the memory in, so we need to
|
|
* unmap it when the transaction is done.
|
|
*/
|
|
need_unmap = 1;
|
|
}
|
|
|
|
/*
|
|
* Once queued on the pending CCB list, this CCB will be protected
|
|
* by the error recovery handling used for 'buffer I/O' ccbs. Since
|
|
* we are in a process context here, however, the software interrupt
|
|
* for this driver may deliver an event invalidating this CCB just
|
|
* before we queue it. Close this race condition by blocking
|
|
* software interrupt delivery, checking for any pertinent queued
|
|
* events, and only then queuing this CCB.
|
|
*/
|
|
s = splsoftcam();
|
|
if (softc->exceptions == 0) {
|
|
if (ccb->ccb_h.func_code == XPT_CONT_TARGET_IO)
|
|
TAILQ_INSERT_TAIL(&softc->pending_queue, &ccb->ccb_h,
|
|
periph_links.tqe);
|
|
|
|
/*
|
|
* If the user wants us to perform any error recovery,
|
|
* then honor that request. Otherwise, it's up to the
|
|
* user to perform any error recovery.
|
|
*/
|
|
error = cam_periph_runccb(ccb, /* error handler */NULL,
|
|
CAM_RETRY_SELTO, SF_RETRY_UA,
|
|
&softc->device_stats);
|
|
|
|
if (ccb->ccb_h.func_code == XPT_CONT_TARGET_IO)
|
|
TAILQ_REMOVE(&softc->pending_queue, &ccb->ccb_h,
|
|
periph_links.tqe);
|
|
} else {
|
|
ccb->ccb_h.status = CAM_UNACKED_EVENT;
|
|
error = 0;
|
|
}
|
|
splx(s);
|
|
|
|
if (need_unmap != 0)
|
|
cam_periph_unmapmem(ccb, &mapinfo);
|
|
|
|
ccb->ccb_h.cbfcnp = NULL;
|
|
ccb->ccb_h.periph_priv = inccb->ccb_h.periph_priv;
|
|
bcopy(ccb, inccb, sizeof(union ccb));
|
|
|
|
return(error);
|
|
}
|
|
|
|
|
|
static int
|
|
targpoll(dev_t dev, int poll_events, struct proc *p)
|
|
{
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
u_int unit;
|
|
int revents;
|
|
int s;
|
|
|
|
unit = minor(dev);
|
|
|
|
/* ioctl is the only supported operation of the control device */
|
|
if (TARG_IS_CONTROL_DEV(unit))
|
|
return EINVAL;
|
|
|
|
periph = cam_extend_get(targperiphs, unit);
|
|
if (periph == NULL)
|
|
return (ENXIO);
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
revents = 0;
|
|
s = splcam();
|
|
if ((poll_events & (POLLOUT | POLLWRNORM)) != 0) {
|
|
if (TAILQ_FIRST(&softc->rcv_ccb_queue) != NULL
|
|
&& bioq_first(&softc->rcv_bio_queue) == NULL)
|
|
revents |= poll_events & (POLLOUT | POLLWRNORM);
|
|
}
|
|
if ((poll_events & (POLLIN | POLLRDNORM)) != 0) {
|
|
if (TAILQ_FIRST(&softc->snd_ccb_queue) != NULL
|
|
&& bioq_first(&softc->snd_bio_queue) == NULL)
|
|
revents |= poll_events & (POLLIN | POLLRDNORM);
|
|
}
|
|
|
|
if (softc->state != TARG_STATE_NORMAL)
|
|
revents |= POLLERR;
|
|
|
|
if (revents == 0) {
|
|
if (poll_events & (POLLOUT | POLLWRNORM))
|
|
selrecord(p, &softc->rcv_select);
|
|
if (poll_events & (POLLIN | POLLRDNORM))
|
|
selrecord(p, &softc->snd_select);
|
|
}
|
|
splx(s);
|
|
return (revents);
|
|
}
|
|
|
|
static int
|
|
targread(dev_t dev, struct uio *uio, int ioflag)
|
|
{
|
|
u_int unit;
|
|
|
|
unit = minor(dev);
|
|
/* ioctl is the only supported operation of the control device */
|
|
if (TARG_IS_CONTROL_DEV(unit))
|
|
return EINVAL;
|
|
|
|
if (uio->uio_iovcnt == 0
|
|
|| uio->uio_iov->iov_len == 0) {
|
|
/* EOF */
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
int s;
|
|
|
|
s = splcam();
|
|
periph = cam_extend_get(targperiphs, unit);
|
|
if (periph == NULL)
|
|
return (ENXIO);
|
|
softc = (struct targ_softc *)periph->softc;
|
|
softc->flags |= TARG_FLAG_SEND_EOF;
|
|
splx(s);
|
|
targrunqueue(periph, softc);
|
|
return (0);
|
|
}
|
|
return(physread(dev, uio, ioflag));
|
|
}
|
|
|
|
static int
|
|
targwrite(dev_t dev, struct uio *uio, int ioflag)
|
|
{
|
|
u_int unit;
|
|
|
|
unit = minor(dev);
|
|
/* ioctl is the only supported operation of the control device */
|
|
if (TARG_IS_CONTROL_DEV(unit))
|
|
return EINVAL;
|
|
|
|
if (uio->uio_iovcnt == 0
|
|
|| uio->uio_iov->iov_len == 0) {
|
|
/* EOF */
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
int s;
|
|
|
|
s = splcam();
|
|
periph = cam_extend_get(targperiphs, unit);
|
|
if (periph == NULL)
|
|
return (ENXIO);
|
|
softc = (struct targ_softc *)periph->softc;
|
|
softc->flags |= TARG_FLAG_RECEIVE_EOF;
|
|
splx(s);
|
|
targrunqueue(periph, softc);
|
|
return (0);
|
|
}
|
|
return(physwrite(dev, uio, ioflag));
|
|
}
|
|
|
|
/*
|
|
* Actually translate the requested transfer into one the physical driver
|
|
* can understand. The transfer is described by a buf and will include
|
|
* only one physical transfer.
|
|
*/
|
|
static void
|
|
targstrategy(struct bio *bp)
|
|
{
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
u_int unit;
|
|
int s;
|
|
|
|
unit = minor(bp->bio_dev);
|
|
|
|
/* ioctl is the only supported operation of the control device */
|
|
if (TARG_IS_CONTROL_DEV(unit)) {
|
|
bp->bio_error = EINVAL;
|
|
goto bad;
|
|
}
|
|
|
|
periph = cam_extend_get(targperiphs, unit);
|
|
if (periph == NULL) {
|
|
bp->bio_error = ENXIO;
|
|
goto bad;
|
|
}
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
/*
|
|
* Mask interrupts so that the device cannot be invalidated until
|
|
* after we are in the queue. Otherwise, we might not properly
|
|
* clean up one of the buffers.
|
|
*/
|
|
s = splbio();
|
|
|
|
/*
|
|
* If there is an exception pending, error out
|
|
*/
|
|
if (softc->state != TARG_STATE_NORMAL) {
|
|
splx(s);
|
|
if (softc->state == TARG_STATE_EXCEPTION
|
|
&& (softc->exceptions & TARG_EXCEPT_DEVICE_INVALID) == 0)
|
|
bp->bio_error = EBUSY;
|
|
else
|
|
bp->bio_error = ENXIO;
|
|
goto bad;
|
|
}
|
|
|
|
/*
|
|
* Place it in the queue of buffers available for either
|
|
* SEND or RECEIVE commands.
|
|
*
|
|
*/
|
|
bp->bio_resid = bp->bio_bcount;
|
|
if (bp->bio_cmd == BIO_READ) {
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Queued a SEND buffer\n"));
|
|
bioq_insert_tail(&softc->snd_bio_queue, bp);
|
|
} else {
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Queued a RECEIVE buffer\n"));
|
|
bioq_insert_tail(&softc->rcv_bio_queue, bp);
|
|
}
|
|
|
|
splx(s);
|
|
|
|
/*
|
|
* Attempt to use the new buffer to service any pending
|
|
* target commands.
|
|
*/
|
|
targrunqueue(periph, softc);
|
|
|
|
return;
|
|
bad:
|
|
bp->bio_flags |= BIO_ERROR;
|
|
|
|
/*
|
|
* Correctly set the buf to indicate a completed xfer
|
|
*/
|
|
bp->bio_resid = bp->bio_bcount;
|
|
biodone(bp);
|
|
}
|
|
|
|
static void
|
|
targrunqueue(struct cam_periph *periph, struct targ_softc *softc)
|
|
{
|
|
struct ccb_queue *pending_queue;
|
|
struct ccb_accept_tio *atio;
|
|
struct bio_queue_head *bioq;
|
|
struct bio *bp;
|
|
struct targ_cmd_desc *desc;
|
|
struct ccb_hdr *ccbh;
|
|
int s;
|
|
|
|
s = splbio();
|
|
pending_queue = NULL;
|
|
bioq = NULL;
|
|
ccbh = NULL;
|
|
/* Only run one request at a time to maintain data ordering. */
|
|
if (softc->state != TARG_STATE_NORMAL
|
|
|| TAILQ_FIRST(&softc->work_queue) != NULL
|
|
|| TAILQ_FIRST(&softc->pending_queue) != NULL) {
|
|
splx(s);
|
|
return;
|
|
}
|
|
|
|
if (((bp = bioq_first(&softc->snd_bio_queue)) != NULL
|
|
|| (softc->flags & TARG_FLAG_SEND_EOF) != 0)
|
|
&& (ccbh = TAILQ_FIRST(&softc->snd_ccb_queue)) != NULL) {
|
|
|
|
if (bp == NULL)
|
|
softc->flags &= ~TARG_FLAG_SEND_EOF;
|
|
else {
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("De-Queued a SEND buffer %ld\n",
|
|
bp->bio_bcount));
|
|
}
|
|
bioq = &softc->snd_bio_queue;
|
|
pending_queue = &softc->snd_ccb_queue;
|
|
} else if (((bp = bioq_first(&softc->rcv_bio_queue)) != NULL
|
|
|| (softc->flags & TARG_FLAG_RECEIVE_EOF) != 0)
|
|
&& (ccbh = TAILQ_FIRST(&softc->rcv_ccb_queue)) != NULL) {
|
|
|
|
if (bp == NULL)
|
|
softc->flags &= ~TARG_FLAG_RECEIVE_EOF;
|
|
else {
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("De-Queued a RECEIVE buffer %ld\n",
|
|
bp->bio_bcount));
|
|
}
|
|
bioq = &softc->rcv_bio_queue;
|
|
pending_queue = &softc->rcv_ccb_queue;
|
|
}
|
|
|
|
if (pending_queue != NULL) {
|
|
/* Process a request */
|
|
atio = (struct ccb_accept_tio *)ccbh;
|
|
TAILQ_REMOVE(pending_queue, ccbh, periph_links.tqe);
|
|
desc = (struct targ_cmd_desc *)atio->ccb_h.ccb_descr;
|
|
desc->bp = bp;
|
|
if (bp == NULL) {
|
|
/* EOF */
|
|
desc->data = NULL;
|
|
desc->data_increment = 0;
|
|
desc->data_resid = 0;
|
|
atio->ccb_h.flags &= ~CAM_DIR_MASK;
|
|
atio->ccb_h.flags |= CAM_DIR_NONE;
|
|
} else {
|
|
bioq_remove(bioq, bp);
|
|
desc->data = &bp->bio_data[bp->bio_bcount - bp->bio_resid];
|
|
desc->data_increment =
|
|
MIN(desc->data_resid, bp->bio_resid);
|
|
}
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Buffer command: data %p: datacnt %d\n",
|
|
desc->data, desc->data_increment));
|
|
TAILQ_INSERT_TAIL(&softc->work_queue, &atio->ccb_h,
|
|
periph_links.tqe);
|
|
}
|
|
atio = (struct ccb_accept_tio *)TAILQ_FIRST(&softc->work_queue);
|
|
if (atio != NULL) {
|
|
int priority;
|
|
|
|
priority = (atio->ccb_h.flags & CAM_DIS_DISCONNECT) ? 0 : 1;
|
|
splx(s);
|
|
xpt_schedule(periph, priority);
|
|
} else
|
|
splx(s);
|
|
}
|
|
|
|
static void
|
|
targstart(struct cam_periph *periph, union ccb *start_ccb)
|
|
{
|
|
struct targ_softc *softc;
|
|
struct ccb_hdr *ccbh;
|
|
struct ccb_accept_tio *atio;
|
|
struct targ_cmd_desc *desc;
|
|
struct ccb_scsiio *csio;
|
|
targ_ccb_flags flags;
|
|
int s;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
s = splbio();
|
|
ccbh = TAILQ_FIRST(&softc->work_queue);
|
|
if (periph->immediate_priority <= periph->pinfo.priority) {
|
|
start_ccb->ccb_h.ccb_flags = TARG_CCB_WAITING;
|
|
SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h,
|
|
periph_links.sle);
|
|
periph->immediate_priority = CAM_PRIORITY_NONE;
|
|
splx(s);
|
|
wakeup(&periph->ccb_list);
|
|
} else if (ccbh == NULL) {
|
|
splx(s);
|
|
xpt_release_ccb(start_ccb);
|
|
} else {
|
|
TAILQ_REMOVE(&softc->work_queue, ccbh, periph_links.tqe);
|
|
splx(s);
|
|
atio = (struct ccb_accept_tio*)ccbh;
|
|
desc = (struct targ_cmd_desc *)atio->ccb_h.ccb_descr;
|
|
|
|
/* Is this a tagged request? */
|
|
flags = atio->ccb_h.flags &
|
|
(CAM_DIS_DISCONNECT|CAM_TAG_ACTION_VALID|CAM_DIR_MASK);
|
|
|
|
/*
|
|
* If we are done with the transaction, tell the
|
|
* controller to send status and perform a CMD_CMPLT.
|
|
*/
|
|
if (desc->data_resid == desc->data_increment)
|
|
flags |= CAM_SEND_STATUS;
|
|
|
|
csio = &start_ccb->csio;
|
|
cam_fill_ctio(csio,
|
|
/*retries*/2,
|
|
targdone,
|
|
flags,
|
|
(flags & CAM_TAG_ACTION_VALID)?
|
|
MSG_SIMPLE_Q_TAG : 0,
|
|
atio->tag_id,
|
|
atio->init_id,
|
|
desc->status,
|
|
/*data_ptr*/desc->data_increment == 0
|
|
? NULL : desc->data,
|
|
/*dxfer_len*/desc->data_increment,
|
|
/*timeout*/desc->timeout);
|
|
|
|
if ((flags & CAM_SEND_STATUS) != 0
|
|
&& (desc->status == SCSI_STATUS_CHECK_COND
|
|
|| desc->status == SCSI_STATUS_CMD_TERMINATED)) {
|
|
struct initiator_state *istate;
|
|
|
|
istate = &softc->istate[atio->init_id];
|
|
csio->sense_len = istate->sense_data.extra_len
|
|
+ offsetof(struct scsi_sense_data,
|
|
extra_len);
|
|
bcopy(&istate->sense_data, &csio->sense_data,
|
|
csio->sense_len);
|
|
csio->ccb_h.flags |= CAM_SEND_SENSE;
|
|
} else {
|
|
csio->sense_len = 0;
|
|
}
|
|
|
|
start_ccb->ccb_h.ccb_flags = TARG_CCB_NONE;
|
|
start_ccb->ccb_h.ccb_atio = atio;
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Sending a CTIO (flags 0x%x)\n", csio->ccb_h.flags));
|
|
TAILQ_INSERT_TAIL(&softc->pending_queue, &csio->ccb_h,
|
|
periph_links.tqe);
|
|
xpt_action(start_ccb);
|
|
/*
|
|
* If the queue was frozen waiting for the response
|
|
* to this ATIO (for instance disconnection was disallowed),
|
|
* then release it now that our response has been queued.
|
|
*/
|
|
if ((atio->ccb_h.flags & CAM_DEV_QFRZN) != 0) {
|
|
cam_release_devq(periph->path,
|
|
/*relsim_flags*/0,
|
|
/*reduction*/0,
|
|
/*timeout*/0,
|
|
/*getcount_only*/0);
|
|
atio->ccb_h.flags &= ~CAM_DEV_QFRZN;
|
|
}
|
|
s = splbio();
|
|
ccbh = TAILQ_FIRST(&softc->work_queue);
|
|
splx(s);
|
|
}
|
|
if (ccbh != NULL)
|
|
targrunqueue(periph, softc);
|
|
}
|
|
|
|
static void
|
|
targdone(struct cam_periph *periph, union ccb *done_ccb)
|
|
{
|
|
struct targ_softc *softc;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
if (done_ccb->ccb_h.ccb_flags == TARG_CCB_WAITING) {
|
|
/* Caller will release the CCB */
|
|
wakeup(&done_ccb->ccb_h.cbfcnp);
|
|
return;
|
|
}
|
|
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("targdone %x\n", done_ccb->ccb_h.func_code));
|
|
|
|
switch (done_ccb->ccb_h.func_code) {
|
|
case XPT_ACCEPT_TARGET_IO:
|
|
{
|
|
struct ccb_accept_tio *atio;
|
|
struct targ_cmd_desc *descr;
|
|
struct initiator_state *istate;
|
|
u_int8_t *cdb;
|
|
int priority;
|
|
|
|
atio = &done_ccb->atio;
|
|
descr = (struct targ_cmd_desc*)atio->ccb_h.ccb_descr;
|
|
istate = &softc->istate[atio->init_id];
|
|
cdb = atio->cdb_io.cdb_bytes;
|
|
if (softc->state == TARG_STATE_TEARDOWN
|
|
|| atio->ccb_h.status == CAM_REQ_ABORTED) {
|
|
freedescr(descr);
|
|
free(done_ccb, M_DEVBUF);
|
|
return;
|
|
}
|
|
|
|
#ifdef CAMDEBUG
|
|
{
|
|
int i;
|
|
char dcb[128];
|
|
for (dcb[0] = 0, i = 0; i < atio->cdb_len; i++) {
|
|
snprintf(dcb, sizeof dcb,
|
|
"%s %02x", dcb, cdb[i] & 0xff);
|
|
}
|
|
CAM_DEBUG(periph->path,
|
|
CAM_DEBUG_PERIPH, ("cdb:%s\n", dcb));
|
|
}
|
|
#endif
|
|
if (atio->sense_len != 0) {
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("ATIO with sense_len\n"));
|
|
|
|
/*
|
|
* We had an error in the reception of
|
|
* this command. Immediately issue a CA.
|
|
*/
|
|
atio->ccb_h.flags &= ~CAM_DIR_MASK;
|
|
atio->ccb_h.flags |= CAM_DIR_NONE;
|
|
descr->data_resid = 0;
|
|
descr->data_increment = 0;
|
|
descr->timeout = 5 * 1000;
|
|
descr->status = SCSI_STATUS_CHECK_COND;
|
|
copy_sense(softc, istate, (u_int8_t *)&atio->sense_data,
|
|
atio->sense_len);
|
|
set_ca_condition(periph, atio->init_id, CA_CMD_SENSE);
|
|
} else if (istate->pending_ca == 0
|
|
&& istate->pending_ua != 0
|
|
&& cdb[0] != INQUIRY) {
|
|
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("pending_ca %d pending_ua %d\n",
|
|
istate->pending_ca, istate->pending_ua));
|
|
|
|
/* Pending UA, tell initiator */
|
|
/* Direction is always relative to the initator */
|
|
atio->ccb_h.flags &= ~CAM_DIR_MASK;
|
|
atio->ccb_h.flags |= CAM_DIR_NONE;
|
|
descr->data_resid = 0;
|
|
descr->data_increment = 0;
|
|
descr->timeout = 5 * 1000;
|
|
descr->status = SCSI_STATUS_CHECK_COND;
|
|
fill_sense(softc, atio->init_id,
|
|
SSD_CURRENT_ERROR, SSD_KEY_UNIT_ATTENTION,
|
|
0x29,
|
|
istate->pending_ua == UA_POWER_ON ? 1 : 2);
|
|
set_ca_condition(periph, atio->init_id, CA_UNIT_ATTN);
|
|
} else {
|
|
/*
|
|
* Save the current CA and UA status so
|
|
* they can be used by this command.
|
|
*/
|
|
ua_types pending_ua;
|
|
ca_types pending_ca;
|
|
|
|
pending_ua = istate->pending_ua;
|
|
pending_ca = istate->pending_ca;
|
|
|
|
/*
|
|
* As per the SCSI2 spec, any command that occurs
|
|
* after a CA is reported, clears the CA. We must
|
|
* also clear the UA condition, if any, that caused
|
|
* the CA to occur assuming the UA is not for a
|
|
* persistant condition.
|
|
*/
|
|
istate->pending_ca = CA_NONE;
|
|
if (pending_ca == CA_UNIT_ATTN)
|
|
istate->pending_ua = UA_NONE;
|
|
|
|
/*
|
|
* Determine the type of incoming command and
|
|
* setup our buffer for a response.
|
|
*/
|
|
switch (cdb[0]) {
|
|
case INQUIRY:
|
|
{
|
|
struct scsi_inquiry *inq;
|
|
struct scsi_sense_data *sense;
|
|
|
|
inq = (struct scsi_inquiry *)cdb;
|
|
sense = &istate->sense_data;
|
|
descr->status = SCSI_STATUS_OK;
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Saw an inquiry!\n"));
|
|
/*
|
|
* Validate the command. We don't
|
|
* support any VPD pages, so complain
|
|
* if EVPD is set.
|
|
*/
|
|
if ((inq->byte2 & SI_EVPD) != 0
|
|
|| inq->page_code != 0) {
|
|
atio->ccb_h.flags &= ~CAM_DIR_MASK;
|
|
atio->ccb_h.flags |= CAM_DIR_NONE;
|
|
descr->data_resid = 0;
|
|
descr->data_increment = 0;
|
|
descr->timeout = 5 * 1000;
|
|
descr->status = SCSI_STATUS_CHECK_COND;
|
|
fill_sense(softc, atio->init_id,
|
|
SSD_CURRENT_ERROR,
|
|
SSD_KEY_ILLEGAL_REQUEST,
|
|
/*asc*/0x24, /*ascq*/0x00);
|
|
sense->extra_len =
|
|
offsetof(struct scsi_sense_data,
|
|
extra_bytes)
|
|
- offsetof(struct scsi_sense_data,
|
|
extra_len);
|
|
set_ca_condition(periph, atio->init_id,
|
|
CA_CMD_SENSE);
|
|
}
|
|
|
|
if ((inq->byte2 & SI_EVPD) != 0) {
|
|
sense->sense_key_spec[0] =
|
|
SSD_SCS_VALID|SSD_FIELDPTR_CMD
|
|
|SSD_BITPTR_VALID| /*bit value*/1;
|
|
sense->sense_key_spec[1] = 0;
|
|
sense->sense_key_spec[2] =
|
|
offsetof(struct scsi_inquiry,
|
|
byte2);
|
|
} else if (inq->page_code != 0) {
|
|
sense->sense_key_spec[0] =
|
|
SSD_SCS_VALID|SSD_FIELDPTR_CMD;
|
|
sense->sense_key_spec[1] = 0;
|
|
sense->sense_key_spec[2] =
|
|
offsetof(struct scsi_inquiry,
|
|
page_code);
|
|
}
|
|
if (descr->status == SCSI_STATUS_CHECK_COND)
|
|
break;
|
|
|
|
/*
|
|
* Direction is always relative
|
|
* to the initator.
|
|
*/
|
|
atio->ccb_h.flags &= ~CAM_DIR_MASK;
|
|
atio->ccb_h.flags |= CAM_DIR_IN;
|
|
descr->data = softc->inq_data;
|
|
descr->data_resid =
|
|
MIN(softc->inq_data_len,
|
|
SCSI_CDB6_LEN(inq->length));
|
|
descr->data_increment = descr->data_resid;
|
|
descr->timeout = 5 * 1000;
|
|
break;
|
|
}
|
|
case TEST_UNIT_READY:
|
|
atio->ccb_h.flags &= ~CAM_DIR_MASK;
|
|
atio->ccb_h.flags |= CAM_DIR_NONE;
|
|
descr->data_resid = 0;
|
|
descr->data_increment = 0;
|
|
descr->timeout = 5 * 1000;
|
|
descr->status = SCSI_STATUS_OK;
|
|
break;
|
|
case REQUEST_SENSE:
|
|
{
|
|
struct scsi_request_sense *rsense;
|
|
struct scsi_sense_data *sense;
|
|
|
|
rsense = (struct scsi_request_sense *)cdb;
|
|
sense = &istate->sense_data;
|
|
if (pending_ca == 0) {
|
|
fill_sense(softc, atio->init_id,
|
|
SSD_CURRENT_ERROR,
|
|
SSD_KEY_NO_SENSE, 0x00,
|
|
0x00);
|
|
CAM_DEBUG(periph->path,
|
|
CAM_DEBUG_PERIPH,
|
|
("No pending CA!\n"));
|
|
}
|
|
/*
|
|
* Direction is always relative
|
|
* to the initator.
|
|
*/
|
|
atio->ccb_h.flags &= ~CAM_DIR_MASK;
|
|
atio->ccb_h.flags |= CAM_DIR_IN;
|
|
descr->data = sense;
|
|
descr->data_resid =
|
|
offsetof(struct scsi_sense_data,
|
|
extra_len)
|
|
+ sense->extra_len;
|
|
descr->data_resid =
|
|
MIN(descr->data_resid,
|
|
SCSI_CDB6_LEN(rsense->length));
|
|
descr->data_increment = descr->data_resid;
|
|
descr->timeout = 5 * 1000;
|
|
descr->status = SCSI_STATUS_OK;
|
|
break;
|
|
}
|
|
case RECEIVE:
|
|
case SEND:
|
|
{
|
|
struct scsi_send_receive *sr;
|
|
|
|
sr = (struct scsi_send_receive *)cdb;
|
|
|
|
/*
|
|
* Direction is always relative
|
|
* to the initator.
|
|
*/
|
|
atio->ccb_h.flags &= ~CAM_DIR_MASK;
|
|
descr->data_resid = scsi_3btoul(sr->xfer_len);
|
|
descr->timeout = 5 * 1000;
|
|
descr->status = SCSI_STATUS_OK;
|
|
if (cdb[0] == SEND) {
|
|
atio->ccb_h.flags |= CAM_DIR_OUT;
|
|
CAM_DEBUG(periph->path,
|
|
CAM_DEBUG_PERIPH,
|
|
("Saw a SEND!\n"));
|
|
atio->ccb_h.flags |= CAM_DIR_OUT;
|
|
TAILQ_INSERT_TAIL(&softc->snd_ccb_queue,
|
|
&atio->ccb_h,
|
|
periph_links.tqe);
|
|
selwakeup(&softc->snd_select);
|
|
} else {
|
|
atio->ccb_h.flags |= CAM_DIR_IN;
|
|
CAM_DEBUG(periph->path,
|
|
CAM_DEBUG_PERIPH,
|
|
("Saw a RECEIVE!\n"));
|
|
TAILQ_INSERT_TAIL(&softc->rcv_ccb_queue,
|
|
&atio->ccb_h,
|
|
periph_links.tqe);
|
|
selwakeup(&softc->rcv_select);
|
|
}
|
|
/*
|
|
* Attempt to satisfy this request with
|
|
* a user buffer.
|
|
*/
|
|
targrunqueue(periph, softc);
|
|
return;
|
|
}
|
|
default:
|
|
/*
|
|
* Queue for consumption by our userland
|
|
* counterpart and transition to the exception
|
|
* state.
|
|
*/
|
|
TAILQ_INSERT_TAIL(&softc->unknown_atio_queue,
|
|
&atio->ccb_h,
|
|
periph_links.tqe);
|
|
softc->exceptions |= TARG_EXCEPT_UNKNOWN_ATIO;
|
|
targfireexception(periph, softc);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Queue us up to receive a Continue Target I/O ccb. */
|
|
if ((atio->ccb_h.flags & CAM_DIS_DISCONNECT) != 0) {
|
|
TAILQ_INSERT_HEAD(&softc->work_queue, &atio->ccb_h,
|
|
periph_links.tqe);
|
|
priority = 0;
|
|
} else {
|
|
TAILQ_INSERT_TAIL(&softc->work_queue, &atio->ccb_h,
|
|
periph_links.tqe);
|
|
priority = 1;
|
|
}
|
|
xpt_schedule(periph, priority);
|
|
break;
|
|
}
|
|
case XPT_CONT_TARGET_IO:
|
|
{
|
|
struct ccb_scsiio *csio;
|
|
struct ccb_accept_tio *atio;
|
|
struct targ_cmd_desc *desc;
|
|
struct bio *bp;
|
|
int error;
|
|
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Received completed CTIO\n"));
|
|
csio = &done_ccb->csio;
|
|
atio = (struct ccb_accept_tio*)done_ccb->ccb_h.ccb_atio;
|
|
desc = (struct targ_cmd_desc *)atio->ccb_h.ccb_descr;
|
|
|
|
TAILQ_REMOVE(&softc->pending_queue, &done_ccb->ccb_h,
|
|
periph_links.tqe);
|
|
|
|
if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
|
|
printf("CCB with error %x\n", done_ccb->ccb_h.status);
|
|
error = targerror(done_ccb, 0, 0);
|
|
if (error == ERESTART)
|
|
break;
|
|
/*
|
|
* Right now we don't need to do anything
|
|
* prior to unfreezing the queue...
|
|
*/
|
|
if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
|
|
printf("Releasing Queue\n");
|
|
cam_release_devq(done_ccb->ccb_h.path,
|
|
/*relsim_flags*/0,
|
|
/*reduction*/0,
|
|
/*timeout*/0,
|
|
/*getcount_only*/0);
|
|
}
|
|
} else
|
|
error = 0;
|
|
|
|
/*
|
|
* If we shipped back sense data when completing
|
|
* this command, clear the pending CA for it.
|
|
*/
|
|
if (done_ccb->ccb_h.status & CAM_SENT_SENSE) {
|
|
struct initiator_state *istate;
|
|
|
|
istate = &softc->istate[csio->init_id];
|
|
if (istate->pending_ca == CA_UNIT_ATTN)
|
|
istate->pending_ua = UA_NONE;
|
|
istate->pending_ca = CA_NONE;
|
|
softc->istate[csio->init_id].pending_ca = CA_NONE;
|
|
done_ccb->ccb_h.status &= ~CAM_SENT_SENSE;
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Sent Sense\n"));
|
|
}
|
|
done_ccb->ccb_h.flags &= ~CAM_SEND_SENSE;
|
|
|
|
desc->data_increment -= csio->resid;
|
|
desc->data_resid -= desc->data_increment;
|
|
if ((bp = desc->bp) != NULL) {
|
|
|
|
bp->bio_resid -= desc->data_increment;
|
|
bp->bio_error = error;
|
|
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Buffer I/O Completed - Resid %ld:%d\n",
|
|
bp->bio_resid, desc->data_resid));
|
|
/*
|
|
* Send the buffer back to the client if
|
|
* either the command has completed or all
|
|
* buffer space has been consumed.
|
|
*/
|
|
if (desc->data_resid == 0
|
|
|| bp->bio_resid == 0
|
|
|| error != 0) {
|
|
if (bp->bio_resid != 0)
|
|
/* Short transfer */
|
|
bp->bio_flags |= BIO_ERROR;
|
|
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Completing a buffer\n"));
|
|
biodone(bp);
|
|
desc->bp = NULL;
|
|
}
|
|
}
|
|
|
|
xpt_release_ccb(done_ccb);
|
|
if (softc->state != TARG_STATE_TEARDOWN) {
|
|
|
|
if (desc->data_resid == 0) {
|
|
/*
|
|
* Send the original accept TIO back to the
|
|
* controller to handle more work.
|
|
*/
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Returning ATIO to target SIM\n"));
|
|
atio->ccb_h.ccb_flags = TARG_CCB_NONE;
|
|
xpt_action((union ccb *)atio);
|
|
break;
|
|
}
|
|
|
|
/* Queue us up for another buffer */
|
|
if (atio->cdb_io.cdb_bytes[0] == SEND) {
|
|
if (desc->bp != NULL)
|
|
TAILQ_INSERT_HEAD(
|
|
&softc->snd_bio_queue.queue,
|
|
bp, bio_queue);
|
|
TAILQ_INSERT_HEAD(&softc->snd_ccb_queue,
|
|
&atio->ccb_h,
|
|
periph_links.tqe);
|
|
} else {
|
|
if (desc->bp != NULL)
|
|
TAILQ_INSERT_HEAD(
|
|
&softc->rcv_bio_queue.queue,
|
|
bp, bio_queue);
|
|
TAILQ_INSERT_HEAD(&softc->rcv_ccb_queue,
|
|
&atio->ccb_h,
|
|
periph_links.tqe);
|
|
}
|
|
desc->bp = NULL;
|
|
targrunqueue(periph, softc);
|
|
} else {
|
|
if (desc->bp != NULL) {
|
|
bp->bio_flags |= BIO_ERROR;
|
|
bp->bio_error = ENXIO;
|
|
biodone(bp);
|
|
}
|
|
freedescr(desc);
|
|
free(atio, M_DEVBUF);
|
|
}
|
|
break;
|
|
}
|
|
case XPT_IMMED_NOTIFY:
|
|
{
|
|
int frozen;
|
|
|
|
frozen = (done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0;
|
|
if (softc->state == TARG_STATE_TEARDOWN) {
|
|
SLIST_REMOVE(&softc->immed_notify_slist,
|
|
&done_ccb->ccb_h, ccb_hdr,
|
|
periph_links.sle);
|
|
free(done_ccb, M_DEVBUF);
|
|
} else if (done_ccb->ccb_h.status == CAM_REQ_ABORTED) {
|
|
free(done_ccb, M_DEVBUF);
|
|
} else {
|
|
printf("Saw event %x:%x\n", done_ccb->ccb_h.status,
|
|
done_ccb->cin.message_args[0]);
|
|
/* Process error condition. */
|
|
targinoterror(periph, softc, &done_ccb->cin);
|
|
|
|
/* Requeue for another immediate event */
|
|
xpt_action(done_ccb);
|
|
}
|
|
if (frozen != 0)
|
|
cam_release_devq(periph->path,
|
|
/*relsim_flags*/0,
|
|
/*opening reduction*/0,
|
|
/*timeout*/0,
|
|
/*getcount_only*/0);
|
|
break;
|
|
}
|
|
case XPT_DEBUG:
|
|
wakeup(&done_ccb->ccb_h.cbfcnp);
|
|
break;
|
|
default:
|
|
panic("targdone: Impossible xpt opcode %x encountered.",
|
|
done_ccb->ccb_h.func_code);
|
|
/* NOTREACHED */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Transition to the exception state and notify our symbiotic
|
|
* userland process of the change.
|
|
*/
|
|
static void
|
|
targfireexception(struct cam_periph *periph, struct targ_softc *softc)
|
|
{
|
|
/*
|
|
* return all pending buffers with short read/write status so our
|
|
* process unblocks, and do a selwakeup on any process queued
|
|
* waiting for reads or writes. When the selwakeup is performed,
|
|
* the waking process will wakeup, call our poll routine again,
|
|
* and pick up the exception.
|
|
*/
|
|
struct bio *bp;
|
|
|
|
if (softc->state != TARG_STATE_NORMAL)
|
|
/* Already either tearing down or in exception state */
|
|
return;
|
|
|
|
softc->state = TARG_STATE_EXCEPTION;
|
|
|
|
while ((bp = bioq_first(&softc->snd_bio_queue)) != NULL) {
|
|
bioq_remove(&softc->snd_bio_queue, bp);
|
|
bp->bio_flags |= BIO_ERROR;
|
|
biodone(bp);
|
|
}
|
|
|
|
while ((bp = bioq_first(&softc->rcv_bio_queue)) != NULL) {
|
|
bioq_remove(&softc->snd_bio_queue, bp);
|
|
bp->bio_flags |= BIO_ERROR;
|
|
biodone(bp);
|
|
}
|
|
|
|
selwakeup(&softc->snd_select);
|
|
selwakeup(&softc->rcv_select);
|
|
}
|
|
|
|
static void
|
|
targinoterror(struct cam_periph *periph, struct targ_softc *softc,
|
|
struct ccb_immed_notify *inot)
|
|
{
|
|
cam_status status;
|
|
int sense;
|
|
|
|
status = inot->ccb_h.status;
|
|
sense = (status & CAM_AUTOSNS_VALID) != 0;
|
|
status &= CAM_STATUS_MASK;
|
|
switch (status) {
|
|
case CAM_SCSI_BUS_RESET:
|
|
set_unit_attention_cond(periph, /*init_id*/CAM_TARGET_WILDCARD,
|
|
UA_BUS_RESET);
|
|
abort_pending_transactions(periph,
|
|
/*init_id*/CAM_TARGET_WILDCARD,
|
|
TARG_TAG_WILDCARD, EINTR,
|
|
/*to_held_queue*/FALSE);
|
|
softc->exceptions |= TARG_EXCEPT_BUS_RESET_SEEN;
|
|
targfireexception(periph, softc);
|
|
break;
|
|
case CAM_BDR_SENT:
|
|
set_unit_attention_cond(periph, /*init_id*/CAM_TARGET_WILDCARD,
|
|
UA_BDR);
|
|
abort_pending_transactions(periph, CAM_TARGET_WILDCARD,
|
|
TARG_TAG_WILDCARD, EINTR,
|
|
/*to_held_queue*/FALSE);
|
|
softc->exceptions |= TARG_EXCEPT_BDR_RECEIVED;
|
|
targfireexception(periph, softc);
|
|
break;
|
|
case CAM_MESSAGE_RECV:
|
|
switch (inot->message_args[0]) {
|
|
case MSG_INITIATOR_DET_ERR:
|
|
break;
|
|
case MSG_ABORT:
|
|
break;
|
|
case MSG_BUS_DEV_RESET:
|
|
break;
|
|
case MSG_ABORT_TAG:
|
|
break;
|
|
case MSG_CLEAR_QUEUE:
|
|
break;
|
|
case MSG_TERM_IO_PROC:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int
|
|
targerror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
|
|
{
|
|
struct cam_periph *periph;
|
|
struct targ_softc *softc;
|
|
struct ccb_scsiio *csio;
|
|
struct initiator_state *istate;
|
|
cam_status status;
|
|
int frozen;
|
|
int sense;
|
|
int error;
|
|
int on_held_queue;
|
|
|
|
periph = xpt_path_periph(ccb->ccb_h.path);
|
|
softc = (struct targ_softc *)periph->softc;
|
|
status = ccb->ccb_h.status;
|
|
sense = (status & CAM_AUTOSNS_VALID) != 0;
|
|
frozen = (status & CAM_DEV_QFRZN) != 0;
|
|
status &= CAM_STATUS_MASK;
|
|
on_held_queue = FALSE;
|
|
csio = &ccb->csio;
|
|
istate = &softc->istate[csio->init_id];
|
|
switch (status) {
|
|
case CAM_REQ_ABORTED:
|
|
if ((ccb->ccb_h.ccb_flags & TARG_CCB_ABORT_TO_HELDQ) != 0) {
|
|
|
|
/*
|
|
* Place this CCB into the initiators
|
|
* 'held' queue until the pending CA is cleared.
|
|
* If there is no CA pending, reissue immediately.
|
|
*/
|
|
if (istate->pending_ca == 0) {
|
|
ccb->ccb_h.ccb_flags = TARG_CCB_NONE;
|
|
xpt_action(ccb);
|
|
} else {
|
|
ccb->ccb_h.ccb_flags = TARG_CCB_HELDQ;
|
|
TAILQ_INSERT_TAIL(&softc->pending_queue,
|
|
&ccb->ccb_h,
|
|
periph_links.tqe);
|
|
}
|
|
/* The command will be retried at a later time. */
|
|
on_held_queue = TRUE;
|
|
error = ERESTART;
|
|
break;
|
|
}
|
|
/* FALLTHROUGH */
|
|
case CAM_SCSI_BUS_RESET:
|
|
case CAM_BDR_SENT:
|
|
case CAM_REQ_TERMIO:
|
|
case CAM_CMD_TIMEOUT:
|
|
/* Assume we did not send any data */
|
|
csio->resid = csio->dxfer_len;
|
|
error = EIO;
|
|
break;
|
|
case CAM_SEL_TIMEOUT:
|
|
if (ccb->ccb_h.retry_count > 0) {
|
|
ccb->ccb_h.retry_count--;
|
|
error = ERESTART;
|
|
} else {
|
|
/* "Select or reselect failure" */
|
|
csio->resid = csio->dxfer_len;
|
|
fill_sense(softc, csio->init_id, SSD_CURRENT_ERROR,
|
|
SSD_KEY_HARDWARE_ERROR, 0x45, 0x00);
|
|
set_ca_condition(periph, csio->init_id, CA_CMD_SENSE);
|
|
error = EIO;
|
|
}
|
|
break;
|
|
case CAM_UNCOR_PARITY:
|
|
/* "SCSI parity error" */
|
|
fill_sense(softc, csio->init_id, SSD_CURRENT_ERROR,
|
|
SSD_KEY_HARDWARE_ERROR, 0x47, 0x00);
|
|
set_ca_condition(periph, csio->init_id, CA_CMD_SENSE);
|
|
csio->resid = csio->dxfer_len;
|
|
error = EIO;
|
|
break;
|
|
case CAM_NO_HBA:
|
|
csio->resid = csio->dxfer_len;
|
|
error = ENXIO;
|
|
break;
|
|
case CAM_SEQUENCE_FAIL:
|
|
if (sense != 0) {
|
|
copy_sense(softc, istate, (u_int8_t *)&csio->sense_data,
|
|
csio->sense_len);
|
|
set_ca_condition(periph, csio->init_id, CA_CMD_SENSE);
|
|
}
|
|
csio->resid = csio->dxfer_len;
|
|
error = EIO;
|
|
break;
|
|
case CAM_IDE:
|
|
/* "Initiator detected error message received" */
|
|
fill_sense(softc, csio->init_id, SSD_CURRENT_ERROR,
|
|
SSD_KEY_HARDWARE_ERROR, 0x48, 0x00);
|
|
set_ca_condition(periph, csio->init_id, CA_CMD_SENSE);
|
|
csio->resid = csio->dxfer_len;
|
|
error = EIO;
|
|
break;
|
|
case CAM_REQUEUE_REQ:
|
|
printf("Requeue Request!\n");
|
|
error = ERESTART;
|
|
break;
|
|
default:
|
|
csio->resid = csio->dxfer_len;
|
|
error = EIO;
|
|
panic("targerror: Unexpected status %x encounterd", status);
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
if (error == ERESTART || error == 0) {
|
|
/* Clear the QFRZN flag as we will release the queue */
|
|
if (frozen != 0)
|
|
ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
|
|
|
|
if (error == ERESTART && !on_held_queue)
|
|
xpt_action(ccb);
|
|
|
|
if (frozen != 0)
|
|
cam_release_devq(ccb->ccb_h.path,
|
|
/*relsim_flags*/0,
|
|
/*opening reduction*/0,
|
|
/*timeout*/0,
|
|
/*getcount_only*/0);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
static struct targ_cmd_desc*
|
|
allocdescr()
|
|
{
|
|
struct targ_cmd_desc* descr;
|
|
|
|
/* Allocate the targ_descr structure */
|
|
descr = (struct targ_cmd_desc *)malloc(sizeof(*descr),
|
|
M_DEVBUF, M_NOWAIT);
|
|
if (descr == NULL)
|
|
return (NULL);
|
|
|
|
bzero(descr, sizeof(*descr));
|
|
|
|
/* Allocate buffer backing store */
|
|
descr->backing_store = malloc(MAX_BUF_SIZE, M_DEVBUF, M_NOWAIT);
|
|
if (descr->backing_store == NULL) {
|
|
free(descr, M_DEVBUF);
|
|
return (NULL);
|
|
}
|
|
descr->max_size = MAX_BUF_SIZE;
|
|
return (descr);
|
|
}
|
|
|
|
static void
|
|
freedescr(struct targ_cmd_desc *descr)
|
|
{
|
|
free(descr->backing_store, M_DEVBUF);
|
|
free(descr, M_DEVBUF);
|
|
}
|
|
|
|
static void
|
|
fill_sense(struct targ_softc *softc, u_int initiator_id, u_int error_code,
|
|
u_int sense_key, u_int asc, u_int ascq)
|
|
{
|
|
struct initiator_state *istate;
|
|
struct scsi_sense_data *sense;
|
|
|
|
istate = &softc->istate[initiator_id];
|
|
sense = &istate->sense_data;
|
|
bzero(sense, sizeof(*sense));
|
|
sense->error_code = error_code;
|
|
sense->flags = sense_key;
|
|
sense->add_sense_code = asc;
|
|
sense->add_sense_code_qual = ascq;
|
|
|
|
sense->extra_len = offsetof(struct scsi_sense_data, fru)
|
|
- offsetof(struct scsi_sense_data, extra_len);
|
|
}
|
|
|
|
static void
|
|
copy_sense(struct targ_softc *softc, struct initiator_state *istate,
|
|
u_int8_t *sense_buffer, size_t sense_len)
|
|
{
|
|
struct scsi_sense_data *sense;
|
|
size_t copylen;
|
|
|
|
sense = &istate->sense_data;
|
|
copylen = sizeof(*sense);
|
|
if (copylen > sense_len)
|
|
copylen = sense_len;
|
|
bcopy(sense_buffer, sense, copylen);
|
|
}
|
|
|
|
static void
|
|
set_unit_attention_cond(struct cam_periph *periph,
|
|
u_int initiator_id, ua_types ua)
|
|
{
|
|
int start;
|
|
int end;
|
|
struct targ_softc *softc;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
if (initiator_id == CAM_TARGET_WILDCARD) {
|
|
start = 0;
|
|
end = MAX_INITIATORS - 1;
|
|
} else
|
|
start = end = initiator_id;
|
|
|
|
while (start <= end) {
|
|
softc->istate[start].pending_ua = ua;
|
|
start++;
|
|
}
|
|
}
|
|
|
|
static void
|
|
set_ca_condition(struct cam_periph *periph, u_int initiator_id, ca_types ca)
|
|
{
|
|
struct targ_softc *softc;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
softc->istate[initiator_id].pending_ca = ca;
|
|
abort_pending_transactions(periph, initiator_id, TARG_TAG_WILDCARD,
|
|
/*errno*/0, /*to_held_queue*/TRUE);
|
|
}
|
|
|
|
static void
|
|
abort_pending_transactions(struct cam_periph *periph, u_int initiator_id,
|
|
u_int tag_id, int errno, int to_held_queue)
|
|
{
|
|
struct ccb_abort cab;
|
|
struct ccb_queue *atio_queues[3];
|
|
struct targ_softc *softc;
|
|
struct ccb_hdr *ccbh;
|
|
u_int i;
|
|
|
|
softc = (struct targ_softc *)periph->softc;
|
|
|
|
atio_queues[0] = &softc->work_queue;
|
|
atio_queues[1] = &softc->snd_ccb_queue;
|
|
atio_queues[2] = &softc->rcv_ccb_queue;
|
|
|
|
/* First address the ATIOs awaiting resources */
|
|
for (i = 0; i < (sizeof(atio_queues) / sizeof(*atio_queues)); i++) {
|
|
struct ccb_queue *atio_queue;
|
|
|
|
if (to_held_queue) {
|
|
/*
|
|
* The device queue is frozen anyway, so there
|
|
* is nothing for us to do.
|
|
*/
|
|
continue;
|
|
}
|
|
atio_queue = atio_queues[i];
|
|
ccbh = TAILQ_FIRST(atio_queue);
|
|
while (ccbh != NULL) {
|
|
struct ccb_accept_tio *atio;
|
|
struct targ_cmd_desc *desc;
|
|
|
|
atio = (struct ccb_accept_tio *)ccbh;
|
|
desc = (struct targ_cmd_desc *)atio->ccb_h.ccb_descr;
|
|
ccbh = TAILQ_NEXT(ccbh, periph_links.tqe);
|
|
|
|
/* Only abort the CCBs that match */
|
|
if ((atio->init_id != initiator_id
|
|
&& initiator_id != CAM_TARGET_WILDCARD)
|
|
|| (tag_id != TARG_TAG_WILDCARD
|
|
&& ((atio->ccb_h.flags & CAM_TAG_ACTION_VALID) == 0
|
|
|| atio->tag_id != tag_id)))
|
|
continue;
|
|
|
|
TAILQ_REMOVE(atio_queue, &atio->ccb_h,
|
|
periph_links.tqe);
|
|
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Aborting ATIO\n"));
|
|
if (desc->bp != NULL) {
|
|
desc->bp->bio_flags |= BIO_ERROR;
|
|
if (softc->state != TARG_STATE_TEARDOWN)
|
|
desc->bp->bio_error = errno;
|
|
else
|
|
desc->bp->bio_error = ENXIO;
|
|
biodone(desc->bp);
|
|
desc->bp = NULL;
|
|
}
|
|
if (softc->state == TARG_STATE_TEARDOWN) {
|
|
freedescr(desc);
|
|
free(atio, M_DEVBUF);
|
|
} else {
|
|
/* Return the ATIO back to the controller */
|
|
atio->ccb_h.ccb_flags = TARG_CCB_NONE;
|
|
xpt_action((union ccb *)atio);
|
|
}
|
|
}
|
|
}
|
|
|
|
ccbh = TAILQ_FIRST(&softc->pending_queue);
|
|
while (ccbh != NULL) {
|
|
struct ccb_scsiio *csio;
|
|
|
|
csio = (struct ccb_scsiio *)ccbh;
|
|
ccbh = TAILQ_NEXT(ccbh, periph_links.tqe);
|
|
|
|
/* Only abort the CCBs that match */
|
|
if ((csio->init_id != initiator_id
|
|
&& initiator_id != CAM_TARGET_WILDCARD)
|
|
|| (tag_id != TARG_TAG_WILDCARD
|
|
&& ((csio->ccb_h.flags & CAM_TAG_ACTION_VALID) == 0
|
|
|| csio->tag_id != tag_id)))
|
|
continue;
|
|
|
|
CAM_DEBUG(periph->path, CAM_DEBUG_PERIPH,
|
|
("Aborting CTIO\n"));
|
|
|
|
TAILQ_REMOVE(&softc->pending_queue, &csio->ccb_h,
|
|
periph_links.tqe);
|
|
|
|
if (to_held_queue != 0)
|
|
csio->ccb_h.ccb_flags |= TARG_CCB_ABORT_TO_HELDQ;
|
|
xpt_setup_ccb(&cab.ccb_h, csio->ccb_h.path, /*priority*/1);
|
|
cab.abort_ccb = (union ccb *)csio;
|
|
xpt_action((union ccb *)&cab);
|
|
if (cab.ccb_h.status != CAM_REQ_CMP) {
|
|
xpt_print_path(cab.ccb_h.path);
|
|
printf("Unable to abort CCB. Status %x\n",
|
|
cab.ccb_h.status);
|
|
}
|
|
}
|
|
}
|