1998-09-15 06:33:23 +00:00
|
|
|
/*
|
|
|
|
* Implementation of the Common Access Method Transport (XPT) layer.
|
|
|
|
*
|
|
|
|
* Copyright (c) 1997, 1998 Justin T. Gibbs.
|
|
|
|
* Copyright (c) 1997, 1998 Kenneth D. Merry.
|
|
|
|
* 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.
|
|
|
|
*
|
1998-12-22 20:05:23 +00:00
|
|
|
* $Id: cam_xpt.c,v 1.30 1998/12/15 08:13:10 gibbs Exp $
|
1998-09-15 06:33:23 +00:00
|
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/device.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/fcntl.h>
|
|
|
|
#include <sys/md5.h>
|
|
|
|
#include <sys/devicestat.h>
|
|
|
|
|
|
|
|
#ifdef PC98
|
|
|
|
#include <pc98/pc98/pc98_machdep.h> /* geometry translation */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <machine/clock.h>
|
|
|
|
#include <machine/ipl.h>
|
|
|
|
|
|
|
|
#include <cam/cam.h>
|
|
|
|
#include <cam/cam_conf.h>
|
|
|
|
#include <cam/cam_ccb.h>
|
|
|
|
#include <cam/cam_periph.h>
|
|
|
|
#include <cam/cam_sim.h>
|
|
|
|
#include <cam/cam_xpt.h>
|
|
|
|
#include <cam/cam_xpt_sim.h>
|
|
|
|
#include <cam/cam_xpt_periph.h>
|
|
|
|
#include <cam/cam_debug.h>
|
|
|
|
|
|
|
|
#include <cam/scsi/scsi_all.h>
|
|
|
|
#include <cam/scsi/scsi_message.h>
|
|
|
|
#include <cam/scsi/scsi_pass.h>
|
|
|
|
#include "opt_cam.h"
|
|
|
|
#include "opt_scsi.h"
|
|
|
|
|
|
|
|
extern void (*ihandlers[32]) __P((void));
|
|
|
|
|
|
|
|
/* Datastructures internal to the xpt layer */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Definition of an async handler callback block. These are used to add
|
|
|
|
* SIMs and peripherals to the async callback lists.
|
|
|
|
*/
|
|
|
|
struct async_node {
|
|
|
|
SLIST_ENTRY(async_node) links;
|
|
|
|
u_int32_t event_enable; /* Async Event enables */
|
|
|
|
void (*callback)(void *arg, u_int32_t code,
|
|
|
|
struct cam_path *path, void *args);
|
|
|
|
void *callback_arg;
|
|
|
|
};
|
|
|
|
|
|
|
|
SLIST_HEAD(async_list, async_node);
|
|
|
|
SLIST_HEAD(periph_list, cam_periph);
|
1998-12-22 20:05:23 +00:00
|
|
|
static STAILQ_HEAD(highpowerlist, ccb_hdr) highpowerq;
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the maximum number of high powered commands (e.g. start unit)
|
|
|
|
* that can be outstanding at a particular time.
|
|
|
|
*/
|
|
|
|
#ifndef CAM_MAX_HIGHPOWER
|
|
|
|
#define CAM_MAX_HIGHPOWER 4
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the number of seconds we wait for devices to settle after a SCSI
|
|
|
|
* bus reset.
|
|
|
|
*/
|
|
|
|
#ifndef SCSI_DELAY
|
|
|
|
#define SCSI_DELAY 2000
|
|
|
|
#endif
|
1998-09-17 23:58:53 +00:00
|
|
|
/*
|
|
|
|
* If someone sets this to 0, we assume that they want the minimum
|
|
|
|
* allowable bus settle delay. All devices need _some_ sort of bus settle
|
|
|
|
* delay, so we'll set it to a minimum value of 100ms.
|
|
|
|
*/
|
|
|
|
#if (SCSI_DELAY == 0)
|
|
|
|
#undef SCSI_DELAY
|
|
|
|
#define SCSI_DELAY 100
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure the user isn't using seconds instead of milliseconds.
|
|
|
|
*/
|
1998-09-15 06:33:23 +00:00
|
|
|
#if (SCSI_DELAY < 100)
|
|
|
|
#error "SCSI_DELAY is in milliseconds, not seconds! Please use a larger value"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* number of high powered commands that can go through right now */
|
|
|
|
static int num_highpower = CAM_MAX_HIGHPOWER;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structure for queueing a device in a run queue.
|
|
|
|
* There is one run queue for allocating new ccbs,
|
|
|
|
* and another for sending ccbs to the controller.
|
|
|
|
*/
|
|
|
|
struct cam_ed_qinfo {
|
|
|
|
cam_pinfo pinfo;
|
|
|
|
struct cam_ed *device;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The CAM EDT (Existing Device Table) contains the device information for
|
|
|
|
* all devices for all busses in the system. The table contains a
|
|
|
|
* cam_ed structure for each device on the bus.
|
|
|
|
*/
|
|
|
|
struct cam_ed {
|
|
|
|
TAILQ_ENTRY(cam_ed) links;
|
|
|
|
struct cam_ed_qinfo alloc_ccb_entry;
|
|
|
|
struct cam_ed_qinfo send_ccb_entry;
|
|
|
|
struct cam_et *target;
|
|
|
|
lun_id_t lun_id;
|
|
|
|
struct camq drvq; /*
|
|
|
|
* Queue of type drivers wanting to do
|
|
|
|
* work on this device.
|
|
|
|
*/
|
|
|
|
struct cam_ccbq ccbq; /* Queue of pending ccbs */
|
|
|
|
struct async_list asyncs; /* Async callback info for this B/T/L */
|
|
|
|
struct periph_list periphs; /* All attached devices */
|
|
|
|
u_int generation; /* Generation number */
|
|
|
|
struct cam_periph *owner; /* Peripheral driver's ownership tag */
|
|
|
|
struct xpt_quirk_entry *quirk; /* Oddities about this device */
|
|
|
|
/* Storage for the inquiry data */
|
|
|
|
struct scsi_inquiry_data inq_data;
|
|
|
|
u_int8_t inq_flags; /*
|
|
|
|
* Current settings for inquiry flags.
|
|
|
|
* This allows us to override settings
|
|
|
|
* like disconnection and tagged
|
|
|
|
* queuing for a device.
|
|
|
|
*/
|
|
|
|
u_int8_t queue_flags; /* Queue flags from the control page */
|
|
|
|
u_int8_t *serial_num;
|
|
|
|
u_int8_t serial_num_len;
|
|
|
|
u_int32_t qfrozen_cnt;
|
|
|
|
u_int32_t flags;
|
|
|
|
#define CAM_DEV_UNCONFIGURED 0x01
|
|
|
|
#define CAM_DEV_REL_TIMEOUT_PENDING 0x02
|
|
|
|
#define CAM_DEV_REL_ON_COMPLETE 0x04
|
|
|
|
#define CAM_DEV_REL_ON_QUEUE_EMPTY 0x08
|
|
|
|
#define CAM_DEV_RESIZE_QUEUE_NEEDED 0x10
|
1998-09-23 03:03:19 +00:00
|
|
|
#define CAM_DEV_TAG_AFTER_COUNT 0x20
|
|
|
|
u_int32_t tag_delay_count;
|
|
|
|
#define CAM_TAG_DELAY_COUNT 5
|
1998-09-15 06:33:23 +00:00
|
|
|
u_int32_t refcount;
|
|
|
|
struct callout_handle c_handle;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Each target is represented by an ET (Existing Target). These
|
|
|
|
* entries are created when a target is successfully probed with an
|
|
|
|
* identify, and removed when a device fails to respond after a number
|
|
|
|
* of retries, or a bus rescan finds the device missing.
|
|
|
|
*/
|
|
|
|
struct cam_et {
|
|
|
|
TAILQ_HEAD(, cam_ed) ed_entries;
|
|
|
|
TAILQ_ENTRY(cam_et) links;
|
|
|
|
struct cam_eb *bus;
|
|
|
|
target_id_t target_id;
|
|
|
|
u_int32_t refcount;
|
|
|
|
u_int generation;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Each bus is represented by an EB (Existing Bus). These entries
|
|
|
|
* are created by calls to xpt_bus_register and deleted by calls to
|
|
|
|
* xpt_bus_deregister.
|
|
|
|
*/
|
|
|
|
struct cam_eb {
|
|
|
|
TAILQ_HEAD(, cam_et) et_entries;
|
|
|
|
TAILQ_ENTRY(cam_eb) links;
|
|
|
|
struct async_list asyncs; /* Async callback info for this B/T/L */
|
|
|
|
path_id_t path_id;
|
|
|
|
struct cam_sim *sim;
|
|
|
|
u_int32_t flags;
|
|
|
|
#define CAM_EB_RUNQ_SCHEDULED 0x01
|
|
|
|
u_int generation;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct cam_path {
|
|
|
|
struct cam_periph *periph;
|
|
|
|
struct cam_eb *bus;
|
|
|
|
struct cam_et *target;
|
|
|
|
struct cam_ed *device;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct xpt_quirk_entry {
|
|
|
|
struct scsi_inquiry_pattern inq_pat;
|
|
|
|
u_int8_t quirks;
|
|
|
|
#define CAM_QUIRK_NOLUNS 0x01
|
|
|
|
#define CAM_QUIRK_NOSERIAL 0x02
|
|
|
|
u_int8_t mintags;
|
|
|
|
u_int8_t maxtags;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
XPT_FLAG_OPEN = 0x01
|
|
|
|
} xpt_flags;
|
|
|
|
|
|
|
|
struct xpt_softc {
|
|
|
|
xpt_flags flags;
|
|
|
|
u_int32_t generation;
|
|
|
|
#ifdef DEVFS
|
|
|
|
void *xpt_devfs_token;
|
|
|
|
void *ctl_devfs_token;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char quantum[] = "QUANTUM";
|
1998-09-22 20:41:12 +00:00
|
|
|
static const char sony[] = "SONY";
|
|
|
|
static const char west_digital[] = "WDIGTL";
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
static struct xpt_quirk_entry xpt_quirk_table[] =
|
|
|
|
{
|
|
|
|
{
|
|
|
|
/* Reports QUEUE FULL for temporary resource shortages */
|
1998-09-18 19:55:34 +00:00
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, quantum, "XP39100*", "*" },
|
1998-09-15 06:33:23 +00:00
|
|
|
/*quirks*/0, /*mintags*/24, /*maxtags*/32
|
|
|
|
},
|
|
|
|
{
|
|
|
|
/* Reports QUEUE FULL for temporary resource shortages */
|
1998-09-18 19:55:34 +00:00
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, quantum, "XP34550*", "*" },
|
|
|
|
/*quirks*/0, /*mintags*/24, /*maxtags*/32
|
|
|
|
},
|
|
|
|
{
|
|
|
|
/* Reports QUEUE FULL for temporary resource shortages */
|
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, quantum, "XP32275*", "*" },
|
1998-09-15 06:33:23 +00:00
|
|
|
/*quirks*/0, /*mintags*/24, /*maxtags*/32
|
|
|
|
},
|
|
|
|
{
|
|
|
|
/* Broken tagged queuing drive */
|
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, "HP", "C372*", "*" },
|
|
|
|
/*quirks*/0, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
|
|
|
{
|
|
|
|
/* Broken tagged queuing drive */
|
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, "MICROP", "3391*", "x43h" },
|
|
|
|
/*quirks*/0, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
1998-10-14 21:17:39 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Broken tagged queuing drive
|
|
|
|
* Reported by: Bret Ford <bford@uop.cs.uop.edu>
|
|
|
|
* and: Martin Renters <martin@tdc.on.ca>
|
|
|
|
*/
|
1998-10-14 22:51:51 +00:00
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, "SEAGATE", "ST410800*", "71*" },
|
1998-10-14 21:17:39 +00:00
|
|
|
/*quirks*/0, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
1998-09-15 06:33:23 +00:00
|
|
|
{
|
|
|
|
/* Broken tagged queuing drive */
|
|
|
|
{ T_DIRECT, SIP_MEDIA_REMOVABLE, "iomega", "jaz*", "*" },
|
|
|
|
/*quirks*/0, /*mintags*/0, /*maxtags*/0
|
1998-09-22 20:41:12 +00:00
|
|
|
},
|
1998-10-07 03:25:21 +00:00
|
|
|
{
|
|
|
|
/* Broken tagged queuing drive */
|
|
|
|
{ T_DIRECT, SIP_MEDIA_REMOVABLE, "CONNER", "CFP2107*", "*" },
|
|
|
|
/*quirks*/0, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
1998-09-22 20:41:12 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Slow when tagged queueing is enabled. (1.5MB/sec versus
|
|
|
|
* 8MB/sec.)
|
|
|
|
* Submitted by: Andrew Gallatin <gallatin@cs.duke.edu>
|
|
|
|
*/
|
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, west_digital, "WDE*", "*" },
|
|
|
|
/*quirks*/0, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Slow when tagged queueing is enabled. (1.5MB/sec versus
|
|
|
|
* 8MB/sec.)
|
|
|
|
* Submitted by: Andrew Gallatin <gallatin@cs.duke.edu>
|
|
|
|
*/
|
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, west_digital, "ENTERPRISE", "*" },
|
|
|
|
/*quirks*/0, /*mintags*/0, /*maxtags*/0
|
1998-09-15 06:33:23 +00:00
|
|
|
},
|
1998-09-20 07:14:36 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Doesn't handle queue full condition correctly,
|
|
|
|
* so we need to limit maxtags to what the device
|
|
|
|
* can handle instead of determining this automatically.
|
|
|
|
*/
|
|
|
|
{ T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "WN321010S*", "*" },
|
1998-09-23 03:03:19 +00:00
|
|
|
/*quirks*/0, /*mintags*/2, /*maxtags*/32
|
1998-09-20 07:14:36 +00:00
|
|
|
},
|
1998-09-15 06:33:23 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Hack until multiple-luns are supported by
|
|
|
|
* the target mode code.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
T_PROCESSOR, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED,
|
|
|
|
"FreeBSD", "TM-PT", "*"
|
|
|
|
},
|
|
|
|
CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
1998-09-22 04:53:23 +00:00
|
|
|
{
|
1998-09-23 03:03:19 +00:00
|
|
|
/* Really only one LUN */
|
1998-09-22 04:53:23 +00:00
|
|
|
{
|
1998-09-23 03:03:19 +00:00
|
|
|
T_ENCLOSURE, SIP_MEDIA_FIXED, "SUN", "SENA*", "*"
|
1998-09-22 04:53:23 +00:00
|
|
|
},
|
1998-09-23 03:03:19 +00:00
|
|
|
CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0
|
1998-09-22 04:53:23 +00:00
|
|
|
},
|
1998-09-15 06:33:23 +00:00
|
|
|
{
|
1998-09-23 03:03:19 +00:00
|
|
|
/* I can't believe we need a quirk for DPT volumes. */
|
1998-09-15 06:33:23 +00:00
|
|
|
{
|
1998-09-23 03:03:19 +00:00
|
|
|
T_ANY, SIP_MEDIA_FIXED|SIP_MEDIA_REMOVABLE,
|
|
|
|
"DPT", "*", "*"
|
1998-09-15 06:33:23 +00:00
|
|
|
},
|
1998-09-23 03:03:19 +00:00
|
|
|
CAM_QUIRK_NOSERIAL|CAM_QUIRK_NOLUNS,
|
|
|
|
/*mintags*/0, /*maxtags*/255
|
1998-09-17 23:58:53 +00:00
|
|
|
},
|
1998-09-22 20:41:12 +00:00
|
|
|
{
|
|
|
|
/*
|
1998-11-04 19:56:24 +00:00
|
|
|
* Many Sony CDROM drives don't like multi-LUN probing.
|
1998-09-22 20:41:12 +00:00
|
|
|
*/
|
|
|
|
{
|
|
|
|
T_CDROM, SIP_MEDIA_REMOVABLE, sony,
|
1998-11-04 19:56:24 +00:00
|
|
|
"CD-ROM CDU*", "*"
|
1998-09-22 20:41:12 +00:00
|
|
|
},
|
|
|
|
CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This drive doesn't like multiple LUN probing.
|
|
|
|
* Submitted by: Parag Patel <parag@cgt.com>
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
T_WORM, SIP_MEDIA_REMOVABLE, sony,
|
|
|
|
"CD-R CDU9*", "*"
|
|
|
|
},
|
|
|
|
CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
1998-09-15 06:33:23 +00:00
|
|
|
{
|
1998-10-06 19:27:19 +00:00
|
|
|
/*
|
|
|
|
* The 8200 doesn't like multi-lun probing, and probably
|
|
|
|
* don't like serial number requests either.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "EXABYTE",
|
|
|
|
"EXB-8200*", "*"
|
|
|
|
},
|
|
|
|
CAM_QUIRK_NOSERIAL|CAM_QUIRK_NOLUNS, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
1998-11-25 13:50:10 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This old revision of the TDC3600 is also SCSI-1, and
|
|
|
|
* hangs upon serial number probing.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
T_SEQUENTIAL, SIP_MEDIA_REMOVABLE, "TANDBERG",
|
|
|
|
" TDC 3600", "U07:"
|
|
|
|
},
|
|
|
|
CAM_QUIRK_NOSERIAL, /*mintags*/0, /*maxtags*/0
|
|
|
|
},
|
1998-10-06 19:27:19 +00:00
|
|
|
{
|
1998-09-15 06:33:23 +00:00
|
|
|
/* Default tagged queuing parameters for all devices */
|
|
|
|
{
|
|
|
|
T_ANY, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED,
|
|
|
|
/*vendor*/"*", /*product*/"*", /*revision*/"*"
|
|
|
|
},
|
1998-09-23 03:03:19 +00:00
|
|
|
/*quirks*/0, /*mintags*/2, /*maxtags*/255
|
1998-09-15 06:33:23 +00:00
|
|
|
},
|
|
|
|
};
|
1998-09-23 03:03:19 +00:00
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
typedef enum {
|
|
|
|
DM_RET_COPY = 0x01,
|
|
|
|
DM_RET_FLAG_MASK = 0x0f,
|
|
|
|
DM_RET_NONE = 0x00,
|
|
|
|
DM_RET_STOP = 0x10,
|
|
|
|
DM_RET_DESCEND = 0x20,
|
|
|
|
DM_RET_ERROR = 0x30,
|
|
|
|
DM_RET_ACTION_MASK = 0xf0
|
|
|
|
} dev_match_ret;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
XPT_DEPTH_BUS,
|
|
|
|
XPT_DEPTH_TARGET,
|
|
|
|
XPT_DEPTH_DEVICE,
|
|
|
|
XPT_DEPTH_PERIPH
|
|
|
|
} xpt_traverse_depth;
|
|
|
|
|
|
|
|
struct xpt_traverse_config {
|
|
|
|
xpt_traverse_depth depth;
|
|
|
|
void *tr_func;
|
|
|
|
void *tr_arg;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef int xpt_busfunc_t (struct cam_eb *bus, void *arg);
|
|
|
|
typedef int xpt_targetfunc_t (struct cam_et *target, void *arg);
|
|
|
|
typedef int xpt_devicefunc_t (struct cam_ed *device, void *arg);
|
|
|
|
typedef int xpt_periphfunc_t (struct cam_periph *periph, void *arg);
|
|
|
|
typedef int xpt_pdrvfunc_t (struct periph_driver **pdrv, void *arg);
|
|
|
|
|
|
|
|
/* Transport layer configuration information */
|
|
|
|
static struct xpt_softc xsoftc;
|
|
|
|
|
|
|
|
/* Queues for our software interrupt handler */
|
|
|
|
typedef TAILQ_HEAD(cam_isrq, ccb_hdr) cam_isrq_t;
|
|
|
|
static cam_isrq_t cam_bioq;
|
|
|
|
static cam_isrq_t cam_netq;
|
|
|
|
|
|
|
|
/* "Pool" of inactive ccbs managed by xpt_alloc_ccb and xpt_free_ccb */
|
1998-12-22 20:05:23 +00:00
|
|
|
static SLIST_HEAD(,ccb_hdr) ccb_freeq;
|
1998-09-15 06:33:23 +00:00
|
|
|
static u_int xpt_max_ccbs; /*
|
|
|
|
* Maximum size of ccb pool. Modified as
|
|
|
|
* devices are added/removed or have their
|
|
|
|
* opening counts changed.
|
|
|
|
*/
|
|
|
|
static u_int xpt_ccb_count; /* Current count of allocated ccbs */
|
|
|
|
|
|
|
|
static struct cam_periph *xpt_periph;
|
|
|
|
|
|
|
|
static periph_init_t xpt_periph_init;
|
|
|
|
|
|
|
|
static periph_init_t probe_periph_init;
|
|
|
|
|
|
|
|
static struct periph_driver xpt_driver =
|
|
|
|
{
|
|
|
|
xpt_periph_init, "xpt",
|
|
|
|
TAILQ_HEAD_INITIALIZER(xpt_driver.units)
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct periph_driver probe_driver =
|
|
|
|
{
|
|
|
|
probe_periph_init, "probe",
|
|
|
|
TAILQ_HEAD_INITIALIZER(probe_driver.units)
|
|
|
|
};
|
|
|
|
|
|
|
|
DATA_SET(periphdriver_set, xpt_driver);
|
|
|
|
DATA_SET(periphdriver_set, probe_driver);
|
|
|
|
|
|
|
|
#define XPT_CDEV_MAJOR 104
|
|
|
|
|
|
|
|
static d_open_t xptopen;
|
|
|
|
static d_close_t xptclose;
|
|
|
|
static d_ioctl_t xptioctl;
|
|
|
|
|
|
|
|
static struct cdevsw xpt_cdevsw =
|
|
|
|
{
|
|
|
|
/*d_open*/ xptopen,
|
|
|
|
/*d_close*/ xptclose,
|
|
|
|
/*d_read*/ noread,
|
|
|
|
/*d_write*/ nowrite,
|
|
|
|
/*d_ioctl*/ xptioctl,
|
|
|
|
/*d_stop*/ nostop,
|
|
|
|
/*d_reset*/ noreset,
|
|
|
|
/*d_devtotty*/ nodevtotty,
|
|
|
|
/*d_poll*/ NULL,
|
|
|
|
/*d_mmap*/ nommap,
|
|
|
|
/*d_strategy*/ nostrategy,
|
|
|
|
/*d_name*/ "xpt",
|
|
|
|
/*d_spare*/ NULL,
|
|
|
|
/*d_maj*/ -1,
|
|
|
|
/*d_dump*/ nodump,
|
|
|
|
/*d_psize*/ nopsize,
|
|
|
|
/*d_flags*/ 0,
|
|
|
|
/*d_maxio*/ 0,
|
|
|
|
/*b_maj*/ -1
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct intr_config_hook *xpt_config_hook;
|
|
|
|
|
|
|
|
/* Registered busses */
|
1998-12-22 20:05:23 +00:00
|
|
|
static TAILQ_HEAD(,cam_eb) xpt_busses;
|
1998-09-15 06:33:23 +00:00
|
|
|
static u_int bus_generation;
|
|
|
|
|
|
|
|
/* Storage for debugging datastructures */
|
|
|
|
#ifdef CAMDEBUG
|
|
|
|
struct cam_path *cam_dpath;
|
|
|
|
u_int32_t cam_dflags;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(CAM_DEBUG_FLAGS) && !defined(CAMDEBUG)
|
|
|
|
#error "You must have options CAMDEBUG to use options CAM_DEBUG_FLAGS"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In order to enable the CAM_DEBUG_* options, the user must have CAMDEBUG
|
|
|
|
* enabled. Also, the user must have either none, or all of CAM_DEBUG_BUS,
|
|
|
|
* CAM_DEBUG_TARGET, and CAM_DEBUG_LUN specified.
|
|
|
|
*/
|
|
|
|
#if defined(CAM_DEBUG_BUS) || defined(CAM_DEBUG_TARGET) \
|
|
|
|
|| defined(CAM_DEBUG_LUN)
|
|
|
|
#ifdef CAMDEBUG
|
|
|
|
#if !defined(CAM_DEBUG_BUS) || !defined(CAM_DEBUG_TARGET) \
|
|
|
|
|| !defined(CAM_DEBUG_LUN)
|
|
|
|
#error "You must define all or none of CAM_DEBUG_BUS, CAM_DEBUG_TARGET \
|
|
|
|
and CAM_DEBUG_LUN"
|
|
|
|
#endif /* !CAM_DEBUG_BUS || !CAM_DEBUG_TARGET || !CAM_DEBUG_LUN */
|
|
|
|
#else /* !CAMDEBUG */
|
|
|
|
#error "You must use options CAMDEBUG if you use the CAM_DEBUG_* options"
|
|
|
|
#endif /* CAMDEBUG */
|
|
|
|
#endif /* CAM_DEBUG_BUS || CAM_DEBUG_TARGET || CAM_DEBUG_LUN */
|
|
|
|
|
|
|
|
/* Forward declarations for private functions */
|
|
|
|
void xpt_init(void);
|
|
|
|
|
|
|
|
static cam_status xpt_compile_path(struct cam_path *new_path,
|
|
|
|
struct cam_periph *perph,
|
|
|
|
path_id_t path_id,
|
|
|
|
target_id_t target_id,
|
|
|
|
lun_id_t lun_id);
|
|
|
|
|
|
|
|
static void xpt_release_path(struct cam_path *path);
|
|
|
|
|
|
|
|
static void xpt_async_bcast(struct async_list *async_head,
|
|
|
|
u_int32_t async_code,
|
|
|
|
struct cam_path *path,
|
|
|
|
void *async_arg);
|
|
|
|
static int xptnextfreebus(path_id_t startbus);
|
|
|
|
static int xptpathid(const char *sim_name, int sim_unit, int sim_bus,
|
|
|
|
path_id_t *nextpath);
|
|
|
|
static union ccb *xpt_get_ccb(struct cam_ed *device);
|
|
|
|
static int xpt_schedule_dev(struct camq *queue, cam_pinfo *dev_pinfo,
|
|
|
|
u_int32_t new_priority);
|
|
|
|
static void xpt_run_dev_allocq(struct cam_eb *bus);
|
|
|
|
static void xpt_run_dev_sendq(struct cam_eb *bus);
|
|
|
|
static timeout_t xpt_release_devq_timeout;
|
|
|
|
static timeout_t xpt_release_simq_timeout;
|
|
|
|
static struct cam_et*
|
|
|
|
xpt_alloc_target(struct cam_eb *bus, target_id_t target_id);
|
|
|
|
static void xpt_release_target(struct cam_eb *bus, struct cam_et *target);
|
|
|
|
static struct cam_ed*
|
|
|
|
xpt_alloc_device(struct cam_eb *bus, struct cam_et *target,
|
|
|
|
lun_id_t lun_id);
|
|
|
|
static void xpt_release_device(struct cam_eb *bus, struct cam_et *target,
|
|
|
|
struct cam_ed *device);
|
|
|
|
static u_int32_t xpt_dev_ccbq_resize(struct cam_path *path, int newopenings);
|
|
|
|
static struct cam_eb*
|
|
|
|
xpt_find_bus(path_id_t path_id);
|
|
|
|
static struct cam_et*
|
|
|
|
xpt_find_target(struct cam_eb *bus, target_id_t target_id);
|
|
|
|
static struct cam_ed*
|
|
|
|
xpt_find_device(struct cam_et *target, lun_id_t lun_id);
|
|
|
|
static void xpt_scan_bus(struct cam_periph *periph, union ccb *ccb);
|
|
|
|
static void xpt_scan_lun(struct cam_periph *periph,
|
|
|
|
struct cam_path *path, cam_flags flags,
|
|
|
|
union ccb *ccb);
|
|
|
|
static void xptscandone(struct cam_periph *periph, union ccb *done_ccb);
|
|
|
|
static xpt_busfunc_t xptconfigbuscountfunc;
|
|
|
|
static xpt_busfunc_t xptconfigfunc;
|
|
|
|
static void xpt_config(void *arg);
|
|
|
|
static xpt_devicefunc_t xptfinishconfigfunc;
|
|
|
|
static xpt_devicefunc_t xptpassannouncefunc;
|
|
|
|
static void xpt_finishconfig(struct cam_periph *periph, union ccb *ccb);
|
|
|
|
static void xptaction(struct cam_sim *sim, union ccb *work_ccb);
|
|
|
|
void swi_camnet(void);
|
|
|
|
void swi_cambio(void);
|
|
|
|
static void camisr(cam_isrq_t *queue);
|
|
|
|
#if 0
|
|
|
|
static void xptstart(struct cam_periph *periph, union ccb *work_ccb);
|
|
|
|
static void xptasync(struct cam_periph *periph,
|
|
|
|
u_int32_t code, cam_path *path);
|
|
|
|
#endif
|
|
|
|
static dev_match_ret xptbusmatch(struct dev_match_pattern *patterns,
|
|
|
|
int num_patterns, struct cam_eb *bus);
|
|
|
|
static dev_match_ret xptdevicematch(struct dev_match_pattern *patterns,
|
|
|
|
int num_patterns, struct cam_ed *device);
|
|
|
|
static dev_match_ret xptperiphmatch(struct dev_match_pattern *patterns,
|
|
|
|
int num_patterns,
|
|
|
|
struct cam_periph *periph);
|
|
|
|
static xpt_busfunc_t xptedtbusfunc;
|
|
|
|
static xpt_targetfunc_t xptedttargetfunc;
|
|
|
|
static xpt_devicefunc_t xptedtdevicefunc;
|
|
|
|
static xpt_periphfunc_t xptedtperiphfunc;
|
|
|
|
static xpt_pdrvfunc_t xptplistpdrvfunc;
|
|
|
|
static xpt_periphfunc_t xptplistperiphfunc;
|
|
|
|
static int xptedtmatch(struct ccb_dev_match *cdm);
|
|
|
|
static int xptperiphlistmatch(struct ccb_dev_match *cdm);
|
|
|
|
static int xptbustraverse(struct cam_eb *start_bus,
|
|
|
|
xpt_busfunc_t *tr_func, void *arg);
|
|
|
|
static int xpttargettraverse(struct cam_eb *bus,
|
|
|
|
struct cam_et *start_target,
|
|
|
|
xpt_targetfunc_t *tr_func, void *arg);
|
|
|
|
static int xptdevicetraverse(struct cam_et *target,
|
|
|
|
struct cam_ed *start_device,
|
|
|
|
xpt_devicefunc_t *tr_func, void *arg);
|
|
|
|
static int xptperiphtraverse(struct cam_ed *device,
|
|
|
|
struct cam_periph *start_periph,
|
|
|
|
xpt_periphfunc_t *tr_func, void *arg);
|
|
|
|
static int xptpdrvtraverse(struct periph_driver **start_pdrv,
|
|
|
|
xpt_pdrvfunc_t *tr_func, void *arg);
|
|
|
|
static int xptpdperiphtraverse(struct periph_driver **pdrv,
|
|
|
|
struct cam_periph *start_periph,
|
|
|
|
xpt_periphfunc_t *tr_func,
|
|
|
|
void *arg);
|
|
|
|
static xpt_busfunc_t xptdefbusfunc;
|
|
|
|
static xpt_targetfunc_t xptdeftargetfunc;
|
|
|
|
static xpt_devicefunc_t xptdefdevicefunc;
|
|
|
|
static xpt_periphfunc_t xptdefperiphfunc;
|
|
|
|
static int xpt_for_all_busses(xpt_busfunc_t *tr_func, void *arg);
|
|
|
|
static int xpt_for_all_targets(xpt_targetfunc_t *tr_func,
|
|
|
|
void *arg);
|
|
|
|
static int xpt_for_all_devices(xpt_devicefunc_t *tr_func,
|
|
|
|
void *arg);
|
|
|
|
static int xpt_for_all_periphs(xpt_periphfunc_t *tr_func,
|
|
|
|
void *arg);
|
|
|
|
static xpt_devicefunc_t xptsetasyncfunc;
|
|
|
|
static xpt_busfunc_t xptsetasyncbusfunc;
|
|
|
|
static cam_status xptregister(struct cam_periph *periph,
|
|
|
|
void *arg);
|
|
|
|
static cam_status proberegister(struct cam_periph *periph,
|
|
|
|
void *arg);
|
|
|
|
static void probeschedule(struct cam_periph *probe_periph);
|
|
|
|
static void probestart(struct cam_periph *periph, union ccb *start_ccb);
|
|
|
|
static void probedone(struct cam_periph *periph, union ccb *done_ccb);
|
|
|
|
static void probecleanup(struct cam_periph *periph);
|
|
|
|
static void xpt_find_quirk(struct cam_ed *device);
|
|
|
|
static void xpt_set_transfer_settings(struct ccb_trans_settings *cts,
|
1998-09-25 22:35:56 +00:00
|
|
|
struct cam_ed *device,
|
1998-09-15 06:33:23 +00:00
|
|
|
int async_update);
|
1998-09-24 22:43:54 +00:00
|
|
|
static void xpt_toggle_tags(struct cam_path *path);
|
1998-09-23 03:03:19 +00:00
|
|
|
static void xpt_start_tags(struct cam_path *path);
|
1998-09-15 06:33:23 +00:00
|
|
|
static __inline int xpt_schedule_dev_allocq(struct cam_eb *bus,
|
|
|
|
struct cam_ed *dev);
|
|
|
|
static __inline int xpt_schedule_dev_sendq(struct cam_eb *bus,
|
|
|
|
struct cam_ed *dev);
|
|
|
|
static __inline int periph_is_queued(struct cam_periph *periph);
|
|
|
|
static __inline int device_is_alloc_queued(struct cam_ed *device);
|
|
|
|
static __inline int device_is_send_queued(struct cam_ed *device);
|
|
|
|
static __inline int dev_allocq_is_runnable(struct cam_devq *devq);
|
|
|
|
|
|
|
|
static __inline int
|
|
|
|
xpt_schedule_dev_allocq(struct cam_eb *bus, struct cam_ed *dev)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
if (dev->ccbq.devq_openings > 0) {
|
|
|
|
if ((dev->flags & CAM_DEV_RESIZE_QUEUE_NEEDED) != 0) {
|
|
|
|
cam_ccbq_resize(&dev->ccbq,
|
|
|
|
dev->ccbq.dev_openings
|
|
|
|
+ dev->ccbq.dev_active);
|
|
|
|
dev->flags &= ~CAM_DEV_RESIZE_QUEUE_NEEDED;
|
|
|
|
}
|
|
|
|
retval = xpt_schedule_dev(&bus->sim->devq->alloc_queue,
|
|
|
|
&dev->alloc_ccb_entry.pinfo,
|
|
|
|
dev->drvq.queue_array[0]->priority);
|
|
|
|
} else {
|
|
|
|
retval = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline int
|
|
|
|
xpt_schedule_dev_sendq(struct cam_eb *bus, struct cam_ed *dev)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
if (dev->ccbq.dev_openings > 0) {
|
|
|
|
retval = xpt_schedule_dev(&bus->sim->devq->send_queue,
|
|
|
|
&dev->send_ccb_entry.pinfo,
|
|
|
|
dev->ccbq.queue.queue_array[0]->priority);
|
|
|
|
} else {
|
|
|
|
retval = 0;
|
|
|
|
}
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline int
|
|
|
|
periph_is_queued(struct cam_periph *periph)
|
|
|
|
{
|
|
|
|
return (periph->pinfo.index != CAM_UNQUEUED_INDEX);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline int
|
|
|
|
device_is_alloc_queued(struct cam_ed *device)
|
|
|
|
{
|
|
|
|
return (device->alloc_ccb_entry.pinfo.index != CAM_UNQUEUED_INDEX);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline int
|
|
|
|
device_is_send_queued(struct cam_ed *device)
|
|
|
|
{
|
|
|
|
return (device->send_ccb_entry.pinfo.index != CAM_UNQUEUED_INDEX);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline int
|
|
|
|
dev_allocq_is_runnable(struct cam_devq *devq)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Have work to do.
|
|
|
|
* Have space to do more work.
|
|
|
|
* Allowed to do work.
|
|
|
|
*/
|
|
|
|
return ((devq->alloc_queue.qfrozen_cnt == 0)
|
|
|
|
&& (devq->alloc_queue.entries > 0)
|
|
|
|
&& (devq->alloc_openings > 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_periph_init()
|
|
|
|
{
|
|
|
|
dev_t dev;
|
|
|
|
|
|
|
|
dev = makedev(XPT_CDEV_MAJOR, 0);
|
|
|
|
cdevsw_add(&dev, &xpt_cdevsw, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
probe_periph_init()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
xptdone(struct cam_periph *periph, union ccb *done_ccb)
|
|
|
|
{
|
|
|
|
/* Caller will release the CCB */
|
|
|
|
wakeup(&done_ccb->ccb_h.cbfcnp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptopen(dev_t dev, int flags, int fmt, struct proc *p)
|
|
|
|
{
|
|
|
|
int unit;
|
|
|
|
|
|
|
|
unit = minor(dev) & 0xff;
|
|
|
|
|
1998-09-16 00:11:53 +00:00
|
|
|
/*
|
|
|
|
* Only allow read-write access.
|
|
|
|
*/
|
|
|
|
if (((flags & FWRITE) == 0) || ((flags & FREAD) == 0))
|
|
|
|
return(EPERM);
|
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
/*
|
|
|
|
* We don't allow nonblocking access.
|
|
|
|
*/
|
|
|
|
if ((flags & O_NONBLOCK) != 0) {
|
|
|
|
printf("xpt%d: can't do nonblocking accesss\n", unit);
|
|
|
|
return(ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only have one transport layer right now. If someone accesses
|
|
|
|
* us via something other than minor number 1, point out their
|
|
|
|
* mistake.
|
|
|
|
*/
|
|
|
|
if (unit != 0) {
|
|
|
|
printf("xptopen: got invalid xpt unit %d\n", unit);
|
|
|
|
return(ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark ourselves open */
|
|
|
|
xsoftc.flags |= XPT_FLAG_OPEN;
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptclose(dev_t dev, int flag, int fmt, struct proc *p)
|
|
|
|
{
|
|
|
|
int unit;
|
|
|
|
|
|
|
|
unit = minor(dev) & 0xff;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only have one transport layer right now. If someone accesses
|
|
|
|
* us via something other than minor number 1, point out their
|
|
|
|
* mistake.
|
|
|
|
*/
|
|
|
|
if (unit != 0) {
|
|
|
|
printf("xptclose: got invalid xpt unit %d\n", unit);
|
|
|
|
return(ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark ourselves closed */
|
|
|
|
xsoftc.flags &= ~XPT_FLAG_OPEN;
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
|
|
|
|
{
|
|
|
|
int unit, error;
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
unit = minor(dev) & 0xff;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only have one transport layer right now. If someone accesses
|
|
|
|
* us via something other than minor number 1, point out their
|
|
|
|
* mistake.
|
|
|
|
*/
|
|
|
|
if (unit != 0) {
|
|
|
|
printf("xptioctl: got invalid xpt unit %d\n", unit);
|
|
|
|
return(ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(cmd) {
|
|
|
|
/*
|
|
|
|
* For the transport layer CAMIOCOMMAND ioctl, we really only want
|
|
|
|
* to accept CCB types that don't quite make sense to send through a
|
|
|
|
* passthrough driver.
|
|
|
|
*/
|
|
|
|
case CAMIOCOMMAND: {
|
|
|
|
union ccb *ccb;
|
|
|
|
union ccb *inccb;
|
|
|
|
|
|
|
|
inccb = (union ccb *)addr;
|
|
|
|
|
|
|
|
switch(inccb->ccb_h.func_code) {
|
|
|
|
case XPT_SCAN_BUS:
|
|
|
|
case XPT_RESET_BUS:
|
|
|
|
if ((inccb->ccb_h.target_id != CAM_TARGET_WILDCARD)
|
|
|
|
|| (inccb->ccb_h.target_lun != CAM_LUN_WILDCARD)) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case XPT_SCAN_LUN:
|
|
|
|
case XPT_ENG_INQ: /* XXX not implemented yet */
|
|
|
|
case XPT_ENG_EXEC:
|
|
|
|
|
|
|
|
ccb = xpt_alloc_ccb();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a path using the bus, target, and lun the
|
|
|
|
* user passed in.
|
|
|
|
*/
|
|
|
|
if (xpt_create_path(&ccb->ccb_h.path, xpt_periph,
|
|
|
|
inccb->ccb_h.path_id,
|
|
|
|
inccb->ccb_h.target_id,
|
|
|
|
inccb->ccb_h.target_lun) !=
|
|
|
|
CAM_REQ_CMP){
|
|
|
|
error = EINVAL;
|
|
|
|
xpt_free_ccb(ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Ensure all of our fields are correct */
|
|
|
|
xpt_setup_ccb(&ccb->ccb_h, ccb->ccb_h.path,
|
|
|
|
inccb->ccb_h.pinfo.priority);
|
|
|
|
xpt_merge_ccb(ccb, inccb);
|
|
|
|
ccb->ccb_h.cbfcnp = xptdone;
|
|
|
|
cam_periph_runccb(ccb, NULL, 0, 0, NULL);
|
|
|
|
bcopy(ccb, inccb, sizeof(union ccb));
|
|
|
|
xpt_free_path(ccb->ccb_h.path);
|
|
|
|
xpt_free_ccb(ccb);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case XPT_DEBUG: {
|
|
|
|
union ccb ccb;
|
|
|
|
|
|
|
|
/*
|
1998-12-06 00:06:48 +00:00
|
|
|
* This is an immediate CCB, so it's okay to
|
1998-09-15 06:33:23 +00:00
|
|
|
* allocate it on the stack.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a path using the bus, target, and lun the
|
|
|
|
* user passed in.
|
|
|
|
*/
|
|
|
|
if (xpt_create_path(&ccb.ccb_h.path, xpt_periph,
|
|
|
|
inccb->ccb_h.path_id,
|
|
|
|
inccb->ccb_h.target_id,
|
|
|
|
inccb->ccb_h.target_lun) !=
|
|
|
|
CAM_REQ_CMP){
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Ensure all of our fields are correct */
|
|
|
|
xpt_setup_ccb(&ccb.ccb_h, ccb.ccb_h.path,
|
|
|
|
inccb->ccb_h.pinfo.priority);
|
|
|
|
xpt_merge_ccb(&ccb, inccb);
|
|
|
|
ccb.ccb_h.cbfcnp = xptdone;
|
|
|
|
xpt_action(&ccb);
|
|
|
|
bcopy(&ccb, inccb, sizeof(union ccb));
|
|
|
|
xpt_free_path(ccb.ccb_h.path);
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
case XPT_DEV_MATCH: {
|
|
|
|
struct cam_periph_map_info mapinfo;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can't deal with physical addresses for this
|
|
|
|
* type of transaction.
|
|
|
|
*/
|
|
|
|
if (inccb->ccb_h.flags & CAM_DATA_PHYS) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
bzero(&mapinfo, sizeof(mapinfo));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Map the pattern and match buffers into kernel
|
|
|
|
* virtual address space.
|
|
|
|
*/
|
|
|
|
error = cam_periph_mapmem(inccb, &mapinfo);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is an immediate CCB, we can send it on directly.
|
|
|
|
*/
|
|
|
|
xpt_action(inccb);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Map the buffers back into user space.
|
|
|
|
*/
|
|
|
|
cam_periph_unmapmem(inccb, &mapinfo);
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* This is the getpassthru ioctl. It takes a XPT_GDEVLIST ccb as input,
|
|
|
|
* with the periphal driver name and unit name filled in. The other
|
|
|
|
* fields don't really matter as input. The passthrough driver name
|
|
|
|
* ("pass"), and unit number are passed back in the ccb. The current
|
|
|
|
* device generation number, and the index into the device peripheral
|
|
|
|
* driver list, and the status are also passed back. Note that
|
|
|
|
* since we do everything in one pass, unlike the XPT_GDEVLIST ccb,
|
|
|
|
* we never return a status of CAM_GDEVLIST_LIST_CHANGED. It is
|
|
|
|
* (or rather should be) impossible for the device peripheral driver
|
|
|
|
* list to change since we look at the whole thing in one pass, and
|
|
|
|
* we do it with splsoftcam protection.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
case CAMGETPASSTHRU: {
|
|
|
|
union ccb *ccb;
|
|
|
|
struct cam_periph *periph;
|
|
|
|
struct periph_driver **p_drv;
|
|
|
|
char *name;
|
|
|
|
int unit;
|
|
|
|
int cur_generation;
|
1998-10-12 21:54:13 +00:00
|
|
|
int base_periph_found;
|
1998-09-15 06:33:23 +00:00
|
|
|
int splbreaknum;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
ccb = (union ccb *)addr;
|
|
|
|
unit = ccb->cgdl.unit_number;
|
|
|
|
name = ccb->cgdl.periph_name;
|
|
|
|
/*
|
|
|
|
* Every 100 devices, we want to drop our spl protection to
|
|
|
|
* give the software interrupt handler a chance to run.
|
|
|
|
* Most systems won't run into this check, but this should
|
|
|
|
* avoid starvation in the software interrupt handler in
|
|
|
|
* large systems.
|
|
|
|
*/
|
|
|
|
splbreaknum = 100;
|
|
|
|
|
|
|
|
ccb = (union ccb *)addr;
|
|
|
|
|
1998-10-12 21:54:13 +00:00
|
|
|
base_periph_found = 0;
|
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
/*
|
|
|
|
* Sanity check -- make sure we don't get a null peripheral
|
|
|
|
* driver name.
|
|
|
|
*/
|
|
|
|
if (*ccb->cgdl.periph_name == '\0') {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Keep the list from changing while we traverse it */
|
|
|
|
s = splsoftcam();
|
|
|
|
ptstartover:
|
|
|
|
cur_generation = xsoftc.generation;
|
|
|
|
|
|
|
|
/* first find our driver in the list of drivers */
|
|
|
|
for (p_drv = (struct periph_driver **)periphdriver_set.ls_items;
|
|
|
|
*p_drv != NULL; p_drv++)
|
|
|
|
if (strcmp((*p_drv)->driver_name, name) == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (*p_drv == NULL) {
|
|
|
|
splx(s);
|
|
|
|
ccb->ccb_h.status = CAM_REQ_CMP_ERR;
|
|
|
|
ccb->cgdl.status = CAM_GDEVLIST_ERROR;
|
|
|
|
*ccb->cgdl.periph_name = '\0';
|
|
|
|
ccb->cgdl.unit_number = 0;
|
|
|
|
error = ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Run through every peripheral instance of this driver
|
|
|
|
* and check to see whether it matches the unit passed
|
|
|
|
* in by the user. If it does, get out of the loops and
|
|
|
|
* find the passthrough driver associated with that
|
|
|
|
* peripheral driver.
|
|
|
|
*/
|
|
|
|
for (periph = TAILQ_FIRST(&(*p_drv)->units); periph != NULL;
|
|
|
|
periph = TAILQ_NEXT(periph, unit_links)) {
|
|
|
|
|
|
|
|
if (periph->unit_number == unit) {
|
|
|
|
break;
|
|
|
|
} else if (--splbreaknum == 0) {
|
|
|
|
splx(s);
|
|
|
|
s = splsoftcam();
|
|
|
|
splbreaknum = 100;
|
|
|
|
if (cur_generation != xsoftc.generation)
|
|
|
|
goto ptstartover;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we found the peripheral driver that the user passed
|
|
|
|
* in, go through all of the peripheral drivers for that
|
|
|
|
* particular device and look for a passthrough driver.
|
|
|
|
*/
|
|
|
|
if (periph != NULL) {
|
|
|
|
struct cam_ed *device;
|
|
|
|
int i;
|
|
|
|
|
1998-10-12 21:54:13 +00:00
|
|
|
base_periph_found = 1;
|
1998-09-15 06:33:23 +00:00
|
|
|
device = periph->path->device;
|
|
|
|
for (i = 0, periph = device->periphs.slh_first;
|
|
|
|
periph != NULL;
|
|
|
|
periph = periph->periph_links.sle_next, i++) {
|
|
|
|
/*
|
|
|
|
* Check to see whether we have a
|
|
|
|
* passthrough device or not.
|
|
|
|
*/
|
|
|
|
if (strcmp(periph->periph_name, "pass") == 0) {
|
|
|
|
/*
|
|
|
|
* Fill in the getdevlist fields.
|
|
|
|
*/
|
|
|
|
strcpy(ccb->cgdl.periph_name,
|
|
|
|
periph->periph_name);
|
|
|
|
ccb->cgdl.unit_number =
|
|
|
|
periph->unit_number;
|
|
|
|
if (periph->periph_links.sle_next)
|
|
|
|
ccb->cgdl.status =
|
|
|
|
CAM_GDEVLIST_MORE_DEVS;
|
|
|
|
else
|
|
|
|
ccb->cgdl.status =
|
|
|
|
CAM_GDEVLIST_LAST_DEVICE;
|
|
|
|
ccb->cgdl.generation =
|
|
|
|
device->generation;
|
|
|
|
ccb->cgdl.index = i;
|
|
|
|
/*
|
|
|
|
* Fill in some CCB header fields
|
|
|
|
* that the user may want.
|
|
|
|
*/
|
|
|
|
ccb->ccb_h.path_id =
|
|
|
|
periph->path->bus->path_id;
|
|
|
|
ccb->ccb_h.target_id =
|
|
|
|
periph->path->target->target_id;
|
|
|
|
ccb->ccb_h.target_lun =
|
|
|
|
periph->path->device->lun_id;
|
|
|
|
ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the periph is null here, one of two things has
|
|
|
|
* happened. The first possibility is that we couldn't
|
|
|
|
* find the unit number of the particular peripheral driver
|
|
|
|
* that the user is asking about. e.g. the user asks for
|
|
|
|
* the passthrough driver for "da11". We find the list of
|
|
|
|
* "da" peripherals all right, but there is no unit 11.
|
|
|
|
* The other possibility is that we went through the list
|
|
|
|
* of peripheral drivers attached to the device structure,
|
|
|
|
* but didn't find one with the name "pass". Either way,
|
|
|
|
* we return ENOENT, since we couldn't find something.
|
|
|
|
*/
|
|
|
|
if (periph == NULL) {
|
|
|
|
ccb->ccb_h.status = CAM_REQ_CMP_ERR;
|
|
|
|
ccb->cgdl.status = CAM_GDEVLIST_ERROR;
|
|
|
|
*ccb->cgdl.periph_name = '\0';
|
|
|
|
ccb->cgdl.unit_number = 0;
|
|
|
|
error = ENOENT;
|
1998-10-12 21:54:13 +00:00
|
|
|
/*
|
|
|
|
* It is unfortunate that this is even necessary,
|
|
|
|
* but there are many, many clueless users out there.
|
|
|
|
* If this is true, the user is looking for the
|
|
|
|
* passthrough driver, but doesn't have one in his
|
|
|
|
* kernel.
|
|
|
|
*/
|
|
|
|
if (base_periph_found == 1) {
|
|
|
|
printf("xptioctl: pass driver is not in the "
|
|
|
|
"kernel\n");
|
|
|
|
printf("xptioctl: put \"device pass0\" in "
|
|
|
|
"your kernel config file\n");
|
|
|
|
}
|
1998-09-15 06:33:23 +00:00
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
error = ENOTTY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Functions accessed by the peripheral drivers */
|
|
|
|
void
|
|
|
|
xpt_init()
|
|
|
|
{
|
|
|
|
struct cam_sim *xpt_sim;
|
|
|
|
struct cam_path *path;
|
|
|
|
struct cam_devq;
|
|
|
|
cam_status status;
|
|
|
|
|
|
|
|
TAILQ_INIT(&xpt_busses);
|
|
|
|
TAILQ_INIT(&cam_bioq);
|
|
|
|
TAILQ_INIT(&cam_netq);
|
|
|
|
SLIST_INIT(&ccb_freeq);
|
|
|
|
STAILQ_INIT(&highpowerq);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The xpt layer is, itself, the equivelent of a SIM.
|
|
|
|
* Allow 16 ccbs in the ccb pool for it. This should
|
|
|
|
* give decent parallelism when we probe busses and
|
|
|
|
* perform other XPT functions.
|
|
|
|
*/
|
|
|
|
xpt_sim = (struct cam_sim *)malloc(sizeof(*xpt_sim),
|
|
|
|
M_DEVBUF, M_WAITOK);
|
|
|
|
xpt_sim->sim_action = xptaction;
|
|
|
|
xpt_sim->sim_name = "xpt";
|
|
|
|
xpt_sim->path_id = CAM_XPT_PATH_ID;
|
|
|
|
xpt_sim->bus_id = 0;
|
|
|
|
xpt_sim->max_tagged_dev_openings = 0;
|
|
|
|
xpt_sim->max_dev_openings = 0;
|
|
|
|
xpt_sim->devq = cam_simq_alloc(16);
|
|
|
|
xpt_max_ccbs = 16;
|
|
|
|
|
|
|
|
xpt_bus_register(xpt_sim, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Looking at the XPT from the SIM layer, the XPT is
|
|
|
|
* the equivelent of a peripheral driver. Allocate
|
|
|
|
* a peripheral driver entry for us.
|
|
|
|
*/
|
|
|
|
if ((status = xpt_create_path(&path, NULL, CAM_XPT_PATH_ID,
|
|
|
|
CAM_TARGET_WILDCARD,
|
|
|
|
CAM_LUN_WILDCARD)) != CAM_REQ_CMP) {
|
|
|
|
printf("xpt_init: xpt_create_path failed with status %#x,"
|
|
|
|
" failing attach\n", status);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
Fix a problem with the way we handled device invalidation when attaching
to a device failed.
In theory, the same steps that happen when we get an AC_LOST_DEVICE async
notification should have been taken when a driver fails to attach. In
practice, that wasn't the case.
This only affected the da, cd and ch drivers, but the fix affects all
peripheral drivers.
There were several possible problems:
- In the da driver, we didn't remove the peripheral's softc from the da
driver's linked list of softcs. Once the peripheral and softc got
removed, we'd get a kernel panic the next time the timeout routine
called dasendorderedtag().
- In the da, cd and possibly ch drivers, we didn't remove the
peripheral's devstat structure from the devstat queue. Once the
peripheral and softc were removed, this could cause a panic if anyone
tried to access device statistics. (one component of the linked list
wouldn't exist anymore)
- In the cd driver, we didn't take the peripheral off the changer run
queue if it was scheduled to run. In practice, it's highly unlikely,
and maybe impossible that the peripheral would have been on the
changer run queue at that stage of the probe process.
The fix is:
- Add a new peripheral callback function (the "oninvalidate" function)
that is called the first time cam_periph_invalidate() is called for a
peripheral.
- Create new foooninvalidate() routines for each peripheral driver. This
routine is always called at splsoftcam(), and contains all the stuff
that used to be in the AC_LOST_DEVICE case of the async callback
handler.
- Move the devstat cleanup call to the destructor/cleanup routines, since
some of the drivers do I/O in their close routines.
- Make sure that when we're flushing the buffer queue, we traverse it at
splbio().
- Add a check for the invalid flag in the pt driver's open routine.
Reviewed by: gibbs
1998-10-22 22:16:56 +00:00
|
|
|
cam_periph_alloc(xptregister, NULL, NULL, NULL, "xpt", CAM_PERIPH_BIO,
|
1998-09-15 06:33:23 +00:00
|
|
|
path, NULL, 0, NULL);
|
|
|
|
xpt_free_path(path);
|
|
|
|
|
|
|
|
xpt_sim->softc = xpt_periph;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Register a callback for when interrupts are enabled.
|
|
|
|
*/
|
|
|
|
xpt_config_hook =
|
|
|
|
(struct intr_config_hook *)malloc(sizeof(struct intr_config_hook),
|
|
|
|
M_TEMP, M_NOWAIT);
|
|
|
|
if (xpt_config_hook == NULL) {
|
|
|
|
printf("xpt_init: Cannot malloc config hook "
|
|
|
|
"- failing attach\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
bzero(xpt_config_hook, sizeof(*xpt_config_hook));
|
|
|
|
|
|
|
|
xpt_config_hook->ich_func = xpt_config;
|
|
|
|
if (config_intrhook_establish(xpt_config_hook) != 0) {
|
|
|
|
free (xpt_config_hook, M_TEMP);
|
|
|
|
printf("xpt_init: config_intrhook_establish failed "
|
|
|
|
"- failing attach\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Install our software interrupt handlers */
|
|
|
|
/* XXX Should call some MI function to do this */
|
1998-09-16 23:30:11 +00:00
|
|
|
#ifdef __i386__
|
1998-09-15 06:33:23 +00:00
|
|
|
ihandlers[SWI_CAMNET] = swi_camnet;
|
|
|
|
ihandlers[SWI_CAMBIO] = swi_cambio;
|
1998-09-16 23:30:11 +00:00
|
|
|
#endif
|
1998-09-15 06:33:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static cam_status
|
|
|
|
xptregister(struct cam_periph *periph, void *arg)
|
|
|
|
{
|
|
|
|
if (periph == NULL) {
|
|
|
|
printf("xptregister: periph was NULL!!\n");
|
|
|
|
return(CAM_REQ_CMP_ERR);
|
|
|
|
}
|
|
|
|
|
|
|
|
periph->softc = NULL;
|
|
|
|
|
|
|
|
xpt_periph = periph;
|
|
|
|
|
|
|
|
return(CAM_REQ_CMP);
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t
|
|
|
|
xpt_add_periph(struct cam_periph *periph)
|
|
|
|
{
|
|
|
|
struct cam_ed *device;
|
|
|
|
int32_t status;
|
|
|
|
struct periph_list *periph_head;
|
|
|
|
|
|
|
|
device = periph->path->device;
|
|
|
|
|
|
|
|
periph_head = &device->periphs;
|
|
|
|
|
|
|
|
status = CAM_REQ_CMP;
|
|
|
|
|
|
|
|
if (device != NULL) {
|
|
|
|
int s;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make room for this peripheral
|
|
|
|
* so it will fit in the queue
|
|
|
|
* when it's scheduled to run
|
|
|
|
*/
|
|
|
|
s = splsoftcam();
|
|
|
|
status = camq_resize(&device->drvq,
|
|
|
|
device->drvq.array_size + 1);
|
|
|
|
|
|
|
|
device->generation++;
|
|
|
|
|
|
|
|
SLIST_INSERT_HEAD(periph_head, periph, periph_links);
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
xsoftc.generation++;
|
|
|
|
|
|
|
|
return (status);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_remove_periph(struct cam_periph *periph)
|
|
|
|
{
|
|
|
|
struct cam_ed *device;
|
|
|
|
|
|
|
|
device = periph->path->device;
|
|
|
|
|
|
|
|
if (device != NULL) {
|
|
|
|
int s;
|
|
|
|
struct periph_list *periph_head;
|
|
|
|
|
|
|
|
periph_head = &device->periphs;
|
|
|
|
|
|
|
|
/* Release the slot for this peripheral */
|
|
|
|
s = splsoftcam();
|
|
|
|
camq_resize(&device->drvq, device->drvq.array_size - 1);
|
|
|
|
|
|
|
|
device->generation++;
|
|
|
|
|
|
|
|
SLIST_REMOVE(periph_head, periph, cam_periph, periph_links);
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
xsoftc.generation++;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_announce_periph(struct cam_periph *periph, char *announce_string)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
u_int mb;
|
|
|
|
struct cam_path *path;
|
|
|
|
struct ccb_trans_settings cts;
|
|
|
|
|
|
|
|
path = periph->path;
|
|
|
|
/*
|
|
|
|
* To ensure that this is printed in one piece,
|
|
|
|
* mask out CAM interrupts.
|
|
|
|
*/
|
|
|
|
s = splsoftcam();
|
|
|
|
printf("%s%d at %s%d bus %d target %d lun %d\n",
|
|
|
|
periph->periph_name, periph->unit_number,
|
|
|
|
path->bus->sim->sim_name,
|
|
|
|
path->bus->sim->unit_number,
|
|
|
|
path->bus->sim->bus_id,
|
|
|
|
path->target->target_id,
|
|
|
|
path->device->lun_id);
|
|
|
|
printf("%s%d: ", periph->periph_name, periph->unit_number);
|
|
|
|
scsi_print_inquiry(&path->device->inq_data);
|
|
|
|
if ((bootverbose)
|
|
|
|
&& (path->device->serial_num_len > 0)) {
|
|
|
|
/* Don't wrap the screen - print only the first 60 chars */
|
|
|
|
printf("%s%d: Serial Number %.60s\n", periph->periph_name,
|
|
|
|
periph->unit_number, path->device->serial_num);
|
|
|
|
}
|
|
|
|
xpt_setup_ccb(&cts.ccb_h, path, /*priority*/1);
|
|
|
|
cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
|
|
|
|
cts.flags = CCB_TRANS_CURRENT_SETTINGS;
|
|
|
|
xpt_action((union ccb*)&cts);
|
|
|
|
if (cts.ccb_h.status == CAM_REQ_CMP) {
|
|
|
|
u_int speed;
|
|
|
|
u_int freq;
|
|
|
|
|
|
|
|
if ((cts.valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0
|
|
|
|
&& cts.sync_offset != 0) {
|
|
|
|
freq = scsi_calc_syncsrate(cts.sync_period);
|
|
|
|
speed = freq;
|
|
|
|
} else {
|
|
|
|
freq = 0;
|
|
|
|
speed = path->bus->sim->base_transfer_speed;
|
|
|
|
}
|
|
|
|
if ((cts.valid & CCB_TRANS_BUS_WIDTH_VALID) != 0)
|
|
|
|
speed *= (0x01 << cts.bus_width);
|
|
|
|
mb = speed / 1000;
|
|
|
|
if (mb > 0)
|
|
|
|
printf("%s%d: %d.%dMB/s transfers", periph->periph_name,
|
|
|
|
periph->unit_number, mb, speed % 1000);
|
|
|
|
else
|
|
|
|
printf("%s%d: %dKB/s transfers", periph->periph_name,
|
|
|
|
periph->unit_number, (speed % 1000) * 1000);
|
|
|
|
if ((cts.valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0
|
|
|
|
&& cts.sync_offset != 0) {
|
|
|
|
printf(" (%d.%dMHz, offset %d", freq / 1000,
|
|
|
|
freq % 1000, cts.sync_offset);
|
|
|
|
}
|
|
|
|
if ((cts.valid & CCB_TRANS_BUS_WIDTH_VALID) != 0
|
|
|
|
&& cts.bus_width > 0) {
|
|
|
|
if ((cts.valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0
|
|
|
|
&& cts.sync_offset != 0) {
|
|
|
|
printf(", ");
|
|
|
|
} else {
|
|
|
|
printf(" (");
|
|
|
|
}
|
|
|
|
printf("%dbit)", 8 * (0x01 << cts.bus_width));
|
|
|
|
} else if ((cts.valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0
|
|
|
|
&& cts.sync_offset != 0) {
|
|
|
|
printf(")");
|
|
|
|
}
|
1998-09-23 03:03:19 +00:00
|
|
|
|
|
|
|
if (path->device->inq_flags & SID_CmdQue
|
|
|
|
|| path->device->flags & CAM_DEV_TAG_AFTER_COUNT) {
|
1998-09-15 06:33:23 +00:00
|
|
|
printf(", Tagged Queueing Enabled");
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("\n");
|
1998-10-07 03:25:21 +00:00
|
|
|
} else if (path->device->inq_flags & SID_CmdQue
|
|
|
|
|| path->device->flags & CAM_DEV_TAG_AFTER_COUNT) {
|
1998-09-15 06:33:23 +00:00
|
|
|
printf("%s%d: Tagged Queueing Enabled\n",
|
|
|
|
periph->periph_name, periph->unit_number);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only want to print the caller's announce string if they've
|
|
|
|
* passed one in..
|
|
|
|
*/
|
|
|
|
if (announce_string != NULL)
|
|
|
|
printf("%s%d: %s\n", periph->periph_name,
|
|
|
|
periph->unit_number, announce_string);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static dev_match_ret
|
|
|
|
xptbusmatch(struct dev_match_pattern *patterns, int num_patterns,
|
|
|
|
struct cam_eb *bus)
|
|
|
|
{
|
|
|
|
dev_match_ret retval;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
retval = DM_RET_NONE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we aren't given something to match against, that's an error.
|
|
|
|
*/
|
|
|
|
if (bus == NULL)
|
|
|
|
return(DM_RET_ERROR);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are no match entries, then this bus matches no
|
|
|
|
* matter what.
|
|
|
|
*/
|
|
|
|
if ((patterns == NULL) || (num_patterns == 0))
|
|
|
|
return(DM_RET_DESCEND | DM_RET_COPY);
|
|
|
|
|
|
|
|
for (i = 0; i < num_patterns; i++) {
|
|
|
|
struct bus_match_pattern *cur_pattern;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the pattern in question isn't for a bus node, we
|
|
|
|
* aren't interested. However, we do indicate to the
|
|
|
|
* calling routine that we should continue descending the
|
|
|
|
* tree, since the user wants to match against lower-level
|
|
|
|
* EDT elements.
|
|
|
|
*/
|
|
|
|
if (patterns[i].type != DEV_MATCH_BUS) {
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_NONE)
|
|
|
|
retval |= DM_RET_DESCEND;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
cur_pattern = &patterns[i].pattern.bus_pattern;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If they want to match any bus node, we give them any
|
|
|
|
* device node.
|
|
|
|
*/
|
|
|
|
if (cur_pattern->flags == BUS_MATCH_ANY) {
|
|
|
|
/* set the copy flag */
|
|
|
|
retval |= DM_RET_COPY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we've already decided on an action, go ahead
|
|
|
|
* and return.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) != DM_RET_NONE)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Not sure why someone would do this...
|
|
|
|
*/
|
|
|
|
if (cur_pattern->flags == BUS_MATCH_NONE)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & BUS_MATCH_PATH) != 0)
|
|
|
|
&& (cur_pattern->path_id != bus->path_id))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & BUS_MATCH_BUS_ID) != 0)
|
|
|
|
&& (cur_pattern->bus_id != bus->sim->bus_id))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & BUS_MATCH_UNIT) != 0)
|
|
|
|
&& (cur_pattern->unit_number != bus->sim->unit_number))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & BUS_MATCH_NAME) != 0)
|
|
|
|
&& (strncmp(cur_pattern->dev_name, bus->sim->sim_name,
|
|
|
|
DEV_IDLEN) != 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get to this point, the user definitely wants
|
|
|
|
* information on this bus. So tell the caller to copy the
|
|
|
|
* data out.
|
|
|
|
*/
|
|
|
|
retval |= DM_RET_COPY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the return action has been set to descend, then we
|
|
|
|
* know that we've already seen a non-bus matching
|
|
|
|
* expression, therefore we need to further descend the tree.
|
|
|
|
* This won't change by continuing around the loop, so we
|
|
|
|
* go ahead and return. If we haven't seen a non-bus
|
|
|
|
* matching expression, we keep going around the loop until
|
|
|
|
* we exhaust the matching expressions. We'll set the stop
|
|
|
|
* flag once we fall out of the loop.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_DESCEND)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the return action hasn't been set to descend yet, that means
|
|
|
|
* we haven't seen anything other than bus matching patterns. So
|
|
|
|
* tell the caller to stop descending the tree -- the user doesn't
|
|
|
|
* want to match against lower level tree elements.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_NONE)
|
|
|
|
retval |= DM_RET_STOP;
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static dev_match_ret
|
|
|
|
xptdevicematch(struct dev_match_pattern *patterns, int num_patterns,
|
|
|
|
struct cam_ed *device)
|
|
|
|
{
|
|
|
|
dev_match_ret retval;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
retval = DM_RET_NONE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we aren't given something to match against, that's an error.
|
|
|
|
*/
|
|
|
|
if (device == NULL)
|
|
|
|
return(DM_RET_ERROR);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are no match entries, then this device matches no
|
|
|
|
* matter what.
|
|
|
|
*/
|
|
|
|
if ((patterns == NULL) || (patterns == 0))
|
|
|
|
return(DM_RET_DESCEND | DM_RET_COPY);
|
|
|
|
|
|
|
|
for (i = 0; i < num_patterns; i++) {
|
|
|
|
struct device_match_pattern *cur_pattern;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the pattern in question isn't for a device node, we
|
|
|
|
* aren't interested.
|
|
|
|
*/
|
|
|
|
if (patterns[i].type != DEV_MATCH_DEVICE) {
|
|
|
|
if ((patterns[i].type == DEV_MATCH_PERIPH)
|
|
|
|
&& ((retval & DM_RET_ACTION_MASK) == DM_RET_NONE))
|
|
|
|
retval |= DM_RET_DESCEND;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
cur_pattern = &patterns[i].pattern.device_pattern;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If they want to match any device node, we give them any
|
|
|
|
* device node.
|
|
|
|
*/
|
|
|
|
if (cur_pattern->flags == DEV_MATCH_ANY) {
|
|
|
|
/* set the copy flag */
|
|
|
|
retval |= DM_RET_COPY;
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we've already decided on an action, go ahead
|
|
|
|
* and return.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) != DM_RET_NONE)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Not sure why someone would do this...
|
|
|
|
*/
|
|
|
|
if (cur_pattern->flags == DEV_MATCH_NONE)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & DEV_MATCH_PATH) != 0)
|
|
|
|
&& (cur_pattern->path_id != device->target->bus->path_id))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & DEV_MATCH_TARGET) != 0)
|
|
|
|
&& (cur_pattern->target_id != device->target->target_id))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & DEV_MATCH_LUN) != 0)
|
|
|
|
&& (cur_pattern->target_lun != device->lun_id))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & DEV_MATCH_INQUIRY) != 0)
|
|
|
|
&& (cam_quirkmatch((caddr_t)&device->inq_data,
|
|
|
|
(caddr_t)&cur_pattern->inq_pat,
|
|
|
|
1, sizeof(cur_pattern->inq_pat),
|
|
|
|
scsi_static_inquiry_match) == NULL))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get to this point, the user definitely wants
|
|
|
|
* information on this device. So tell the caller to copy
|
|
|
|
* the data out.
|
|
|
|
*/
|
|
|
|
retval |= DM_RET_COPY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the return action has been set to descend, then we
|
|
|
|
* know that we've already seen a peripheral matching
|
|
|
|
* expression, therefore we need to further descend the tree.
|
|
|
|
* This won't change by continuing around the loop, so we
|
|
|
|
* go ahead and return. If we haven't seen a peripheral
|
|
|
|
* matching expression, we keep going around the loop until
|
|
|
|
* we exhaust the matching expressions. We'll set the stop
|
|
|
|
* flag once we fall out of the loop.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_DESCEND)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the return action hasn't been set to descend yet, that means
|
|
|
|
* we haven't seen any peripheral matching patterns. So tell the
|
|
|
|
* caller to stop descending the tree -- the user doesn't want to
|
|
|
|
* match against lower level tree elements.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_NONE)
|
|
|
|
retval |= DM_RET_STOP;
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Match a single peripheral against any number of match patterns.
|
|
|
|
*/
|
|
|
|
static dev_match_ret
|
|
|
|
xptperiphmatch(struct dev_match_pattern *patterns, int num_patterns,
|
|
|
|
struct cam_periph *periph)
|
|
|
|
{
|
|
|
|
dev_match_ret retval;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we aren't given something to match against, that's an error.
|
|
|
|
*/
|
|
|
|
if (periph == NULL)
|
|
|
|
return(DM_RET_ERROR);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are no match entries, then this peripheral matches no
|
|
|
|
* matter what.
|
|
|
|
*/
|
|
|
|
if ((patterns == NULL) || (num_patterns == 0))
|
|
|
|
return(DM_RET_STOP | DM_RET_COPY);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There aren't any nodes below a peripheral node, so there's no
|
|
|
|
* reason to descend the tree any further.
|
|
|
|
*/
|
|
|
|
retval = DM_RET_STOP;
|
|
|
|
|
|
|
|
for (i = 0; i < num_patterns; i++) {
|
|
|
|
struct periph_match_pattern *cur_pattern;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the pattern in question isn't for a peripheral, we
|
|
|
|
* aren't interested.
|
|
|
|
*/
|
|
|
|
if (patterns[i].type != DEV_MATCH_PERIPH)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cur_pattern = &patterns[i].pattern.periph_pattern;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If they want to match on anything, then we will do so.
|
|
|
|
*/
|
|
|
|
if (cur_pattern->flags == PERIPH_MATCH_ANY) {
|
|
|
|
/* set the copy flag */
|
|
|
|
retval |= DM_RET_COPY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We've already set the return action to stop,
|
|
|
|
* since there are no nodes below peripherals in
|
|
|
|
* the tree.
|
|
|
|
*/
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Not sure why someone would do this...
|
|
|
|
*/
|
|
|
|
if (cur_pattern->flags == PERIPH_MATCH_NONE)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & PERIPH_MATCH_PATH) != 0)
|
|
|
|
&& (cur_pattern->path_id != periph->path->bus->path_id))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For the target and lun id's, we have to make sure the
|
|
|
|
* target and lun pointers aren't NULL. The xpt peripheral
|
|
|
|
* has a wildcard target and device.
|
|
|
|
*/
|
|
|
|
if (((cur_pattern->flags & PERIPH_MATCH_TARGET) != 0)
|
|
|
|
&& ((periph->path->target == NULL)
|
|
|
|
||(cur_pattern->target_id != periph->path->target->target_id)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & PERIPH_MATCH_LUN) != 0)
|
|
|
|
&& ((periph->path->device == NULL)
|
|
|
|
|| (cur_pattern->target_lun != periph->path->device->lun_id)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & PERIPH_MATCH_UNIT) != 0)
|
|
|
|
&& (cur_pattern->unit_number != periph->unit_number))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (((cur_pattern->flags & PERIPH_MATCH_NAME) != 0)
|
|
|
|
&& (strncmp(cur_pattern->periph_name, periph->periph_name,
|
|
|
|
DEV_IDLEN) != 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get to this point, the user definitely wants
|
|
|
|
* information on this peripheral. So tell the caller to
|
|
|
|
* copy the data out.
|
|
|
|
*/
|
|
|
|
retval |= DM_RET_COPY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The return action has already been set to stop, since
|
|
|
|
* peripherals don't have any nodes below them in the EDT.
|
|
|
|
*/
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get to this point, the peripheral that was passed in
|
|
|
|
* doesn't match any of the patterns.
|
|
|
|
*/
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptedtbusfunc(struct cam_eb *bus, void *arg)
|
|
|
|
{
|
|
|
|
struct ccb_dev_match *cdm;
|
|
|
|
dev_match_ret retval;
|
|
|
|
|
|
|
|
cdm = (struct ccb_dev_match *)arg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If our position is for something deeper in the tree, that means
|
|
|
|
* that we've already seen this node. So, we keep going down.
|
|
|
|
*/
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (cdm->pos.cookie.bus == bus)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_TARGET)
|
|
|
|
&& (cdm->pos.cookie.target != NULL))
|
|
|
|
retval = DM_RET_DESCEND;
|
|
|
|
else
|
|
|
|
retval = xptbusmatch(cdm->patterns, cdm->num_patterns, bus);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we got an error, bail out of the search.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_ERROR) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_ERROR;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the copy flag is set, copy this bus out.
|
|
|
|
*/
|
|
|
|
if (retval & DM_RET_COPY) {
|
|
|
|
int spaceleft, j;
|
|
|
|
|
|
|
|
spaceleft = cdm->match_buf_len - (cdm->num_matches *
|
|
|
|
sizeof(struct dev_match_result));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we don't have enough space to put in another
|
|
|
|
* match result, save our position and tell the
|
|
|
|
* user there are more devices to check.
|
|
|
|
*/
|
|
|
|
if (spaceleft < sizeof(struct dev_match_result)) {
|
|
|
|
bzero(&cdm->pos, sizeof(cdm->pos));
|
|
|
|
cdm->pos.position_type =
|
|
|
|
CAM_DEV_POS_EDT | CAM_DEV_POS_BUS;
|
|
|
|
|
|
|
|
cdm->pos.cookie.bus = bus;
|
|
|
|
cdm->pos.generations[CAM_BUS_GENERATION]=
|
|
|
|
bus_generation;
|
|
|
|
cdm->status = CAM_DEV_MATCH_MORE;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
j = cdm->num_matches;
|
|
|
|
cdm->num_matches++;
|
|
|
|
cdm->matches[j].type = DEV_MATCH_BUS;
|
|
|
|
cdm->matches[j].result.bus_result.path_id = bus->path_id;
|
|
|
|
cdm->matches[j].result.bus_result.bus_id = bus->sim->bus_id;
|
|
|
|
cdm->matches[j].result.bus_result.unit_number =
|
|
|
|
bus->sim->unit_number;
|
|
|
|
strncpy(cdm->matches[j].result.bus_result.dev_name,
|
|
|
|
bus->sim->sim_name, DEV_IDLEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the user is only interested in busses, there's no
|
|
|
|
* reason to descend to the next level in the tree.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_STOP)
|
|
|
|
return(1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a target generation recorded, check it to
|
|
|
|
* make sure the target list hasn't changed.
|
|
|
|
*/
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (bus == cdm->pos.cookie.bus)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_TARGET)
|
|
|
|
&& (cdm->pos.generations[CAM_TARGET_GENERATION] != 0)
|
|
|
|
&& (cdm->pos.generations[CAM_TARGET_GENERATION] !=
|
|
|
|
bus->generation)) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_LIST_CHANGED;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (cdm->pos.cookie.bus == bus)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_TARGET)
|
|
|
|
&& (cdm->pos.cookie.target != NULL))
|
|
|
|
return(xpttargettraverse(bus,
|
|
|
|
(struct cam_et *)cdm->pos.cookie.target,
|
|
|
|
xptedttargetfunc, arg));
|
|
|
|
else
|
|
|
|
return(xpttargettraverse(bus, NULL, xptedttargetfunc, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptedttargetfunc(struct cam_et *target, void *arg)
|
|
|
|
{
|
|
|
|
struct ccb_dev_match *cdm;
|
|
|
|
|
|
|
|
cdm = (struct ccb_dev_match *)arg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a device list generation recorded, check it to
|
|
|
|
* make sure the device list hasn't changed.
|
|
|
|
*/
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (cdm->pos.cookie.bus == target->bus)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_TARGET)
|
|
|
|
&& (cdm->pos.cookie.target == target)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_DEVICE)
|
|
|
|
&& (cdm->pos.generations[CAM_DEV_GENERATION] != 0)
|
|
|
|
&& (cdm->pos.generations[CAM_DEV_GENERATION] !=
|
|
|
|
target->generation)) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_LIST_CHANGED;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (cdm->pos.cookie.bus == target->bus)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_TARGET)
|
|
|
|
&& (cdm->pos.cookie.target == target)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_DEVICE)
|
|
|
|
&& (cdm->pos.cookie.device != NULL))
|
|
|
|
return(xptdevicetraverse(target,
|
|
|
|
(struct cam_ed *)cdm->pos.cookie.device,
|
|
|
|
xptedtdevicefunc, arg));
|
|
|
|
else
|
|
|
|
return(xptdevicetraverse(target, NULL, xptedtdevicefunc, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptedtdevicefunc(struct cam_ed *device, void *arg)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct ccb_dev_match *cdm;
|
|
|
|
dev_match_ret retval;
|
|
|
|
|
|
|
|
cdm = (struct ccb_dev_match *)arg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If our position is for something deeper in the tree, that means
|
|
|
|
* that we've already seen this node. So, we keep going down.
|
|
|
|
*/
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_DEVICE)
|
|
|
|
&& (cdm->pos.cookie.device == device)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_PERIPH)
|
|
|
|
&& (cdm->pos.cookie.periph != NULL))
|
|
|
|
retval = DM_RET_DESCEND;
|
|
|
|
else
|
|
|
|
retval = xptdevicematch(cdm->patterns, cdm->num_patterns,
|
|
|
|
device);
|
|
|
|
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_ERROR) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_ERROR;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the copy flag is set, copy this device out.
|
|
|
|
*/
|
|
|
|
if (retval & DM_RET_COPY) {
|
|
|
|
int spaceleft, j;
|
|
|
|
|
|
|
|
spaceleft = cdm->match_buf_len - (cdm->num_matches *
|
|
|
|
sizeof(struct dev_match_result));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we don't have enough space to put in another
|
|
|
|
* match result, save our position and tell the
|
|
|
|
* user there are more devices to check.
|
|
|
|
*/
|
|
|
|
if (spaceleft < sizeof(struct dev_match_result)) {
|
|
|
|
bzero(&cdm->pos, sizeof(cdm->pos));
|
|
|
|
cdm->pos.position_type =
|
|
|
|
CAM_DEV_POS_EDT | CAM_DEV_POS_BUS |
|
|
|
|
CAM_DEV_POS_TARGET | CAM_DEV_POS_DEVICE;
|
|
|
|
|
|
|
|
cdm->pos.cookie.bus = device->target->bus;
|
|
|
|
cdm->pos.generations[CAM_BUS_GENERATION]=
|
|
|
|
bus_generation;
|
|
|
|
cdm->pos.cookie.target = device->target;
|
|
|
|
cdm->pos.generations[CAM_TARGET_GENERATION] =
|
|
|
|
device->target->bus->generation;
|
|
|
|
cdm->pos.cookie.device = device;
|
|
|
|
cdm->pos.generations[CAM_DEV_GENERATION] =
|
|
|
|
device->target->generation;
|
|
|
|
cdm->status = CAM_DEV_MATCH_MORE;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
j = cdm->num_matches;
|
|
|
|
cdm->num_matches++;
|
|
|
|
cdm->matches[j].type = DEV_MATCH_DEVICE;
|
|
|
|
cdm->matches[j].result.device_result.path_id =
|
|
|
|
device->target->bus->path_id;
|
|
|
|
cdm->matches[j].result.device_result.target_id =
|
|
|
|
device->target->target_id;
|
|
|
|
cdm->matches[j].result.device_result.target_lun =
|
|
|
|
device->lun_id;
|
|
|
|
bcopy(&device->inq_data,
|
|
|
|
&cdm->matches[j].result.device_result.inq_data,
|
|
|
|
sizeof(struct scsi_inquiry_data));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the user isn't interested in peripherals, don't descend
|
|
|
|
* the tree any further.
|
|
|
|
*/
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_STOP)
|
|
|
|
return(1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a peripheral list generation recorded, make sure
|
|
|
|
* it hasn't changed.
|
|
|
|
*/
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (device->target->bus == cdm->pos.cookie.bus)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_TARGET)
|
|
|
|
&& (device->target == cdm->pos.cookie.target)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_DEVICE)
|
|
|
|
&& (device == cdm->pos.cookie.device)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_PERIPH)
|
|
|
|
&& (cdm->pos.generations[CAM_PERIPH_GENERATION] != 0)
|
|
|
|
&& (cdm->pos.generations[CAM_PERIPH_GENERATION] !=
|
|
|
|
device->generation)){
|
|
|
|
cdm->status = CAM_DEV_MATCH_LIST_CHANGED;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (cdm->pos.cookie.bus == device->target->bus)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_TARGET)
|
|
|
|
&& (cdm->pos.cookie.target == device->target)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_DEVICE)
|
|
|
|
&& (cdm->pos.cookie.device == device)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_PERIPH)
|
|
|
|
&& (cdm->pos.cookie.periph != NULL))
|
|
|
|
return(xptperiphtraverse(device,
|
|
|
|
(struct cam_periph *)cdm->pos.cookie.periph,
|
|
|
|
xptedtperiphfunc, arg));
|
|
|
|
else
|
|
|
|
return(xptperiphtraverse(device, NULL, xptedtperiphfunc, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptedtperiphfunc(struct cam_periph *periph, void *arg)
|
|
|
|
{
|
|
|
|
struct ccb_dev_match *cdm;
|
|
|
|
dev_match_ret retval;
|
|
|
|
|
|
|
|
cdm = (struct ccb_dev_match *)arg;
|
|
|
|
|
|
|
|
retval = xptperiphmatch(cdm->patterns, cdm->num_patterns, periph);
|
|
|
|
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_ERROR) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_ERROR;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the copy flag is set, copy this peripheral out.
|
|
|
|
*/
|
|
|
|
if (retval & DM_RET_COPY) {
|
|
|
|
int spaceleft, j;
|
|
|
|
|
|
|
|
spaceleft = cdm->match_buf_len - (cdm->num_matches *
|
|
|
|
sizeof(struct dev_match_result));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we don't have enough space to put in another
|
|
|
|
* match result, save our position and tell the
|
|
|
|
* user there are more devices to check.
|
|
|
|
*/
|
|
|
|
if (spaceleft < sizeof(struct dev_match_result)) {
|
|
|
|
bzero(&cdm->pos, sizeof(cdm->pos));
|
|
|
|
cdm->pos.position_type =
|
|
|
|
CAM_DEV_POS_EDT | CAM_DEV_POS_BUS |
|
|
|
|
CAM_DEV_POS_TARGET | CAM_DEV_POS_DEVICE |
|
|
|
|
CAM_DEV_POS_PERIPH;
|
|
|
|
|
|
|
|
cdm->pos.cookie.bus = periph->path->bus;
|
|
|
|
cdm->pos.generations[CAM_BUS_GENERATION]=
|
|
|
|
bus_generation;
|
|
|
|
cdm->pos.cookie.target = periph->path->target;
|
|
|
|
cdm->pos.generations[CAM_TARGET_GENERATION] =
|
|
|
|
periph->path->bus->generation;
|
|
|
|
cdm->pos.cookie.device = periph->path->device;
|
|
|
|
cdm->pos.generations[CAM_DEV_GENERATION] =
|
|
|
|
periph->path->target->generation;
|
|
|
|
cdm->pos.cookie.periph = periph;
|
|
|
|
cdm->pos.generations[CAM_PERIPH_GENERATION] =
|
|
|
|
periph->path->device->generation;
|
|
|
|
cdm->status = CAM_DEV_MATCH_MORE;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
j = cdm->num_matches;
|
|
|
|
cdm->num_matches++;
|
|
|
|
cdm->matches[j].type = DEV_MATCH_PERIPH;
|
|
|
|
cdm->matches[j].result.periph_result.path_id =
|
|
|
|
periph->path->bus->path_id;
|
|
|
|
cdm->matches[j].result.periph_result.target_id =
|
|
|
|
periph->path->target->target_id;
|
|
|
|
cdm->matches[j].result.periph_result.target_lun =
|
|
|
|
periph->path->device->lun_id;
|
|
|
|
cdm->matches[j].result.periph_result.unit_number =
|
|
|
|
periph->unit_number;
|
|
|
|
strncpy(cdm->matches[j].result.periph_result.periph_name,
|
|
|
|
periph->periph_name, DEV_IDLEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptedtmatch(struct ccb_dev_match *cdm)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
cdm->num_matches = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the bus list generation. If it has changed, the user
|
|
|
|
* needs to reset everything and start over.
|
|
|
|
*/
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (cdm->pos.generations[CAM_BUS_GENERATION] != 0)
|
|
|
|
&& (cdm->pos.generations[CAM_BUS_GENERATION] != bus_generation)) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_LIST_CHANGED;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_BUS)
|
|
|
|
&& (cdm->pos.cookie.bus != NULL))
|
|
|
|
ret = xptbustraverse((struct cam_eb *)cdm->pos.cookie.bus,
|
|
|
|
xptedtbusfunc, cdm);
|
|
|
|
else
|
|
|
|
ret = xptbustraverse(NULL, xptedtbusfunc, cdm);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get back 0, that means that we had to stop before fully
|
|
|
|
* traversing the EDT. It also means that one of the subroutines
|
|
|
|
* has set the status field to the proper value. If we get back 1,
|
|
|
|
* we've fully traversed the EDT and copied out any matching entries.
|
|
|
|
*/
|
|
|
|
if (ret == 1)
|
|
|
|
cdm->status = CAM_DEV_MATCH_LAST;
|
|
|
|
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptplistpdrvfunc(struct periph_driver **pdrv, void *arg)
|
|
|
|
{
|
|
|
|
struct ccb_dev_match *cdm;
|
|
|
|
|
|
|
|
cdm = (struct ccb_dev_match *)arg;
|
|
|
|
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_PDPTR)
|
|
|
|
&& (cdm->pos.cookie.pdrv == pdrv)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_PERIPH)
|
|
|
|
&& (cdm->pos.generations[CAM_PERIPH_GENERATION] != 0)
|
|
|
|
&& (cdm->pos.generations[CAM_PERIPH_GENERATION] !=
|
|
|
|
(*pdrv)->generation)) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_LIST_CHANGED;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_PDPTR)
|
|
|
|
&& (cdm->pos.cookie.pdrv == pdrv)
|
|
|
|
&& (cdm->pos.position_type & CAM_DEV_POS_PERIPH)
|
|
|
|
&& (cdm->pos.cookie.periph != NULL))
|
|
|
|
return(xptpdperiphtraverse(pdrv,
|
|
|
|
(struct cam_periph *)cdm->pos.cookie.periph,
|
|
|
|
xptplistperiphfunc, arg));
|
|
|
|
else
|
|
|
|
return(xptpdperiphtraverse(pdrv, NULL,xptplistperiphfunc, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptplistperiphfunc(struct cam_periph *periph, void *arg)
|
|
|
|
{
|
|
|
|
struct ccb_dev_match *cdm;
|
|
|
|
dev_match_ret retval;
|
|
|
|
|
|
|
|
cdm = (struct ccb_dev_match *)arg;
|
|
|
|
|
|
|
|
retval = xptperiphmatch(cdm->patterns, cdm->num_patterns, periph);
|
|
|
|
|
|
|
|
if ((retval & DM_RET_ACTION_MASK) == DM_RET_ERROR) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_ERROR;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the copy flag is set, copy this peripheral out.
|
|
|
|
*/
|
|
|
|
if (retval & DM_RET_COPY) {
|
|
|
|
int spaceleft, j;
|
|
|
|
|
|
|
|
spaceleft = cdm->match_buf_len - (cdm->num_matches *
|
|
|
|
sizeof(struct dev_match_result));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we don't have enough space to put in another
|
|
|
|
* match result, save our position and tell the
|
|
|
|
* user there are more devices to check.
|
|
|
|
*/
|
|
|
|
if (spaceleft < sizeof(struct dev_match_result)) {
|
|
|
|
struct periph_driver **pdrv;
|
|
|
|
|
|
|
|
pdrv = NULL;
|
|
|
|
bzero(&cdm->pos, sizeof(cdm->pos));
|
|
|
|
cdm->pos.position_type =
|
|
|
|
CAM_DEV_POS_PDRV | CAM_DEV_POS_PDPTR |
|
|
|
|
CAM_DEV_POS_PERIPH;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This may look a bit non-sensical, but it is
|
|
|
|
* actually quite logical. There are very few
|
|
|
|
* peripheral drivers, and bloating every peripheral
|
|
|
|
* structure with a pointer back to its parent
|
|
|
|
* peripheral driver linker set entry would cost
|
|
|
|
* more in the long run than doing this quick lookup.
|
|
|
|
*/
|
|
|
|
for (pdrv =
|
|
|
|
(struct periph_driver **)periphdriver_set.ls_items;
|
|
|
|
*pdrv != NULL; pdrv++) {
|
|
|
|
if (strcmp((*pdrv)->driver_name,
|
|
|
|
periph->periph_name) == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdrv == NULL) {
|
|
|
|
cdm->status = CAM_DEV_MATCH_ERROR;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
cdm->pos.cookie.pdrv = pdrv;
|
|
|
|
/*
|
|
|
|
* The periph generation slot does double duty, as
|
|
|
|
* does the periph pointer slot. They are used for
|
|
|
|
* both edt and pdrv lookups and positioning.
|
|
|
|
*/
|
|
|
|
cdm->pos.cookie.periph = periph;
|
|
|
|
cdm->pos.generations[CAM_PERIPH_GENERATION] =
|
|
|
|
(*pdrv)->generation;
|
|
|
|
cdm->status = CAM_DEV_MATCH_MORE;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
j = cdm->num_matches;
|
|
|
|
cdm->num_matches++;
|
|
|
|
cdm->matches[j].type = DEV_MATCH_PERIPH;
|
|
|
|
cdm->matches[j].result.periph_result.path_id =
|
|
|
|
periph->path->bus->path_id;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The transport layer peripheral doesn't have a target or
|
|
|
|
* lun.
|
|
|
|
*/
|
|
|
|
if (periph->path->target)
|
|
|
|
cdm->matches[j].result.periph_result.target_id =
|
|
|
|
periph->path->target->target_id;
|
|
|
|
else
|
|
|
|
cdm->matches[j].result.periph_result.target_id = -1;
|
|
|
|
|
|
|
|
if (periph->path->device)
|
|
|
|
cdm->matches[j].result.periph_result.target_lun =
|
|
|
|
periph->path->device->lun_id;
|
|
|
|
else
|
|
|
|
cdm->matches[j].result.periph_result.target_lun = -1;
|
|
|
|
|
|
|
|
cdm->matches[j].result.periph_result.unit_number =
|
|
|
|
periph->unit_number;
|
|
|
|
strncpy(cdm->matches[j].result.periph_result.periph_name,
|
|
|
|
periph->periph_name, DEV_IDLEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptperiphlistmatch(struct ccb_dev_match *cdm)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
cdm->num_matches = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point in the edt traversal function, we check the bus
|
|
|
|
* list generation to make sure that no busses have been added or
|
|
|
|
* removed since the user last sent a XPT_DEV_MATCH ccb through.
|
|
|
|
* For the peripheral driver list traversal function, however, we
|
|
|
|
* don't have to worry about new peripheral driver types coming or
|
|
|
|
* going; they're in a linker set, and therefore can't change
|
|
|
|
* without a recompile.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((cdm->pos.position_type & CAM_DEV_POS_PDPTR)
|
|
|
|
&& (cdm->pos.cookie.pdrv != NULL))
|
|
|
|
ret = xptpdrvtraverse(
|
|
|
|
(struct periph_driver **)cdm->pos.cookie.pdrv,
|
|
|
|
xptplistpdrvfunc, cdm);
|
|
|
|
else
|
|
|
|
ret = xptpdrvtraverse(NULL, xptplistpdrvfunc, cdm);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get back 0, that means that we had to stop before fully
|
|
|
|
* traversing the peripheral driver tree. It also means that one of
|
|
|
|
* the subroutines has set the status field to the proper value. If
|
|
|
|
* we get back 1, we've fully traversed the EDT and copied out any
|
|
|
|
* matching entries.
|
|
|
|
*/
|
|
|
|
if (ret == 1)
|
|
|
|
cdm->status = CAM_DEV_MATCH_LAST;
|
|
|
|
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptbustraverse(struct cam_eb *start_bus, xpt_busfunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_eb *bus, *next_bus;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = 1;
|
|
|
|
|
|
|
|
for (bus = (start_bus ? start_bus : TAILQ_FIRST(&xpt_busses));
|
|
|
|
bus != NULL;
|
|
|
|
bus = next_bus) {
|
|
|
|
next_bus = TAILQ_NEXT(bus, links);
|
|
|
|
|
|
|
|
retval = tr_func(bus, arg);
|
|
|
|
if (retval == 0)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xpttargettraverse(struct cam_eb *bus, struct cam_et *start_target,
|
|
|
|
xpt_targetfunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_et *target, *next_target;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = 1;
|
|
|
|
for (target = (start_target ? start_target :
|
|
|
|
TAILQ_FIRST(&bus->et_entries));
|
|
|
|
target != NULL; target = next_target) {
|
|
|
|
|
|
|
|
next_target = TAILQ_NEXT(target, links);
|
|
|
|
|
|
|
|
retval = tr_func(target, arg);
|
|
|
|
|
|
|
|
if (retval == 0)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptdevicetraverse(struct cam_et *target, struct cam_ed *start_device,
|
|
|
|
xpt_devicefunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_ed *device, *next_device;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = 1;
|
|
|
|
for (device = (start_device ? start_device :
|
|
|
|
TAILQ_FIRST(&target->ed_entries));
|
|
|
|
device != NULL;
|
|
|
|
device = next_device) {
|
|
|
|
|
|
|
|
next_device = TAILQ_NEXT(device, links);
|
|
|
|
|
|
|
|
retval = tr_func(device, arg);
|
|
|
|
|
|
|
|
if (retval == 0)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptperiphtraverse(struct cam_ed *device, struct cam_periph *start_periph,
|
|
|
|
xpt_periphfunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_periph *periph, *next_periph;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = 1;
|
|
|
|
|
|
|
|
for (periph = (start_periph ? start_periph :
|
|
|
|
SLIST_FIRST(&device->periphs));
|
|
|
|
periph != NULL;
|
|
|
|
periph = next_periph) {
|
|
|
|
|
|
|
|
next_periph = SLIST_NEXT(periph, periph_links);
|
|
|
|
|
|
|
|
retval = tr_func(periph, arg);
|
|
|
|
if (retval == 0)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptpdrvtraverse(struct periph_driver **start_pdrv,
|
|
|
|
xpt_pdrvfunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct periph_driver **pdrv;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't traverse the peripheral driver list like we do the
|
|
|
|
* other lists, because it is a linker set, and therefore cannot be
|
|
|
|
* changed during runtime. If the peripheral driver list is ever
|
|
|
|
* re-done to be something other than a linker set (i.e. it can
|
|
|
|
* change while the system is running), the list traversal should
|
|
|
|
* be modified to work like the other traversal functions.
|
|
|
|
*/
|
|
|
|
for (pdrv = (start_pdrv ? start_pdrv :
|
|
|
|
(struct periph_driver **)periphdriver_set.ls_items);
|
|
|
|
*pdrv != NULL; pdrv++) {
|
|
|
|
retval = tr_func(pdrv, arg);
|
|
|
|
|
|
|
|
if (retval == 0)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptpdperiphtraverse(struct periph_driver **pdrv,
|
|
|
|
struct cam_periph *start_periph,
|
|
|
|
xpt_periphfunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_periph *periph, *next_periph;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = 1;
|
|
|
|
|
|
|
|
for (periph = (start_periph ? start_periph :
|
|
|
|
TAILQ_FIRST(&(*pdrv)->units)); periph != NULL;
|
|
|
|
periph = next_periph) {
|
|
|
|
|
|
|
|
next_periph = TAILQ_NEXT(periph, unit_links);
|
|
|
|
|
|
|
|
retval = tr_func(periph, arg);
|
|
|
|
if (retval == 0)
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
return(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptdefbusfunc(struct cam_eb *bus, void *arg)
|
|
|
|
{
|
|
|
|
struct xpt_traverse_config *tr_config;
|
|
|
|
|
|
|
|
tr_config = (struct xpt_traverse_config *)arg;
|
|
|
|
|
|
|
|
if (tr_config->depth == XPT_DEPTH_BUS) {
|
|
|
|
xpt_busfunc_t *tr_func;
|
|
|
|
|
|
|
|
tr_func = (xpt_busfunc_t *)tr_config->tr_func;
|
|
|
|
|
|
|
|
return(tr_func(bus, tr_config->tr_arg));
|
|
|
|
} else
|
|
|
|
return(xpttargettraverse(bus, NULL, xptdeftargetfunc, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptdeftargetfunc(struct cam_et *target, void *arg)
|
|
|
|
{
|
|
|
|
struct xpt_traverse_config *tr_config;
|
|
|
|
|
|
|
|
tr_config = (struct xpt_traverse_config *)arg;
|
|
|
|
|
|
|
|
if (tr_config->depth == XPT_DEPTH_TARGET) {
|
|
|
|
xpt_targetfunc_t *tr_func;
|
|
|
|
|
|
|
|
tr_func = (xpt_targetfunc_t *)tr_config->tr_func;
|
|
|
|
|
|
|
|
return(tr_func(target, tr_config->tr_arg));
|
|
|
|
} else
|
|
|
|
return(xptdevicetraverse(target, NULL, xptdefdevicefunc, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptdefdevicefunc(struct cam_ed *device, void *arg)
|
|
|
|
{
|
|
|
|
struct xpt_traverse_config *tr_config;
|
|
|
|
|
|
|
|
tr_config = (struct xpt_traverse_config *)arg;
|
|
|
|
|
|
|
|
if (tr_config->depth == XPT_DEPTH_DEVICE) {
|
|
|
|
xpt_devicefunc_t *tr_func;
|
|
|
|
|
|
|
|
tr_func = (xpt_devicefunc_t *)tr_config->tr_func;
|
|
|
|
|
|
|
|
return(tr_func(device, tr_config->tr_arg));
|
|
|
|
} else
|
|
|
|
return(xptperiphtraverse(device, NULL, xptdefperiphfunc, arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptdefperiphfunc(struct cam_periph *periph, void *arg)
|
|
|
|
{
|
|
|
|
struct xpt_traverse_config *tr_config;
|
|
|
|
xpt_periphfunc_t *tr_func;
|
|
|
|
|
|
|
|
tr_config = (struct xpt_traverse_config *)arg;
|
|
|
|
|
|
|
|
tr_func = (xpt_periphfunc_t *)tr_config->tr_func;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unlike the other default functions, we don't check for depth
|
|
|
|
* here. The peripheral driver level is the last level in the EDT,
|
|
|
|
* so if we're here, we should execute the function in question.
|
|
|
|
*/
|
|
|
|
return(tr_func(periph, tr_config->tr_arg));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Execute the given function for every bus in the EDT.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xpt_for_all_busses(xpt_busfunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct xpt_traverse_config tr_config;
|
|
|
|
|
|
|
|
tr_config.depth = XPT_DEPTH_BUS;
|
|
|
|
tr_config.tr_func = tr_func;
|
|
|
|
tr_config.tr_arg = arg;
|
|
|
|
|
|
|
|
return(xptbustraverse(NULL, xptdefbusfunc, &tr_config));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Execute the given function for every target in the EDT.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xpt_for_all_targets(xpt_targetfunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct xpt_traverse_config tr_config;
|
|
|
|
|
|
|
|
tr_config.depth = XPT_DEPTH_TARGET;
|
|
|
|
tr_config.tr_func = tr_func;
|
|
|
|
tr_config.tr_arg = arg;
|
|
|
|
|
|
|
|
return(xptbustraverse(NULL, xptdefbusfunc, &tr_config));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Execute the given function for every device in the EDT.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xpt_for_all_devices(xpt_devicefunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct xpt_traverse_config tr_config;
|
|
|
|
|
|
|
|
tr_config.depth = XPT_DEPTH_DEVICE;
|
|
|
|
tr_config.tr_func = tr_func;
|
|
|
|
tr_config.tr_arg = arg;
|
|
|
|
|
|
|
|
return(xptbustraverse(NULL, xptdefbusfunc, &tr_config));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Execute the given function for every peripheral in the EDT.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xpt_for_all_periphs(xpt_periphfunc_t *tr_func, void *arg)
|
|
|
|
{
|
|
|
|
struct xpt_traverse_config tr_config;
|
|
|
|
|
|
|
|
tr_config.depth = XPT_DEPTH_PERIPH;
|
|
|
|
tr_config.tr_func = tr_func;
|
|
|
|
tr_config.tr_arg = arg;
|
|
|
|
|
|
|
|
return(xptbustraverse(NULL, xptdefbusfunc, &tr_config));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptsetasyncfunc(struct cam_ed *device, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_path path;
|
|
|
|
struct ccb_getdev cgd;
|
|
|
|
struct async_node *cur_entry;
|
|
|
|
|
|
|
|
cur_entry = (struct async_node *)arg;
|
|
|
|
|
|
|
|
xpt_compile_path(&path,
|
|
|
|
NULL,
|
|
|
|
device->target->bus->path_id,
|
|
|
|
device->target->target_id,
|
|
|
|
device->lun_id);
|
|
|
|
xpt_setup_ccb(&cgd.ccb_h, &path, /*priority*/1);
|
|
|
|
cgd.ccb_h.func_code = XPT_GDEV_TYPE;
|
|
|
|
xpt_action((union ccb *)&cgd);
|
|
|
|
cur_entry->callback(cur_entry->callback_arg,
|
|
|
|
AC_FOUND_DEVICE,
|
|
|
|
&path, &cgd);
|
|
|
|
xpt_release_path(&path);
|
|
|
|
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
static int
|
|
|
|
xptsetasyncbusfunc(struct cam_eb *bus, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_path path;
|
|
|
|
struct ccb_pathinq cpi;
|
|
|
|
struct async_node *cur_entry;
|
|
|
|
|
|
|
|
cur_entry = (struct async_node *)arg;
|
|
|
|
|
|
|
|
xpt_compile_path(&path, /*periph*/NULL,
|
|
|
|
bus->sim->path_id,
|
|
|
|
CAM_TARGET_WILDCARD,
|
|
|
|
CAM_LUN_WILDCARD);
|
|
|
|
xpt_setup_ccb(&cpi.ccb_h, &path, /*priority*/1);
|
|
|
|
cpi.ccb_h.func_code = XPT_PATH_INQ;
|
|
|
|
xpt_action((union ccb *)&cpi);
|
|
|
|
cur_entry->callback(cur_entry->callback_arg,
|
|
|
|
AC_PATH_REGISTERED,
|
|
|
|
&path, &cpi);
|
|
|
|
xpt_release_path(&path);
|
|
|
|
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_action(union ccb *start_ccb)
|
|
|
|
{
|
|
|
|
CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("xpt_action\n"));
|
|
|
|
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_INPROG;
|
|
|
|
|
|
|
|
switch (start_ccb->ccb_h.func_code) {
|
|
|
|
case XPT_SCSI_IO:
|
1998-10-02 21:00:58 +00:00
|
|
|
{
|
|
|
|
#ifdef CAMDEBUG
|
|
|
|
char cdb_str[(SCSI_MAX_CDBLEN * 3) + 1];
|
|
|
|
struct cam_path *path;
|
|
|
|
|
|
|
|
path = start_ccb->ccb_h.path;
|
|
|
|
#endif
|
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
/*
|
|
|
|
* For the sake of compatibility with SCSI-1
|
|
|
|
* devices that may not understand the identify
|
|
|
|
* message, we include lun information in the
|
|
|
|
* second byte of all commands. SCSI-1 specifies
|
|
|
|
* that luns are a 3 bit value and reserves only 3
|
|
|
|
* bits for lun information in the CDB. Later
|
|
|
|
* revisions of the SCSI spec allow for more than 8
|
|
|
|
* luns, but have deprecated lun information in the
|
|
|
|
* CDB. So, if the lun won't fit, we must omit.
|
|
|
|
*
|
|
|
|
* Also be aware that during initial probing for devices,
|
|
|
|
* the inquiry information is unknown but initialized to 0.
|
|
|
|
* This means that this code will be exercised while probing
|
|
|
|
* devices with an ANSI revision greater than 2.
|
|
|
|
*/
|
|
|
|
if (SID_ANSI_REV(&start_ccb->ccb_h.path->device->inq_data) <= 2
|
|
|
|
&& start_ccb->ccb_h.target_lun < 8
|
|
|
|
&& (start_ccb->ccb_h.flags & CAM_CDB_POINTER) == 0) {
|
|
|
|
|
|
|
|
start_ccb->csio.cdb_io.cdb_bytes[1] |=
|
|
|
|
start_ccb->ccb_h.target_lun << 5;
|
|
|
|
}
|
|
|
|
start_ccb->csio.scsi_status = SCSI_STATUS_OK;
|
|
|
|
start_ccb->csio.sense_resid = 0;
|
|
|
|
start_ccb->csio.resid = 0;
|
1998-10-02 21:00:58 +00:00
|
|
|
CAM_DEBUG(path, CAM_DEBUG_CDB,("%s. CDB: %s\n",
|
|
|
|
scsi_op_desc(start_ccb->csio.cdb_io.cdb_bytes[0],
|
|
|
|
&path->device->inq_data),
|
|
|
|
scsi_cdb_string(start_ccb->csio.cdb_io.cdb_bytes,
|
1998-10-15 19:08:58 +00:00
|
|
|
cdb_str, sizeof(cdb_str))));
|
1998-09-15 06:33:23 +00:00
|
|
|
/* FALLTRHOUGH */
|
1998-10-02 21:00:58 +00:00
|
|
|
}
|
1998-09-15 06:33:23 +00:00
|
|
|
case XPT_TARGET_IO:
|
|
|
|
case XPT_CONT_TARGET_IO:
|
|
|
|
case XPT_ENG_EXEC:
|
|
|
|
{
|
|
|
|
struct cam_path *path;
|
|
|
|
int s;
|
|
|
|
int runq;
|
|
|
|
|
|
|
|
path = start_ccb->ccb_h.path;
|
|
|
|
s = splsoftcam();
|
|
|
|
|
|
|
|
cam_ccbq_insert_ccb(&path->device->ccbq, start_ccb);
|
|
|
|
if (path->device->qfrozen_cnt == 0)
|
|
|
|
runq = xpt_schedule_dev_sendq(path->bus, path->device);
|
|
|
|
else
|
|
|
|
runq = 0;
|
|
|
|
splx(s);
|
|
|
|
if (runq != 0)
|
|
|
|
xpt_run_dev_sendq(path->bus);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_SET_TRAN_SETTINGS:
|
|
|
|
{
|
|
|
|
xpt_set_transfer_settings(&start_ccb->cts,
|
1998-09-25 22:35:56 +00:00
|
|
|
start_ccb->ccb_h.path->device,
|
1998-09-15 06:33:23 +00:00
|
|
|
/*async_update*/FALSE);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_CALC_GEOMETRY:
|
|
|
|
/* Filter out garbage */
|
|
|
|
if (start_ccb->ccg.block_size == 0
|
|
|
|
|| start_ccb->ccg.volume_size == 0) {
|
|
|
|
start_ccb->ccg.cylinders = 0;
|
|
|
|
start_ccb->ccg.heads = 0;
|
|
|
|
start_ccb->ccg.secs_per_track = 0;
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#ifdef PC98
|
|
|
|
/*
|
|
|
|
* In a PC-98 system, geometry translation depens on
|
|
|
|
* the "real" device geometry obtained from mode page 4.
|
|
|
|
* SCSI geometry translation is performed in the
|
|
|
|
* initialization routine of the SCSI BIOS and the result
|
|
|
|
* stored in host memory. If the translation is available
|
|
|
|
* in host memory, use it. If not, rely on the default
|
|
|
|
* translation the device driver performs.
|
|
|
|
*/
|
|
|
|
if (scsi_da_bios_params(&start_ccb->ccg) != 0) {
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
#endif
|
1998-12-15 08:13:10 +00:00
|
|
|
case XPT_ABORT:
|
|
|
|
case XPT_RESET_DEV:
|
1998-09-15 06:33:23 +00:00
|
|
|
case XPT_ACCEPT_TARGET_IO:
|
|
|
|
case XPT_EN_LUN:
|
|
|
|
case XPT_IMMED_NOTIFY:
|
|
|
|
case XPT_NOTIFY_ACK:
|
|
|
|
case XPT_GET_TRAN_SETTINGS:
|
|
|
|
case XPT_PATH_INQ:
|
|
|
|
case XPT_RESET_BUS:
|
|
|
|
{
|
|
|
|
struct cam_sim *sim;
|
|
|
|
|
|
|
|
sim = start_ccb->ccb_h.path->bus->sim;
|
|
|
|
(*(sim->sim_action))(sim, start_ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_GDEV_TYPE:
|
|
|
|
if ((start_ccb->ccb_h.path->device->flags & CAM_DEV_UNCONFIGURED) != 0) {
|
|
|
|
start_ccb->ccb_h.status = CAM_DEV_NOT_THERE;
|
|
|
|
} else {
|
|
|
|
struct ccb_getdev *cgd;
|
|
|
|
struct cam_et *tar;
|
|
|
|
struct cam_ed *dev;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splsoftcam();
|
|
|
|
cgd = &start_ccb->cgd;
|
|
|
|
tar = cgd->ccb_h.path->target;
|
|
|
|
dev = cgd->ccb_h.path->device;
|
|
|
|
cgd->inq_data = dev->inq_data;
|
|
|
|
cgd->pd_type = SID_TYPE(&dev->inq_data);
|
|
|
|
cgd->dev_openings = dev->ccbq.dev_openings;
|
|
|
|
cgd->dev_active = dev->ccbq.dev_active;
|
|
|
|
cgd->devq_openings = dev->ccbq.devq_openings;
|
|
|
|
cgd->devq_queued = dev->ccbq.queue.entries;
|
|
|
|
cgd->held = dev->ccbq.held;
|
|
|
|
cgd->maxtags = dev->quirk->maxtags;
|
|
|
|
cgd->mintags = dev->quirk->mintags;
|
|
|
|
cgd->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
cgd->serial_num_len = dev->serial_num_len;
|
|
|
|
if ((dev->serial_num_len > 0)
|
|
|
|
&& (dev->serial_num != NULL))
|
|
|
|
bcopy(dev->serial_num, cgd->serial_num,
|
|
|
|
dev->serial_num_len);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case XPT_GDEVLIST:
|
|
|
|
{
|
|
|
|
struct cam_periph *nperiph;
|
|
|
|
struct periph_list *periph_head;
|
|
|
|
struct ccb_getdevlist *cgdl;
|
|
|
|
int i;
|
|
|
|
int s;
|
|
|
|
struct cam_ed *device;
|
|
|
|
int found;
|
|
|
|
|
|
|
|
|
|
|
|
found = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't want anyone mucking with our data.
|
|
|
|
*/
|
|
|
|
s = splsoftcam();
|
|
|
|
device = start_ccb->ccb_h.path->device;
|
|
|
|
periph_head = &device->periphs;
|
|
|
|
cgdl = &start_ccb->cgdl;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check and see if the list has changed since the user
|
|
|
|
* last requested a list member. If so, tell them that the
|
|
|
|
* list has changed, and therefore they need to start over
|
|
|
|
* from the beginning.
|
|
|
|
*/
|
|
|
|
if ((cgdl->index != 0) &&
|
|
|
|
(cgdl->generation != device->generation)) {
|
|
|
|
cgdl->status = CAM_GDEVLIST_LIST_CHANGED;
|
|
|
|
splx(s);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Traverse the list of peripherals and attempt to find
|
|
|
|
* the requested peripheral.
|
|
|
|
*/
|
|
|
|
for (nperiph = periph_head->slh_first, i = 0;
|
|
|
|
(nperiph != NULL) && (i <= cgdl->index);
|
|
|
|
nperiph = nperiph->periph_links.sle_next, i++) {
|
|
|
|
if (i == cgdl->index) {
|
|
|
|
strncpy(cgdl->periph_name,
|
|
|
|
nperiph->periph_name,
|
|
|
|
DEV_IDLEN);
|
|
|
|
cgdl->unit_number = nperiph->unit_number;
|
|
|
|
found = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found == 0) {
|
|
|
|
cgdl->status = CAM_GDEVLIST_ERROR;
|
|
|
|
splx(s);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nperiph == NULL)
|
|
|
|
cgdl->status = CAM_GDEVLIST_LAST_DEVICE;
|
|
|
|
else
|
|
|
|
cgdl->status = CAM_GDEVLIST_MORE_DEVS;
|
|
|
|
|
|
|
|
cgdl->index++;
|
|
|
|
cgdl->generation = device->generation;
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
cgdl->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_DEV_MATCH:
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
dev_pos_type position_type;
|
|
|
|
struct ccb_dev_match *cdm;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
cdm = &start_ccb->cdm;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prevent EDT changes while we traverse it.
|
|
|
|
*/
|
|
|
|
s = splsoftcam();
|
|
|
|
/*
|
|
|
|
* There are two ways of getting at information in the EDT.
|
|
|
|
* The first way is via the primary EDT tree. It starts
|
|
|
|
* with a list of busses, then a list of targets on a bus,
|
|
|
|
* then devices/luns on a target, and then peripherals on a
|
|
|
|
* device/lun. The "other" way is by the peripheral driver
|
|
|
|
* lists. The peripheral driver lists are organized by
|
|
|
|
* peripheral driver. (obviously) So it makes sense to
|
|
|
|
* use the peripheral driver list if the user is looking
|
|
|
|
* for something like "da1", or all "da" devices. If the
|
|
|
|
* user is looking for something on a particular bus/target
|
|
|
|
* or lun, it's generally better to go through the EDT tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (cdm->pos.position_type != CAM_DEV_POS_NONE)
|
|
|
|
position_type = cdm->pos.position_type;
|
|
|
|
else {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
position_type = CAM_DEV_POS_NONE;
|
|
|
|
|
|
|
|
for (i = 0; i < cdm->num_patterns; i++) {
|
|
|
|
if ((cdm->patterns[i].type == DEV_MATCH_BUS)
|
|
|
|
||(cdm->patterns[i].type == DEV_MATCH_DEVICE)){
|
|
|
|
position_type = CAM_DEV_POS_EDT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cdm->num_patterns == 0)
|
|
|
|
position_type = CAM_DEV_POS_EDT;
|
|
|
|
else if (position_type == CAM_DEV_POS_NONE)
|
|
|
|
position_type = CAM_DEV_POS_PDRV;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(position_type & CAM_DEV_POS_TYPEMASK) {
|
|
|
|
case CAM_DEV_POS_EDT:
|
|
|
|
ret = xptedtmatch(cdm);
|
|
|
|
break;
|
|
|
|
case CAM_DEV_POS_PDRV:
|
|
|
|
ret = xptperiphlistmatch(cdm);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
cdm->status = CAM_DEV_MATCH_ERROR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
if (cdm->status == CAM_DEV_MATCH_ERROR)
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP_ERR;
|
|
|
|
else
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_SASYNC_CB:
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* First off, determine the list we want to
|
|
|
|
* be insterted into.
|
|
|
|
*/
|
|
|
|
struct ccb_setasync *csa;
|
|
|
|
struct async_node *cur_entry;
|
|
|
|
struct async_list *async_head;
|
|
|
|
u_int32_t added;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
csa = &start_ccb->csa;
|
|
|
|
added = csa->event_enable;
|
|
|
|
if (csa->ccb_h.path->device != NULL) {
|
|
|
|
async_head = &csa->ccb_h.path->device->asyncs;
|
|
|
|
} else {
|
|
|
|
async_head = &csa->ccb_h.path->bus->asyncs;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is already an entry for us, simply
|
|
|
|
* update it.
|
|
|
|
*/
|
|
|
|
s = splsoftcam();
|
|
|
|
cur_entry = SLIST_FIRST(async_head);
|
|
|
|
while (cur_entry != NULL) {
|
|
|
|
if ((cur_entry->callback_arg == csa->callback_arg)
|
|
|
|
&& (cur_entry->callback == csa->callback))
|
|
|
|
break;
|
|
|
|
cur_entry = SLIST_NEXT(cur_entry, links);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cur_entry != NULL) {
|
|
|
|
/*
|
|
|
|
* If the request has no flags set,
|
|
|
|
* remove the entry.
|
|
|
|
*/
|
|
|
|
added &= ~cur_entry->event_enable;
|
|
|
|
if (csa->event_enable == 0) {
|
|
|
|
SLIST_REMOVE(async_head, cur_entry,
|
|
|
|
async_node, links);
|
|
|
|
free(cur_entry, M_DEVBUF);
|
|
|
|
} else {
|
|
|
|
cur_entry->event_enable = csa->event_enable;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
cur_entry = malloc(sizeof(*cur_entry), M_DEVBUF,
|
|
|
|
M_NOWAIT);
|
|
|
|
if (cur_entry == NULL) {
|
|
|
|
splx(s);
|
|
|
|
csa->ccb_h.status = CAM_RESRC_UNAVAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
cur_entry->callback_arg = csa->callback_arg;
|
|
|
|
cur_entry->callback = csa->callback;
|
|
|
|
cur_entry->event_enable = csa->event_enable;
|
|
|
|
SLIST_INSERT_HEAD(async_head, cur_entry, links);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((added & AC_FOUND_DEVICE) != 0) {
|
|
|
|
/*
|
|
|
|
* Get this peripheral up to date with all
|
|
|
|
* the currently existing devices.
|
|
|
|
*/
|
|
|
|
xpt_for_all_devices(xptsetasyncfunc, cur_entry);
|
|
|
|
}
|
|
|
|
if ((added & AC_PATH_REGISTERED) != 0) {
|
|
|
|
/*
|
|
|
|
* Get this peripheral up to date with all
|
|
|
|
* the currently existing busses.
|
|
|
|
*/
|
|
|
|
xpt_for_all_busses(xptsetasyncbusfunc, cur_entry);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_REL_SIMQ:
|
|
|
|
{
|
|
|
|
struct ccb_relsim *crs;
|
|
|
|
struct cam_ed *dev;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
crs = &start_ccb->crs;
|
|
|
|
dev = crs->ccb_h.path->device;
|
|
|
|
if (dev == NULL) {
|
|
|
|
|
|
|
|
crs->ccb_h.status = CAM_DEV_NOT_THERE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
|
|
|
|
if ((crs->release_flags & RELSIM_ADJUST_OPENINGS) != 0) {
|
|
|
|
|
|
|
|
if ((dev->inq_data.flags & SID_CmdQue) != 0) {
|
|
|
|
|
|
|
|
/* Don't ever go below one opening */
|
|
|
|
if (crs->openings > 0) {
|
|
|
|
xpt_dev_ccbq_resize(crs->ccb_h.path,
|
|
|
|
crs->openings);
|
|
|
|
|
|
|
|
if (bootverbose || 1) {
|
|
|
|
xpt_print_path(crs->ccb_h.path);
|
|
|
|
printf("tagged openings "
|
|
|
|
"now %d\n",
|
|
|
|
crs->openings);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((crs->release_flags & RELSIM_RELEASE_AFTER_TIMEOUT) != 0) {
|
|
|
|
|
|
|
|
if ((dev->flags & CAM_DEV_REL_TIMEOUT_PENDING) != 0) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Just extend the old timeout and decrement
|
|
|
|
* the freeze count so that a single timeout
|
|
|
|
* is sufficient for releasing the queue.
|
|
|
|
*/
|
|
|
|
start_ccb->ccb_h.flags &= ~CAM_DEV_QFREEZE;
|
|
|
|
untimeout(xpt_release_devq_timeout,
|
|
|
|
dev, dev->c_handle);
|
|
|
|
} else {
|
|
|
|
|
|
|
|
start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->c_handle =
|
|
|
|
timeout(xpt_release_devq_timeout,
|
|
|
|
dev,
|
|
|
|
(crs->release_timeout * hz) / 1000);
|
|
|
|
|
|
|
|
dev->flags |= CAM_DEV_REL_TIMEOUT_PENDING;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((crs->release_flags & RELSIM_RELEASE_AFTER_CMDCMPLT) != 0) {
|
|
|
|
|
|
|
|
if ((dev->flags & CAM_DEV_REL_ON_COMPLETE) != 0) {
|
|
|
|
/*
|
|
|
|
* Decrement the freeze count so that a single
|
|
|
|
* completion is still sufficient to unfreeze
|
|
|
|
* the queue.
|
|
|
|
*/
|
|
|
|
start_ccb->ccb_h.flags &= ~CAM_DEV_QFREEZE;
|
|
|
|
} else {
|
|
|
|
|
|
|
|
dev->flags |= CAM_DEV_REL_ON_COMPLETE;
|
|
|
|
start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((crs->release_flags & RELSIM_RELEASE_AFTER_QEMPTY) != 0) {
|
|
|
|
|
|
|
|
if ((dev->flags & CAM_DEV_REL_ON_QUEUE_EMPTY) != 0
|
|
|
|
|| (dev->ccbq.dev_active == 0)) {
|
|
|
|
|
|
|
|
start_ccb->ccb_h.flags &= ~CAM_DEV_QFREEZE;
|
|
|
|
} else {
|
|
|
|
|
|
|
|
dev->flags |= CAM_DEV_REL_ON_QUEUE_EMPTY;
|
|
|
|
start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
if ((start_ccb->ccb_h.flags & CAM_DEV_QFREEZE) == 0) {
|
|
|
|
|
|
|
|
xpt_release_devq(crs->ccb_h.path->device,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
}
|
|
|
|
start_ccb->crs.qfrozen_cnt = dev->qfrozen_cnt;
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_SCAN_BUS:
|
|
|
|
xpt_scan_bus(start_ccb->ccb_h.path->periph, start_ccb);
|
|
|
|
break;
|
|
|
|
case XPT_SCAN_LUN:
|
|
|
|
xpt_scan_lun(start_ccb->ccb_h.path->periph,
|
|
|
|
start_ccb->ccb_h.path, start_ccb->crcn.flags,
|
|
|
|
start_ccb);
|
|
|
|
break;
|
|
|
|
case XPT_DEBUG: {
|
|
|
|
#ifdef CAMDEBUG
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
cam_dflags = start_ccb->cdbg.flags;
|
|
|
|
if (cam_dpath != NULL) {
|
|
|
|
xpt_free_path(cam_dpath);
|
|
|
|
cam_dpath = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cam_dflags != CAM_DEBUG_NONE) {
|
|
|
|
if (xpt_create_path(&cam_dpath, xpt_periph,
|
|
|
|
start_ccb->ccb_h.path_id,
|
|
|
|
start_ccb->ccb_h.target_id,
|
|
|
|
start_ccb->ccb_h.target_lun) !=
|
|
|
|
CAM_REQ_CMP) {
|
|
|
|
start_ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
|
|
|
|
cam_dflags = CAM_DEBUG_NONE;
|
1998-12-06 00:06:48 +00:00
|
|
|
} else {
|
1998-09-15 06:33:23 +00:00
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP;
|
1998-12-06 00:06:48 +00:00
|
|
|
xpt_print_path(cam_dpath);
|
|
|
|
printf("debugging flags now %x\n", cam_dflags);
|
|
|
|
}
|
1998-09-15 06:33:23 +00:00
|
|
|
} else {
|
|
|
|
cam_dpath = NULL;
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
#else /* !CAMDEBUG */
|
|
|
|
start_ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
|
|
|
|
#endif /* CAMDEBUG */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_NOOP:
|
|
|
|
start_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case XPT_SDEV_TYPE:
|
|
|
|
case XPT_TERM_IO:
|
|
|
|
case XPT_ENG_INQ:
|
|
|
|
/* XXX Implement */
|
|
|
|
start_ccb->ccb_h.status = CAM_PROVIDE_FAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_polled_action(union ccb *start_ccb)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
u_int32_t timeout;
|
|
|
|
struct cam_sim *sim;
|
|
|
|
struct cam_devq *devq;
|
|
|
|
struct cam_ed *dev;
|
|
|
|
|
|
|
|
timeout = start_ccb->ccb_h.timeout;
|
|
|
|
sim = start_ccb->ccb_h.path->bus->sim;
|
|
|
|
devq = sim->devq;
|
|
|
|
dev = start_ccb->ccb_h.path->device;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Steal an opening so that no other queued requests
|
|
|
|
* can get it before us while we simulate interrupts.
|
|
|
|
*/
|
|
|
|
dev->ccbq.devq_openings--;
|
|
|
|
dev->ccbq.dev_openings--;
|
|
|
|
|
|
|
|
while((devq->send_openings <= 0 || dev->ccbq.dev_openings < 0)
|
|
|
|
&& (--timeout > 0)) {
|
|
|
|
DELAY(1000);
|
|
|
|
(*(sim->sim_poll))(sim);
|
|
|
|
swi_camnet();
|
|
|
|
swi_cambio();
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->ccbq.devq_openings++;
|
|
|
|
dev->ccbq.dev_openings++;
|
|
|
|
|
|
|
|
if (timeout != 0) {
|
|
|
|
xpt_action(start_ccb);
|
|
|
|
while(--timeout > 0) {
|
|
|
|
(*(sim->sim_poll))(sim);
|
|
|
|
swi_camnet();
|
|
|
|
swi_cambio();
|
|
|
|
if ((start_ccb->ccb_h.status & CAM_STATUS_MASK)
|
|
|
|
!= CAM_REQ_INPROG)
|
|
|
|
break;
|
|
|
|
DELAY(1000);
|
|
|
|
}
|
|
|
|
if (timeout == 0) {
|
|
|
|
/*
|
|
|
|
* XXX Is it worth adding a sim_timeout entry
|
|
|
|
* point so we can attempt recovery? If
|
|
|
|
* this is only used for dumps, I don't think
|
|
|
|
* it is.
|
|
|
|
*/
|
|
|
|
start_ccb->ccb_h.status = CAM_CMD_TIMEOUT;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
start_ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Schedule a peripheral driver to receive a ccb when it's
|
|
|
|
* target device has space for more transactions.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xpt_schedule(struct cam_periph *perph, u_int32_t new_priority)
|
|
|
|
{
|
|
|
|
struct cam_ed *device;
|
|
|
|
int s;
|
|
|
|
int runq;
|
|
|
|
|
|
|
|
CAM_DEBUG(perph->path, CAM_DEBUG_TRACE, ("xpt_schedule\n"));
|
|
|
|
device = perph->path->device;
|
|
|
|
s = splsoftcam();
|
|
|
|
if (periph_is_queued(perph)) {
|
|
|
|
/* Simply reorder based on new priority */
|
|
|
|
CAM_DEBUG(perph->path, CAM_DEBUG_SUBTRACE,
|
|
|
|
(" change priority to %d\n", new_priority));
|
|
|
|
if (new_priority < perph->pinfo.priority) {
|
|
|
|
camq_change_priority(&device->drvq,
|
|
|
|
perph->pinfo.index,
|
|
|
|
new_priority);
|
|
|
|
}
|
|
|
|
runq = 0;
|
|
|
|
} else {
|
|
|
|
/* New entry on the queue */
|
|
|
|
CAM_DEBUG(perph->path, CAM_DEBUG_SUBTRACE,
|
|
|
|
(" added periph to queue\n"));
|
|
|
|
if (device->drvq.generation++ == 0) {
|
|
|
|
/* Generation wrap, regen all entries */
|
|
|
|
camq_regen(&device->drvq);
|
|
|
|
}
|
|
|
|
perph->pinfo.priority = new_priority;
|
|
|
|
perph->pinfo.generation = device->drvq.generation;
|
|
|
|
camq_insert(&device->drvq, &perph->pinfo);
|
|
|
|
runq = xpt_schedule_dev_allocq(perph->path->bus, device);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
if (runq != 0) {
|
|
|
|
CAM_DEBUG(perph->path, CAM_DEBUG_SUBTRACE,
|
|
|
|
(" calling xpt_run_devq\n"));
|
|
|
|
xpt_run_dev_allocq(perph->path->bus);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Schedule a device to run on a given queue.
|
|
|
|
* If the device was inserted as a new entry on the queue,
|
|
|
|
* return 1 meaning the device queue should be run. If we
|
|
|
|
* were already queued, implying someone else has already
|
|
|
|
* started the queue, return 0 so the caller doesn't attempt
|
|
|
|
* to run the queue. Must be run at either splsoftcam
|
|
|
|
* (or splcam since that encompases splsoftcam).
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xpt_schedule_dev(struct camq *queue, cam_pinfo *pinfo,
|
|
|
|
u_int32_t new_priority)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
u_int32_t old_priority;
|
|
|
|
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_schedule_dev\n"));
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
old_priority = pinfo->priority;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Are we already queued?
|
|
|
|
*/
|
|
|
|
if (pinfo->index != CAM_UNQUEUED_INDEX) {
|
|
|
|
/* Simply reorder based on new priority */
|
|
|
|
if (new_priority < old_priority) {
|
|
|
|
camq_change_priority(queue, pinfo->index,
|
|
|
|
new_priority);
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT,
|
1998-09-15 06:33:23 +00:00
|
|
|
("changed priority to %d\n",
|
|
|
|
new_priority));
|
|
|
|
}
|
|
|
|
retval = 0;
|
|
|
|
} else {
|
|
|
|
/* New entry on the queue */
|
|
|
|
if (new_priority < old_priority)
|
|
|
|
pinfo->priority = new_priority;
|
|
|
|
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT,
|
1998-09-15 06:33:23 +00:00
|
|
|
("Inserting onto queue\n"));
|
|
|
|
if (queue->generation++ == 0) {
|
|
|
|
/* Generation wrap, regen all entries */
|
|
|
|
camq_regen(queue);
|
|
|
|
}
|
|
|
|
pinfo->generation = queue->generation;
|
|
|
|
camq_insert(queue, pinfo);
|
|
|
|
retval = 1;
|
|
|
|
}
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_run_dev_allocq(struct cam_eb *bus)
|
|
|
|
{
|
|
|
|
struct cam_devq *devq;
|
|
|
|
int s;
|
|
|
|
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_run_dev_allocq\n"));
|
1998-09-15 06:33:23 +00:00
|
|
|
devq = bus->sim->devq;
|
|
|
|
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT,
|
1998-09-15 06:33:23 +00:00
|
|
|
(" qfrozen_cnt == 0x%x, entries == %d, "
|
|
|
|
"openings == %d, active == %d\n",
|
|
|
|
devq->alloc_queue.qfrozen_cnt,
|
|
|
|
devq->alloc_queue.entries,
|
|
|
|
devq->alloc_openings,
|
|
|
|
devq->alloc_active));
|
|
|
|
|
|
|
|
s = splsoftcam();
|
|
|
|
devq->alloc_queue.qfrozen_cnt++;
|
|
|
|
while ((devq->alloc_queue.entries > 0)
|
|
|
|
&& (devq->alloc_openings > 0)
|
|
|
|
&& (devq->alloc_queue.qfrozen_cnt <= 1)) {
|
|
|
|
struct cam_ed_qinfo *qinfo;
|
|
|
|
struct cam_ed *device;
|
|
|
|
union ccb *work_ccb;
|
|
|
|
struct cam_periph *drv;
|
|
|
|
struct camq *drvq;
|
|
|
|
|
|
|
|
qinfo = (struct cam_ed_qinfo *)camq_remove(&devq->alloc_queue,
|
|
|
|
/*position*/0);
|
|
|
|
device = qinfo->device;
|
|
|
|
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT,
|
1998-10-15 19:08:58 +00:00
|
|
|
("running device %p\n", device));
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
drvq = &device->drvq;
|
|
|
|
|
|
|
|
#ifdef CAMDEBUG
|
|
|
|
if (drvq->entries <= 0) {
|
|
|
|
panic("xpt_run_dev_allocq: "
|
|
|
|
"Device on queue without any work to do");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if ((work_ccb = xpt_get_ccb(device)) != NULL) {
|
|
|
|
devq->alloc_openings--;
|
|
|
|
devq->alloc_active++;
|
|
|
|
drv = (struct cam_periph*)camq_remove(drvq,
|
|
|
|
/*pos*/0);
|
|
|
|
/* Update priority */
|
|
|
|
if (drvq->entries > 0) {
|
|
|
|
qinfo->pinfo.priority = drvq->queue_array[0]->priority;
|
|
|
|
} else {
|
|
|
|
qinfo->pinfo.priority = CAM_PRIORITY_NONE;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
xpt_setup_ccb(&work_ccb->ccb_h, drv->path,
|
|
|
|
drv->pinfo.priority);
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT,
|
1998-09-15 06:33:23 +00:00
|
|
|
("calling periph start\n"));
|
|
|
|
drv->periph_start(drv, work_ccb);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Malloc failure in alloc_ccb
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* XXX add us to a list to be run from free_ccb
|
|
|
|
* if we don't have any ccbs active on this
|
|
|
|
* device queue otherwise we may never get run
|
|
|
|
* again.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Raise IPL for possible insertion and test at top of loop */
|
|
|
|
s = splsoftcam();
|
|
|
|
|
|
|
|
if (drvq->entries > 0) {
|
|
|
|
/* We have more work. Attempt to reschedule */
|
|
|
|
xpt_schedule_dev_allocq(bus, device);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
devq->alloc_queue.qfrozen_cnt--;
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_run_dev_sendq(struct cam_eb *bus)
|
|
|
|
{
|
|
|
|
struct cam_devq *devq;
|
|
|
|
int s;
|
|
|
|
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_run_dev_sendq\n"));
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
devq = bus->sim->devq;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
devq->send_queue.qfrozen_cnt++;
|
|
|
|
splx(s);
|
|
|
|
s = splsoftcam();
|
|
|
|
while ((devq->send_queue.entries > 0)
|
|
|
|
&& (devq->send_openings > 0)) {
|
|
|
|
struct cam_ed_qinfo *qinfo;
|
|
|
|
struct cam_ed *device;
|
|
|
|
union ccb *work_ccb;
|
|
|
|
struct cam_sim *sim;
|
|
|
|
int ospl;
|
|
|
|
|
|
|
|
ospl = splcam();
|
|
|
|
if (devq->send_queue.qfrozen_cnt > 1) {
|
|
|
|
splx(ospl);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
qinfo = (struct cam_ed_qinfo *)camq_remove(&devq->send_queue,
|
|
|
|
/*position*/0);
|
|
|
|
device = qinfo->device;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the device has been "frozen", don't attempt
|
|
|
|
* to run it.
|
|
|
|
*/
|
|
|
|
if (device->qfrozen_cnt > 0) {
|
|
|
|
splx(ospl);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT,
|
1998-10-15 19:08:58 +00:00
|
|
|
("running device %p\n", device));
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
work_ccb = cam_ccbq_peek_ccb(&device->ccbq, 0);
|
|
|
|
if (work_ccb == NULL) {
|
|
|
|
printf("device on run queue with no ccbs???");
|
|
|
|
splx(ospl);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((work_ccb->ccb_h.flags & CAM_HIGH_POWER) != 0) {
|
|
|
|
|
|
|
|
if (num_highpower <= 0) {
|
|
|
|
/*
|
|
|
|
* We got a high power command, but we
|
|
|
|
* don't have any available slots. Freeze
|
|
|
|
* the device queue until we have a slot
|
|
|
|
* available.
|
|
|
|
*/
|
|
|
|
device->qfrozen_cnt++;
|
|
|
|
STAILQ_INSERT_TAIL(&highpowerq,
|
|
|
|
&work_ccb->ccb_h,
|
|
|
|
xpt_links.stqe);
|
|
|
|
|
|
|
|
splx(ospl);
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Consume a high power slot while
|
|
|
|
* this ccb runs.
|
|
|
|
*/
|
|
|
|
num_highpower--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
devq->active_dev = device;
|
|
|
|
cam_ccbq_remove_ccb(&device->ccbq, work_ccb);
|
|
|
|
|
|
|
|
cam_ccbq_send_ccb(&device->ccbq, work_ccb);
|
|
|
|
splx(ospl);
|
|
|
|
|
|
|
|
devq->send_openings--;
|
|
|
|
devq->send_active++;
|
|
|
|
|
|
|
|
if (device->ccbq.queue.entries > 0) {
|
|
|
|
qinfo->pinfo.priority =
|
|
|
|
device->ccbq.queue.queue_array[0]->priority;
|
|
|
|
xpt_schedule_dev_sendq(bus, device);
|
|
|
|
} else {
|
|
|
|
qinfo->pinfo.priority = CAM_PRIORITY_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (work_ccb && (work_ccb->ccb_h.flags & CAM_DEV_QFREEZE) != 0){
|
|
|
|
/*
|
|
|
|
* The client wants to freeze the queue
|
|
|
|
* after this CCB is sent.
|
|
|
|
*/
|
|
|
|
ospl = splcam();
|
|
|
|
device->qfrozen_cnt++;
|
|
|
|
splx(ospl);
|
|
|
|
}
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
if ((device->inq_flags & SID_CmdQue) != 0)
|
|
|
|
work_ccb->ccb_h.flags |= CAM_TAG_ACTION_VALID;
|
|
|
|
else
|
|
|
|
/*
|
|
|
|
* Clear this in case of a retried CCB that failed
|
|
|
|
* due to a rejected tag.
|
|
|
|
*/
|
|
|
|
work_ccb->ccb_h.flags &= ~CAM_TAG_ACTION_VALID;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device queues can be shared among multiple sim instances
|
|
|
|
* that reside on different busses. Use the SIM in the queue
|
|
|
|
* CCB's path, rather than the one in the bus that was passed
|
|
|
|
* into this function.
|
|
|
|
*/
|
|
|
|
sim = work_ccb->ccb_h.path->bus->sim;
|
|
|
|
(*(sim->sim_action))(sim, work_ccb);
|
|
|
|
|
|
|
|
ospl = splcam();
|
|
|
|
devq->active_dev = NULL;
|
|
|
|
splx(ospl);
|
|
|
|
/* Raise IPL for possible insertion and test at top of loop */
|
|
|
|
s = splsoftcam();
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
s = splcam();
|
|
|
|
devq->send_queue.qfrozen_cnt--;
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function merges stuff from the slave ccb into the master ccb, while
|
|
|
|
* keeping important fields in the master ccb constant.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xpt_merge_ccb(union ccb *master_ccb, union ccb *slave_ccb)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Pull fields that are valid for peripheral drivers to set
|
|
|
|
* into the master CCB along with the CCB "payload".
|
|
|
|
*/
|
|
|
|
master_ccb->ccb_h.retry_count = slave_ccb->ccb_h.retry_count;
|
|
|
|
master_ccb->ccb_h.func_code = slave_ccb->ccb_h.func_code;
|
|
|
|
master_ccb->ccb_h.timeout = slave_ccb->ccb_h.timeout;
|
|
|
|
master_ccb->ccb_h.flags = slave_ccb->ccb_h.flags;
|
|
|
|
bcopy(&(&slave_ccb->ccb_h)[1], &(&master_ccb->ccb_h)[1],
|
|
|
|
sizeof(union ccb) - sizeof(struct ccb_hdr));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_setup_ccb(struct ccb_hdr *ccb_h, struct cam_path *path, u_int32_t priority)
|
|
|
|
{
|
|
|
|
CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_setup_ccb\n"));
|
|
|
|
ccb_h->pinfo.priority = priority;
|
|
|
|
ccb_h->path = path;
|
|
|
|
ccb_h->path_id = path->bus->path_id;
|
|
|
|
if (path->target)
|
|
|
|
ccb_h->target_id = path->target->target_id;
|
|
|
|
else
|
|
|
|
ccb_h->target_id = CAM_TARGET_WILDCARD;
|
|
|
|
if (path->device) {
|
|
|
|
if (path->device->ccbq.queue.generation++ == 0) {
|
|
|
|
/* Generation wrap, regen all entries */
|
|
|
|
cam_ccbq_regen(&path->device->ccbq);
|
|
|
|
}
|
|
|
|
ccb_h->target_lun = path->device->lun_id;
|
|
|
|
ccb_h->pinfo.generation = path->device->ccbq.queue.generation;
|
|
|
|
} else {
|
|
|
|
ccb_h->target_lun = CAM_TARGET_WILDCARD;
|
|
|
|
}
|
|
|
|
ccb_h->pinfo.index = CAM_UNQUEUED_INDEX;
|
|
|
|
ccb_h->flags = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Path manipulation functions */
|
|
|
|
cam_status
|
|
|
|
xpt_create_path(struct cam_path **new_path_ptr, struct cam_periph *perph,
|
|
|
|
path_id_t path_id, target_id_t target_id, lun_id_t lun_id)
|
|
|
|
{
|
|
|
|
struct cam_path *path;
|
|
|
|
cam_status status;
|
|
|
|
|
|
|
|
path = (struct cam_path *)malloc(sizeof(*path), M_DEVBUF, M_NOWAIT);
|
|
|
|
|
|
|
|
if (path == NULL) {
|
|
|
|
status = CAM_RESRC_UNAVAIL;
|
|
|
|
return(status);
|
|
|
|
}
|
|
|
|
status = xpt_compile_path(path, perph, path_id, target_id, lun_id);
|
|
|
|
if (status != CAM_REQ_CMP) {
|
|
|
|
free(path, M_DEVBUF);
|
|
|
|
path = NULL;
|
|
|
|
}
|
|
|
|
*new_path_ptr = path;
|
|
|
|
return (status);
|
|
|
|
}
|
|
|
|
|
|
|
|
static cam_status
|
|
|
|
xpt_compile_path(struct cam_path *new_path, struct cam_periph *perph,
|
|
|
|
path_id_t path_id, target_id_t target_id, lun_id_t lun_id)
|
|
|
|
{
|
|
|
|
struct cam_eb *bus;
|
|
|
|
struct cam_et *target;
|
|
|
|
struct cam_ed *device;
|
|
|
|
cam_status status;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
status = CAM_REQ_CMP; /* Completed without error */
|
|
|
|
target = NULL; /* Wildcarded */
|
|
|
|
device = NULL; /* Wildcarded */
|
|
|
|
s = splsoftcam();
|
|
|
|
bus = xpt_find_bus(path_id);
|
|
|
|
if (bus == NULL) {
|
|
|
|
status = CAM_PATH_INVALID;
|
|
|
|
} else if (target_id != CAM_TARGET_WILDCARD) {
|
|
|
|
target = xpt_find_target(bus, target_id);
|
|
|
|
if (target == NULL) {
|
|
|
|
if (path_id == CAM_XPT_PATH_ID) {
|
|
|
|
status = CAM_TID_INVALID;
|
|
|
|
} else {
|
|
|
|
/* Create one */
|
|
|
|
struct cam_et *new_target;
|
|
|
|
|
|
|
|
new_target = xpt_alloc_target(bus, target_id);
|
|
|
|
if (new_target == NULL) {
|
|
|
|
status = CAM_RESRC_UNAVAIL;
|
|
|
|
} else {
|
|
|
|
target = new_target;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (target != NULL && lun_id != CAM_LUN_WILDCARD) {
|
|
|
|
device = xpt_find_device(target, lun_id);
|
|
|
|
if (device == NULL) {
|
|
|
|
if (path_id == CAM_XPT_PATH_ID) {
|
|
|
|
status = CAM_LUN_INVALID;
|
|
|
|
} else {
|
|
|
|
/* Create one */
|
|
|
|
struct cam_ed *new_device;
|
|
|
|
|
|
|
|
new_device = xpt_alloc_device(bus,
|
|
|
|
target,
|
|
|
|
lun_id);
|
|
|
|
if (new_device == NULL) {
|
|
|
|
status = CAM_RESRC_UNAVAIL;
|
|
|
|
} else {
|
|
|
|
device = new_device;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (lun_id != CAM_LUN_WILDCARD) {
|
|
|
|
/*
|
|
|
|
* Specific luns are not allowed if the
|
|
|
|
* target is wildcarded
|
|
|
|
*/
|
|
|
|
status = CAM_LUN_INVALID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Only touch the user's data if we are successful.
|
|
|
|
*/
|
|
|
|
if (status == CAM_REQ_CMP) {
|
|
|
|
new_path->periph = perph;
|
|
|
|
new_path->bus = bus;
|
|
|
|
new_path->target = target;
|
|
|
|
new_path->device = device;
|
|
|
|
CAM_DEBUG(new_path, CAM_DEBUG_TRACE, ("xpt_compile_path\n"));
|
|
|
|
} else {
|
|
|
|
if (device != NULL)
|
|
|
|
xpt_release_device(bus, target, device);
|
|
|
|
if (target != NULL)
|
|
|
|
xpt_release_target(bus, target);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
return (status);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_release_path(struct cam_path *path)
|
|
|
|
{
|
|
|
|
CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_release_path\n"));
|
|
|
|
if (path->device != NULL)
|
|
|
|
xpt_release_device(path->bus, path->target, path->device);
|
|
|
|
if (path->target != NULL)
|
|
|
|
xpt_release_target(path->bus, path->target);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_free_path(struct cam_path *path)
|
|
|
|
{
|
|
|
|
CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_free_path\n"));
|
|
|
|
xpt_release_path(path);
|
|
|
|
free(path, M_DEVBUF);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return -1 for failure, 0 for exact match, 1 for match with wildcards.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xpt_path_comp(struct cam_path *path1, struct cam_path *path2)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
if (path1->bus != path2->bus) {
|
|
|
|
if ((path1->bus == NULL)
|
|
|
|
|| (path2->bus == NULL))
|
|
|
|
retval = 1;
|
|
|
|
else
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
if (path1->target != path2->target) {
|
|
|
|
if ((path1->target == NULL)
|
|
|
|
|| (path2->target == NULL))
|
|
|
|
retval = 1;
|
|
|
|
else
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
if (path1->device != path2->device) {
|
|
|
|
if ((path1->device == NULL)
|
|
|
|
|| (path2->device == NULL))
|
|
|
|
retval = 1;
|
|
|
|
else
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_print_path(struct cam_path *path)
|
|
|
|
{
|
|
|
|
if (path == NULL)
|
|
|
|
printf("(nopath): ");
|
|
|
|
else {
|
|
|
|
if (path->periph != NULL)
|
|
|
|
printf("(%s%d:", path->periph->periph_name,
|
|
|
|
path->periph->unit_number);
|
|
|
|
else
|
|
|
|
printf("(noperiph:");
|
|
|
|
|
|
|
|
if (path->bus != NULL)
|
|
|
|
printf("%s%d:%d:", path->bus->sim->sim_name,
|
|
|
|
path->bus->sim->unit_number,
|
|
|
|
path->bus->sim->bus_id);
|
|
|
|
else
|
|
|
|
printf("nobus:");
|
|
|
|
|
|
|
|
if (path->target != NULL)
|
|
|
|
printf("%d:", path->target->target_id);
|
|
|
|
else
|
|
|
|
printf("X:");
|
|
|
|
|
|
|
|
if (path->device != NULL)
|
|
|
|
printf("%d): ", path->device->lun_id);
|
|
|
|
else
|
|
|
|
printf("X): ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
path_id_t
|
|
|
|
xpt_path_path_id(struct cam_path *path)
|
|
|
|
{
|
|
|
|
return(path->bus->path_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
target_id_t
|
|
|
|
xpt_path_target_id(struct cam_path *path)
|
|
|
|
{
|
|
|
|
if (path->target != NULL)
|
|
|
|
return (path->target->target_id);
|
|
|
|
else
|
|
|
|
return (CAM_TARGET_WILDCARD);
|
|
|
|
}
|
|
|
|
|
|
|
|
lun_id_t
|
|
|
|
xpt_path_lun_id(struct cam_path *path)
|
|
|
|
{
|
|
|
|
if (path->device != NULL)
|
|
|
|
return (path->device->lun_id);
|
|
|
|
else
|
|
|
|
return (CAM_LUN_WILDCARD);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct cam_sim *
|
|
|
|
xpt_path_sim(struct cam_path *path)
|
|
|
|
{
|
|
|
|
return (path->bus->sim);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct cam_periph*
|
|
|
|
xpt_path_periph(struct cam_path *path)
|
|
|
|
{
|
|
|
|
return (path->periph);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Release a CAM control block for the caller. Remit the cost of the structure
|
|
|
|
* to the device referenced by the path. If the this device had no 'credits'
|
|
|
|
* and peripheral drivers have registered async callbacks for this notification
|
|
|
|
* call them now.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
xpt_release_ccb(union ccb *free_ccb)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
struct cam_path *path;
|
|
|
|
struct cam_ed *device;
|
|
|
|
struct cam_eb *bus;
|
|
|
|
|
1998-12-06 00:06:48 +00:00
|
|
|
CAM_DEBUG_PRINT(CAM_DEBUG_XPT, ("xpt_release_ccb\n"));
|
1998-09-15 06:33:23 +00:00
|
|
|
path = free_ccb->ccb_h.path;
|
|
|
|
device = path->device;
|
|
|
|
bus = path->bus;
|
|
|
|
s = splsoftcam();
|
|
|
|
cam_ccbq_release_opening(&device->ccbq);
|
|
|
|
if (xpt_ccb_count > xpt_max_ccbs) {
|
|
|
|
xpt_free_ccb(free_ccb);
|
|
|
|
xpt_ccb_count--;
|
|
|
|
} else {
|
|
|
|
SLIST_INSERT_HEAD(&ccb_freeq, &free_ccb->ccb_h, xpt_links.sle);
|
|
|
|
}
|
|
|
|
bus->sim->devq->alloc_openings++;
|
|
|
|
bus->sim->devq->alloc_active--;
|
|
|
|
/* XXX Turn this into an inline function - xpt_run_device?? */
|
|
|
|
if ((device_is_alloc_queued(device) == 0)
|
|
|
|
&& (device->drvq.entries > 0)) {
|
|
|
|
xpt_schedule_dev_allocq(bus, device);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
if (dev_allocq_is_runnable(bus->sim->devq))
|
|
|
|
xpt_run_dev_allocq(bus);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Functions accessed by SIM drivers */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A sim structure, listing the SIM entry points and instance
|
|
|
|
* identification info is passed to xpt_bus_register to hook the SIM
|
|
|
|
* into the CAM framework. xpt_bus_register creates a cam_eb entry
|
|
|
|
* for this new bus and places it in the array of busses and assigns
|
|
|
|
* it a path_id. The path_id may be influenced by "hard wiring"
|
|
|
|
* information specified by the user. Once interrupt services are
|
|
|
|
* availible, the bus will be probed.
|
|
|
|
*/
|
|
|
|
int32_t
|
|
|
|
xpt_bus_register(struct cam_sim *sim, u_int32_t bus)
|
|
|
|
{
|
|
|
|
static path_id_t buscount;
|
|
|
|
struct cam_eb *new_bus;
|
|
|
|
struct ccb_pathinq cpi;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
sim->bus_id = bus;
|
|
|
|
new_bus = (struct cam_eb *)malloc(sizeof(*new_bus),
|
|
|
|
M_DEVBUF, M_NOWAIT);
|
|
|
|
if (new_bus == NULL) {
|
|
|
|
/* Couldn't satisfy request */
|
|
|
|
return (CAM_RESRC_UNAVAIL);
|
|
|
|
}
|
|
|
|
|
|
|
|
bzero(new_bus, sizeof(*new_bus));
|
|
|
|
|
|
|
|
if (strcmp(sim->sim_name, "xpt") != 0) {
|
|
|
|
|
|
|
|
sim->path_id = xptpathid(sim->sim_name, sim->unit_number,
|
|
|
|
sim->bus_id, &buscount);
|
|
|
|
}
|
|
|
|
|
|
|
|
new_bus->path_id = sim->path_id;
|
|
|
|
new_bus->sim = sim;
|
|
|
|
SLIST_INIT(&new_bus->asyncs);
|
|
|
|
TAILQ_INIT(&new_bus->et_entries);
|
|
|
|
s = splsoftcam();
|
|
|
|
TAILQ_INSERT_TAIL(&xpt_busses, new_bus, links);
|
|
|
|
bus_generation++;
|
|
|
|
|
|
|
|
/* Notify interested parties */
|
|
|
|
if (sim->path_id != CAM_XPT_PATH_ID) {
|
|
|
|
struct cam_path path;
|
|
|
|
|
|
|
|
xpt_compile_path(&path, /*periph*/NULL, sim->path_id,
|
|
|
|
CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD);
|
|
|
|
xpt_setup_ccb(&cpi.ccb_h, &path, /*priority*/1);
|
|
|
|
cpi.ccb_h.func_code = XPT_PATH_INQ;
|
|
|
|
xpt_action((union ccb *)&cpi);
|
|
|
|
xpt_async(AC_PATH_REGISTERED, xpt_periph->path, &cpi);
|
|
|
|
xpt_release_path(&path);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
return (CAM_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptnextfreebus(path_id_t startbus)
|
|
|
|
{
|
|
|
|
struct cam_sim_config *sim_conf;
|
|
|
|
|
|
|
|
sim_conf = cam_sinit;
|
|
|
|
while (sim_conf->sim_name != NULL) {
|
|
|
|
|
|
|
|
if (IS_SPECIFIED(sim_conf->pathid)
|
|
|
|
&& (startbus == sim_conf->pathid)) {
|
|
|
|
++startbus;
|
|
|
|
/* Start the search over */
|
|
|
|
sim_conf = cam_sinit;
|
|
|
|
} else {
|
|
|
|
sim_conf++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (startbus);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptpathid(const char *sim_name, int sim_unit,
|
|
|
|
int sim_bus, path_id_t *nextpath)
|
|
|
|
{
|
|
|
|
struct cam_sim_config *sim_conf;
|
|
|
|
path_id_t pathid;
|
|
|
|
|
|
|
|
pathid = CAM_XPT_PATH_ID;
|
|
|
|
for (sim_conf = cam_sinit; sim_conf->sim_name != NULL; sim_conf++) {
|
|
|
|
|
|
|
|
if (!IS_SPECIFIED(sim_conf->pathid))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!strcmp(sim_name, sim_conf->sim_name)
|
|
|
|
&& (sim_unit == sim_conf->sim_unit)) {
|
|
|
|
|
|
|
|
if (IS_SPECIFIED(sim_conf->sim_bus)) {
|
|
|
|
if (sim_bus == sim_conf->sim_bus) {
|
|
|
|
pathid = sim_conf->pathid;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (sim_bus == 0) {
|
|
|
|
/* Unspecified matches bus 0 */
|
|
|
|
pathid = sim_conf->pathid;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
printf("Ambiguous scbus configuration for %s%d "
|
|
|
|
"bus %d, cannot wire down. The kernel "
|
|
|
|
"config entry for scbus%d should "
|
|
|
|
"specify a controller bus.\n"
|
|
|
|
"Scbus will be assigned dynamically.\n",
|
|
|
|
sim_name, sim_unit, sim_bus,
|
|
|
|
sim_conf->pathid);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pathid == CAM_XPT_PATH_ID) {
|
|
|
|
pathid = xptnextfreebus(*nextpath);
|
|
|
|
*nextpath = pathid + 1;
|
|
|
|
}
|
|
|
|
return (pathid);
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t
|
|
|
|
xpt_bus_deregister(path_id)
|
|
|
|
u_int8_t path_id;
|
|
|
|
{
|
|
|
|
/* XXX */
|
|
|
|
return (CAM_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_async(u_int32_t async_code, struct cam_path *path, void *async_arg)
|
|
|
|
{
|
|
|
|
struct cam_eb *bus;
|
|
|
|
struct cam_et *target, *next_target;
|
|
|
|
struct cam_ed *device, *next_device;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_async\n"));
|
|
|
|
|
|
|
|
s = splsoftcam();
|
|
|
|
|
|
|
|
bus = path->bus;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Freeze the SIM queue for SCSI_DELAY ms to
|
|
|
|
* allow the bus to settle.
|
|
|
|
*/
|
|
|
|
if (async_code == AC_BUS_RESET) {
|
|
|
|
struct cam_sim *sim;
|
|
|
|
|
|
|
|
sim = bus->sim;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there isn't already another timeout pending, go ahead
|
|
|
|
* and freeze the simq and set the timeout flag. If there
|
|
|
|
* is another timeout pending, replace it with this
|
|
|
|
* timeout. There could be two bus reset async broadcasts
|
|
|
|
* sent for some dual-channel controllers.
|
|
|
|
*/
|
|
|
|
if ((sim->flags & CAM_SIM_REL_TIMEOUT_PENDING) == 0) {
|
|
|
|
xpt_freeze_simq(sim, 1);
|
|
|
|
sim->flags |= CAM_SIM_REL_TIMEOUT_PENDING;
|
|
|
|
} else
|
|
|
|
untimeout(xpt_release_simq_timeout, sim, sim->c_handle);
|
|
|
|
|
|
|
|
sim->c_handle = timeout(xpt_release_simq_timeout,
|
|
|
|
sim, (SCSI_DELAY * hz) / 1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (target = TAILQ_FIRST(&bus->et_entries);
|
|
|
|
target != NULL;
|
|
|
|
target = next_target) {
|
|
|
|
|
|
|
|
next_target = TAILQ_NEXT(target, links);
|
|
|
|
|
|
|
|
if (path->target != target
|
|
|
|
&& path->target != NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (device = TAILQ_FIRST(&target->ed_entries);
|
|
|
|
device != NULL;
|
|
|
|
device = next_device) {
|
|
|
|
cam_status status;
|
|
|
|
struct cam_path newpath;
|
|
|
|
|
|
|
|
next_device = TAILQ_NEXT(device, links);
|
|
|
|
|
|
|
|
if (path->device != device
|
|
|
|
&& path->device != NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
1998-09-23 03:03:19 +00:00
|
|
|
* We need our own path with wildcards expanded to
|
|
|
|
* handle certain types of events.
|
1998-09-15 06:33:23 +00:00
|
|
|
*/
|
|
|
|
if ((async_code == AC_SENT_BDR)
|
1998-09-23 03:03:19 +00:00
|
|
|
|| (async_code == AC_BUS_RESET)
|
1998-09-15 06:33:23 +00:00
|
|
|
|| (async_code == AC_INQ_CHANGED))
|
|
|
|
status = xpt_compile_path(&newpath, NULL,
|
|
|
|
bus->path_id,
|
|
|
|
target->target_id,
|
|
|
|
device->lun_id);
|
|
|
|
else
|
1998-09-24 22:43:54 +00:00
|
|
|
status = CAM_REQ_CMP_ERR;
|
1998-09-15 06:33:23 +00:00
|
|
|
|
1998-09-24 22:43:54 +00:00
|
|
|
if (status == CAM_REQ_CMP) {
|
1998-09-23 03:03:19 +00:00
|
|
|
|
|
|
|
/*
|
1998-09-24 22:43:54 +00:00
|
|
|
* Allow transfer negotiation to occur in a
|
|
|
|
* tag free environment.
|
1998-09-23 03:03:19 +00:00
|
|
|
*/
|
1998-09-24 22:43:54 +00:00
|
|
|
if (async_code == AC_SENT_BDR
|
|
|
|
|| async_code == AC_BUS_RESET)
|
|
|
|
xpt_toggle_tags(&newpath);
|
1998-09-23 03:03:19 +00:00
|
|
|
|
1998-09-24 22:43:54 +00:00
|
|
|
/*
|
|
|
|
* If we send a BDR, freeze the device queue
|
|
|
|
* for SCSI_DELAY ms to allow it to settle
|
|
|
|
* down.
|
|
|
|
*/
|
|
|
|
if (async_code == AC_SENT_BDR) {
|
1998-09-15 06:33:23 +00:00
|
|
|
xpt_freeze_devq(&newpath, 1);
|
|
|
|
/*
|
|
|
|
* Although this looks bad, it
|
|
|
|
* isn't as bad as it seems. We're
|
|
|
|
* passing in a stack-allocated path
|
|
|
|
* that we then immediately release
|
|
|
|
* after scheduling a timeout to
|
|
|
|
* release the device queue. So
|
|
|
|
* the path won't be around when
|
|
|
|
* the timeout fires, right? Right.
|
|
|
|
* But it doesn't matter, since
|
|
|
|
* xpt_release_devq and its timeout
|
|
|
|
* function both take the device as
|
|
|
|
* an argument. Theoretically, the
|
|
|
|
* device will still be there when
|
|
|
|
* the timeout fires, even though
|
|
|
|
* the path will be gone.
|
|
|
|
*/
|
|
|
|
cam_release_devq(
|
|
|
|
&newpath,
|
|
|
|
/*relsim_flags*/
|
|
|
|
RELSIM_RELEASE_AFTER_TIMEOUT,
|
|
|
|
/*reduction*/0,
|
|
|
|
/*timeout*/SCSI_DELAY,
|
|
|
|
/*getcount_only*/0);
|
1998-09-24 22:43:54 +00:00
|
|
|
} else if (async_code == AC_INQ_CHANGED) {
|
|
|
|
/*
|
|
|
|
* We've sent a start unit command, or
|
|
|
|
* something similar to a device that
|
|
|
|
* may have caused its inquiry data to
|
|
|
|
* change. So we re-scan the device to
|
|
|
|
* refresh the inquiry data for it.
|
|
|
|
*/
|
|
|
|
xpt_scan_lun(newpath.periph, &newpath,
|
1998-09-15 06:33:23 +00:00
|
|
|
CAM_EXPECT_INQ_CHANGE,
|
|
|
|
NULL);
|
|
|
|
}
|
1998-09-24 22:43:54 +00:00
|
|
|
xpt_release_path(&newpath);
|
1998-09-25 22:35:56 +00:00
|
|
|
} else if (async_code == AC_LOST_DEVICE) {
|
1998-09-15 06:33:23 +00:00
|
|
|
device->flags |= CAM_DEV_UNCONFIGURED;
|
1998-09-25 22:35:56 +00:00
|
|
|
} else if (async_code == AC_TRANSFER_NEG) {
|
|
|
|
struct ccb_trans_settings *settings;
|
|
|
|
|
|
|
|
settings =
|
|
|
|
(struct ccb_trans_settings *)async_arg;
|
|
|
|
xpt_set_transfer_settings(settings, device,
|
|
|
|
/*async_update*/TRUE);
|
|
|
|
}
|
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
xpt_async_bcast(&device->asyncs,
|
|
|
|
async_code,
|
|
|
|
path,
|
|
|
|
async_arg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
xpt_async_bcast(&bus->asyncs, async_code,
|
|
|
|
path, async_arg);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_async_bcast(struct async_list *async_head,
|
|
|
|
u_int32_t async_code,
|
|
|
|
struct cam_path *path, void *async_arg)
|
|
|
|
{
|
|
|
|
struct async_node *cur_entry;
|
|
|
|
|
|
|
|
cur_entry = SLIST_FIRST(async_head);
|
|
|
|
while (cur_entry != NULL) {
|
|
|
|
struct async_node *next_entry;
|
|
|
|
/*
|
|
|
|
* Grab the next list entry before we call the current
|
|
|
|
* entry's callback. This is because the callback function
|
|
|
|
* can delete its async callback entry.
|
|
|
|
*/
|
|
|
|
next_entry = SLIST_NEXT(cur_entry, links);
|
|
|
|
if ((cur_entry->event_enable & async_code) != 0)
|
|
|
|
cur_entry->callback(cur_entry->callback_arg,
|
|
|
|
async_code, path,
|
|
|
|
async_arg);
|
|
|
|
cur_entry = next_entry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u_int32_t
|
|
|
|
xpt_freeze_devq(struct cam_path *path, u_int count)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
struct ccb_hdr *ccbh;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
path->device->qfrozen_cnt += count;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark the last CCB in the queue as needing
|
|
|
|
* to be requeued if the driver hasn't
|
|
|
|
* changed it's state yet. This fixes a race
|
|
|
|
* where a ccb is just about to be queued to
|
|
|
|
* a controller driver when it's interrupt routine
|
|
|
|
* freezes the queue. To completly close the
|
|
|
|
* hole, controller drives must check to see
|
|
|
|
* if a ccb's status is still CAM_REQ_INPROG
|
|
|
|
* under spl protection just before they queue
|
|
|
|
* the CCB. See ahc_action/ahc_freeze_devq for
|
|
|
|
* an example.
|
|
|
|
*/
|
1998-12-15 08:13:10 +00:00
|
|
|
ccbh = TAILQ_LAST(&path->device->ccbq.active_ccbs, ccb_hdr_tailq);
|
1998-09-15 06:33:23 +00:00
|
|
|
if (ccbh && ccbh->status == CAM_REQ_INPROG)
|
|
|
|
ccbh->status = CAM_REQUEUE_REQ;
|
|
|
|
splx(s);
|
|
|
|
return (path->device->qfrozen_cnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
u_int32_t
|
|
|
|
xpt_freeze_simq(struct cam_sim *sim, u_int count)
|
|
|
|
{
|
|
|
|
sim->devq->send_queue.qfrozen_cnt += count;
|
|
|
|
if (sim->devq->active_dev != NULL) {
|
|
|
|
struct ccb_hdr *ccbh;
|
|
|
|
|
|
|
|
ccbh = TAILQ_LAST(&sim->devq->active_dev->ccbq.active_ccbs,
|
1998-12-15 08:13:10 +00:00
|
|
|
ccb_hdr_tailq);
|
1998-09-15 06:33:23 +00:00
|
|
|
if (ccbh && ccbh->status == CAM_REQ_INPROG)
|
|
|
|
ccbh->status = CAM_REQUEUE_REQ;
|
|
|
|
}
|
|
|
|
return (sim->devq->send_queue.qfrozen_cnt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_release_devq_timeout(void *arg)
|
|
|
|
{
|
|
|
|
struct cam_ed *device;
|
|
|
|
|
|
|
|
device = (struct cam_ed *)arg;
|
|
|
|
|
|
|
|
xpt_release_devq(device, /*run_queue*/TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_release_devq(struct cam_ed *dev, int run_queue)
|
|
|
|
{
|
|
|
|
int rundevq;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
rundevq = 0;
|
|
|
|
s = splcam();
|
|
|
|
if (dev->qfrozen_cnt > 0) {
|
|
|
|
|
|
|
|
dev->qfrozen_cnt--;
|
|
|
|
if (dev->qfrozen_cnt == 0) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* No longer need to wait for a successful
|
|
|
|
* command completion.
|
|
|
|
*/
|
|
|
|
dev->flags &= ~CAM_DEV_REL_ON_COMPLETE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove any timeouts that might be scheduled
|
|
|
|
* to release this queue.
|
|
|
|
*/
|
|
|
|
if ((dev->flags & CAM_DEV_REL_TIMEOUT_PENDING) != 0) {
|
|
|
|
untimeout(xpt_release_devq_timeout, dev,
|
|
|
|
dev->c_handle);
|
|
|
|
dev->flags &= ~CAM_DEV_REL_TIMEOUT_PENDING;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now that we are unfrozen schedule the
|
|
|
|
* device so any pending transactions are
|
|
|
|
* run.
|
|
|
|
*/
|
|
|
|
if ((dev->ccbq.queue.entries > 0)
|
|
|
|
&& (xpt_schedule_dev_sendq(dev->target->bus, dev))
|
|
|
|
&& (run_queue != 0)) {
|
|
|
|
rundevq = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
if (rundevq != 0)
|
|
|
|
xpt_run_dev_sendq(dev->target->bus);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_release_simq(struct cam_sim *sim, int run_queue)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
struct camq *sendq;
|
|
|
|
|
|
|
|
sendq = &(sim->devq->send_queue);
|
|
|
|
s = splcam();
|
|
|
|
if (sendq->qfrozen_cnt > 0) {
|
|
|
|
|
|
|
|
sendq->qfrozen_cnt--;
|
|
|
|
if (sendq->qfrozen_cnt == 0) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is a timeout scheduled to release this
|
|
|
|
* sim queue, remove it. The queue frozen count is
|
|
|
|
* already at 0.
|
|
|
|
*/
|
|
|
|
if ((sim->flags & CAM_SIM_REL_TIMEOUT_PENDING) != 0){
|
|
|
|
untimeout(xpt_release_simq_timeout, sim,
|
|
|
|
sim->c_handle);
|
|
|
|
sim->flags &= ~CAM_SIM_REL_TIMEOUT_PENDING;
|
|
|
|
}
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
if (run_queue) {
|
|
|
|
/*
|
|
|
|
* Now that we are unfrozen run the send queue.
|
|
|
|
*/
|
|
|
|
xpt_run_dev_sendq(xpt_find_bus(sim->path_id));
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
splx(s);
|
|
|
|
} else
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_release_simq_timeout(void *arg)
|
|
|
|
{
|
|
|
|
struct cam_sim *sim;
|
|
|
|
|
|
|
|
sim = (struct cam_sim *)arg;
|
|
|
|
xpt_release_simq(sim, /* run_queue */ TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_done(union ccb *done_ccb)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
|
|
|
|
CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("xpt_done\n"));
|
|
|
|
switch (done_ccb->ccb_h.func_code) {
|
|
|
|
case XPT_SCSI_IO:
|
|
|
|
case XPT_ENG_EXEC:
|
|
|
|
case XPT_TARGET_IO:
|
|
|
|
case XPT_ACCEPT_TARGET_IO:
|
|
|
|
case XPT_CONT_TARGET_IO:
|
|
|
|
case XPT_SCAN_BUS:
|
|
|
|
case XPT_SCAN_LUN:
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Queue up the request for handling by our SWI handler
|
|
|
|
* any of the "non-immediate" type of ccbs.
|
|
|
|
*/
|
|
|
|
switch (done_ccb->ccb_h.path->periph->type) {
|
|
|
|
case CAM_PERIPH_BIO:
|
|
|
|
TAILQ_INSERT_TAIL(&cam_bioq, &done_ccb->ccb_h,
|
|
|
|
sim_links.tqe);
|
|
|
|
done_ccb->ccb_h.pinfo.index = CAM_DONEQ_INDEX;
|
|
|
|
setsoftcambio();
|
|
|
|
break;
|
|
|
|
case CAM_PERIPH_NET:
|
|
|
|
TAILQ_INSERT_TAIL(&cam_netq, &done_ccb->ccb_h,
|
|
|
|
sim_links.tqe);
|
|
|
|
done_ccb->ccb_h.pinfo.index = CAM_DONEQ_INDEX;
|
|
|
|
setsoftcamnet();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
union ccb *
|
|
|
|
xpt_alloc_ccb()
|
|
|
|
{
|
|
|
|
union ccb *new_ccb;
|
|
|
|
|
|
|
|
new_ccb = malloc(sizeof(*new_ccb), M_DEVBUF, M_WAITOK);
|
|
|
|
return (new_ccb);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_free_ccb(union ccb *free_ccb)
|
|
|
|
{
|
|
|
|
free(free_ccb, M_DEVBUF);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Private XPT functions */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get a CAM control block for the caller. Charge the structure to the device
|
|
|
|
* referenced by the path. If the this device has no 'credits' then the
|
|
|
|
* device already has the maximum number of outstanding operations under way
|
|
|
|
* and we return NULL. If we don't have sufficient resources to allocate more
|
|
|
|
* ccbs, we also return NULL.
|
|
|
|
*/
|
|
|
|
static union ccb *
|
|
|
|
xpt_get_ccb(struct cam_ed *device)
|
|
|
|
{
|
|
|
|
union ccb *new_ccb;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splsoftcam();
|
|
|
|
if ((new_ccb = (union ccb *)ccb_freeq.slh_first) == NULL) {
|
|
|
|
new_ccb = malloc(sizeof(*new_ccb), M_DEVBUF, M_NOWAIT);
|
|
|
|
if (new_ccb == NULL) {
|
|
|
|
splx(s);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
callout_handle_init(&new_ccb->ccb_h.timeout_ch);
|
|
|
|
SLIST_INSERT_HEAD(&ccb_freeq, &new_ccb->ccb_h,
|
|
|
|
xpt_links.sle);
|
|
|
|
xpt_ccb_count++;
|
|
|
|
}
|
|
|
|
cam_ccbq_take_opening(&device->ccbq);
|
|
|
|
SLIST_REMOVE_HEAD(&ccb_freeq, xpt_links.sle);
|
|
|
|
splx(s);
|
|
|
|
return (new_ccb);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static struct cam_et *
|
|
|
|
xpt_alloc_target(struct cam_eb *bus, target_id_t target_id)
|
|
|
|
{
|
|
|
|
struct cam_et *target;
|
|
|
|
|
|
|
|
target = (struct cam_et *)malloc(sizeof(*target), M_DEVBUF, M_NOWAIT);
|
|
|
|
if (target != NULL) {
|
|
|
|
struct cam_et *cur_target;
|
|
|
|
|
|
|
|
target->bus = bus;
|
|
|
|
target->target_id = target_id;
|
|
|
|
target->refcount = 1;
|
|
|
|
TAILQ_INIT(&target->ed_entries);
|
|
|
|
|
|
|
|
/* Insertion sort into our bus's target list */
|
|
|
|
cur_target = TAILQ_FIRST(&bus->et_entries);
|
|
|
|
while (cur_target != NULL && cur_target->target_id < target_id)
|
|
|
|
cur_target = TAILQ_NEXT(cur_target, links);
|
|
|
|
|
|
|
|
if (cur_target != NULL) {
|
|
|
|
TAILQ_INSERT_BEFORE(cur_target, target, links);
|
|
|
|
} else {
|
|
|
|
TAILQ_INSERT_TAIL(&bus->et_entries, target, links);
|
|
|
|
bus->generation++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (target);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xpt_release_target(struct cam_eb *bus, struct cam_et *target)
|
|
|
|
{
|
|
|
|
if ((--target->refcount == 0)
|
|
|
|
&& (TAILQ_FIRST(&target->ed_entries) == NULL)) {
|
|
|
|
TAILQ_REMOVE(&bus->et_entries, target, links);
|
|
|
|
bus->generation++;
|
|
|
|
free(target, M_DEVBUF);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct cam_ed *
|
|
|
|
xpt_alloc_device(struct cam_eb *bus, struct cam_et *target, lun_id_t lun_id)
|
|
|
|
{
|
|
|
|
struct cam_ed *device;
|
|
|
|
struct cam_devq *devq;
|
|
|
|
int32_t status;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splsoftcam();
|
|
|
|
/* Make space for us in the device queue on our bus */
|
|
|
|
devq = bus->sim->devq;
|
|
|
|
status = cam_devq_resize(devq, devq->alloc_queue.array_size + 1);
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
if (status != CAM_REQ_CMP) {
|
|
|
|
device = NULL;
|
|
|
|
} else {
|
|
|
|
device = (struct cam_ed *)malloc(sizeof(*device),
|
|
|
|
M_DEVBUF, M_NOWAIT);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (device != NULL) {
|
|
|
|
struct cam_ed *cur_device;
|
|
|
|
|
|
|
|
bzero(device, sizeof(*device));
|
|
|
|
|
|
|
|
SLIST_INIT(&device->asyncs);
|
|
|
|
SLIST_INIT(&device->periphs);
|
|
|
|
callout_handle_init(&device->c_handle);
|
|
|
|
device->refcount = 1;
|
|
|
|
device->flags |= CAM_DEV_UNCONFIGURED;
|
|
|
|
|
|
|
|
cam_init_pinfo(&device->alloc_ccb_entry.pinfo);
|
|
|
|
device->alloc_ccb_entry.device = device;
|
|
|
|
cam_init_pinfo(&device->send_ccb_entry.pinfo);
|
|
|
|
device->send_ccb_entry.device = device;
|
|
|
|
|
|
|
|
device->target = target;
|
|
|
|
|
|
|
|
device->lun_id = lun_id;
|
|
|
|
|
|
|
|
/* Initialize our queues */
|
|
|
|
if (camq_init(&device->drvq, 0) != 0) {
|
|
|
|
free(device, M_DEVBUF);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cam_ccbq_init(&device->ccbq,
|
|
|
|
bus->sim->max_dev_openings) != 0) {
|
|
|
|
camq_fini(&device->drvq);
|
|
|
|
free(device, M_DEVBUF);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
s = splsoftcam();
|
|
|
|
/*
|
|
|
|
* XXX should be limited by number of CCBs this bus can
|
|
|
|
* do.
|
|
|
|
*/
|
|
|
|
xpt_max_ccbs += device->ccbq.devq_openings;
|
|
|
|
/* Insertion sort into our target's device list */
|
|
|
|
cur_device = TAILQ_FIRST(&target->ed_entries);
|
|
|
|
while (cur_device != NULL && cur_device->lun_id < lun_id)
|
|
|
|
cur_device = TAILQ_NEXT(cur_device, links);
|
|
|
|
if (cur_device != NULL) {
|
|
|
|
TAILQ_INSERT_BEFORE(cur_device, device, links);
|
|
|
|
} else {
|
|
|
|
TAILQ_INSERT_TAIL(&target->ed_entries, device, links);
|
|
|
|
target->generation++;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
return (device);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_release_device(struct cam_eb *bus, struct cam_et *target,
|
|
|
|
struct cam_ed *device)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
|
|
|
|
if ((--device->refcount == 0)
|
|
|
|
&& ((device->flags & CAM_DEV_UNCONFIGURED) != 0)) {
|
|
|
|
struct cam_devq *devq;
|
|
|
|
|
|
|
|
s = splsoftcam();
|
|
|
|
TAILQ_REMOVE(&target->ed_entries, device,links);
|
|
|
|
target->generation++;
|
|
|
|
xpt_max_ccbs -= device->ccbq.devq_openings;
|
|
|
|
free(device, M_DEVBUF);
|
|
|
|
/* Release our slot in the devq */
|
|
|
|
devq = bus->sim->devq;
|
|
|
|
cam_devq_resize(devq, devq->alloc_queue.array_size - 1);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static u_int32_t
|
|
|
|
xpt_dev_ccbq_resize(struct cam_path *path, int newopenings)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
int diff;
|
|
|
|
int result;
|
|
|
|
struct cam_ed *dev;
|
|
|
|
|
|
|
|
dev = path->device;
|
|
|
|
s = splsoftcam();
|
|
|
|
|
|
|
|
diff = newopenings - (dev->ccbq.dev_active + dev->ccbq.dev_openings);
|
|
|
|
result = cam_ccbq_resize(&dev->ccbq, newopenings);
|
|
|
|
if (result == CAM_REQ_CMP && (diff < 0)) {
|
|
|
|
dev->flags |= CAM_DEV_RESIZE_QUEUE_NEEDED;
|
|
|
|
}
|
|
|
|
/* Adjust the global limit */
|
|
|
|
xpt_max_ccbs += diff;
|
|
|
|
splx(s);
|
|
|
|
return (result);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct cam_eb *
|
|
|
|
xpt_find_bus(path_id_t path_id)
|
|
|
|
{
|
|
|
|
struct cam_eb *bus;
|
|
|
|
|
|
|
|
for (bus = TAILQ_FIRST(&xpt_busses);
|
|
|
|
bus != NULL;
|
|
|
|
bus = TAILQ_NEXT(bus, links)) {
|
|
|
|
if (bus->path_id == path_id)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return (bus);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct cam_et *
|
|
|
|
xpt_find_target(struct cam_eb *bus, target_id_t target_id)
|
|
|
|
{
|
|
|
|
struct cam_et *target;
|
|
|
|
|
|
|
|
for (target = TAILQ_FIRST(&bus->et_entries);
|
|
|
|
target != NULL;
|
|
|
|
target = TAILQ_NEXT(target, links)) {
|
|
|
|
if (target->target_id == target_id) {
|
|
|
|
target->refcount++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (target);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct cam_ed *
|
|
|
|
xpt_find_device(struct cam_et *target, lun_id_t lun_id)
|
|
|
|
{
|
|
|
|
struct cam_ed *device;
|
|
|
|
|
|
|
|
for (device = TAILQ_FIRST(&target->ed_entries);
|
|
|
|
device != NULL;
|
|
|
|
device = TAILQ_NEXT(device, links)) {
|
|
|
|
if (device->lun_id == lun_id) {
|
|
|
|
device->refcount++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (device);
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
union ccb *request_ccb;
|
|
|
|
struct ccb_pathinq *cpi;
|
|
|
|
int pending_count;
|
|
|
|
} xpt_scan_bus_info;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To start a scan, request_ccb is an XPT_SCAN_BUS ccb.
|
|
|
|
* As the scan progresses, xpt_scan_bus is used as the
|
|
|
|
* callback on completion function.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
xpt_scan_bus(struct cam_periph *periph, union ccb *request_ccb)
|
|
|
|
{
|
|
|
|
CAM_DEBUG(request_ccb->ccb_h.path, CAM_DEBUG_TRACE,
|
|
|
|
("xpt_scan_bus\n"));
|
|
|
|
switch (request_ccb->ccb_h.func_code) {
|
|
|
|
case XPT_SCAN_BUS:
|
|
|
|
{
|
|
|
|
xpt_scan_bus_info *scan_info;
|
|
|
|
union ccb *work_ccb;
|
|
|
|
struct cam_path *path;
|
|
|
|
u_int i;
|
|
|
|
u_int max_target;
|
|
|
|
u_int initiator_id;
|
|
|
|
|
|
|
|
/* Find out the characteristics of the bus */
|
|
|
|
work_ccb = xpt_alloc_ccb();
|
|
|
|
xpt_setup_ccb(&work_ccb->ccb_h, request_ccb->ccb_h.path,
|
|
|
|
request_ccb->ccb_h.pinfo.priority);
|
|
|
|
work_ccb->ccb_h.func_code = XPT_PATH_INQ;
|
|
|
|
xpt_action(work_ccb);
|
|
|
|
if (work_ccb->ccb_h.status != CAM_REQ_CMP) {
|
|
|
|
request_ccb->ccb_h.status = work_ccb->ccb_h.status;
|
|
|
|
xpt_free_ccb(work_ccb);
|
|
|
|
xpt_done(request_ccb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1998-12-10 04:05:49 +00:00
|
|
|
if ((work_ccb->cpi.hba_misc & PIM_NOINITIATOR) != 0) {
|
|
|
|
/*
|
|
|
|
* Can't scan the bus on an adapter that
|
|
|
|
* cannot perform the initiator role.
|
|
|
|
*/
|
|
|
|
request_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_free_ccb(work_ccb);
|
|
|
|
xpt_done(request_ccb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
/* Save some state for use while we probe for devices */
|
|
|
|
scan_info = (xpt_scan_bus_info *)
|
|
|
|
malloc(sizeof(xpt_scan_bus_info), M_TEMP, M_WAITOK);
|
|
|
|
scan_info->request_ccb = request_ccb;
|
|
|
|
scan_info->cpi = &work_ccb->cpi;
|
|
|
|
|
|
|
|
/* Cache on our stack so we can work asynchronously */
|
|
|
|
max_target = scan_info->cpi->max_target;
|
|
|
|
initiator_id = scan_info->cpi->initiator_id;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't count the initiator if the
|
|
|
|
* initiator is addressable.
|
|
|
|
*/
|
|
|
|
scan_info->pending_count = max_target + 1;
|
|
|
|
if (initiator_id <= max_target)
|
|
|
|
scan_info->pending_count--;
|
|
|
|
|
|
|
|
for (i = 0; i <= max_target; i++) {
|
|
|
|
cam_status status;
|
|
|
|
if (i == initiator_id)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
status = xpt_create_path(&path, xpt_periph,
|
|
|
|
request_ccb->ccb_h.path_id,
|
|
|
|
i, 0);
|
|
|
|
if (status != CAM_REQ_CMP) {
|
|
|
|
printf("xpt_scan_bus: xpt_create_path failed"
|
|
|
|
" with status %#x, bus scan halted\n",
|
|
|
|
status);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
work_ccb = xpt_alloc_ccb();
|
|
|
|
xpt_setup_ccb(&work_ccb->ccb_h, path,
|
|
|
|
request_ccb->ccb_h.pinfo.priority);
|
|
|
|
work_ccb->ccb_h.func_code = XPT_SCAN_LUN;
|
|
|
|
work_ccb->ccb_h.cbfcnp = xpt_scan_bus;
|
|
|
|
work_ccb->ccb_h.ppriv_ptr0 = scan_info;
|
|
|
|
work_ccb->crcn.flags = request_ccb->crcn.flags;
|
|
|
|
#if 0
|
|
|
|
printf("xpt_scan_bus: probing %d:%d:%d\n",
|
|
|
|
request_ccb->ccb_h.path_id, i, 0);
|
|
|
|
#endif
|
|
|
|
xpt_action(work_ccb);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_SCAN_LUN:
|
|
|
|
{
|
|
|
|
xpt_scan_bus_info *scan_info;
|
|
|
|
path_id_t path_id;
|
|
|
|
target_id_t target_id;
|
|
|
|
lun_id_t lun_id;
|
|
|
|
|
|
|
|
/* Reuse the same CCB to query if a device was really found */
|
|
|
|
scan_info = (xpt_scan_bus_info *)request_ccb->ccb_h.ppriv_ptr0;
|
|
|
|
xpt_setup_ccb(&request_ccb->ccb_h, request_ccb->ccb_h.path,
|
|
|
|
request_ccb->ccb_h.pinfo.priority);
|
|
|
|
request_ccb->ccb_h.func_code = XPT_GDEV_TYPE;
|
|
|
|
|
|
|
|
path_id = request_ccb->ccb_h.path_id;
|
|
|
|
target_id = request_ccb->ccb_h.target_id;
|
|
|
|
lun_id = request_ccb->ccb_h.target_lun;
|
|
|
|
xpt_action(request_ccb);
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
printf("xpt_scan_bus: got back probe from %d:%d:%d\n",
|
|
|
|
path_id, target_id, lun_id);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (request_ccb->ccb_h.status != CAM_REQ_CMP) {
|
|
|
|
struct cam_ed *device;
|
|
|
|
struct cam_et *target;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we already probed lun 0 successfully, or
|
|
|
|
* we have additional configured luns on this
|
|
|
|
* target that might have "gone away", go onto
|
|
|
|
* the next lun.
|
|
|
|
*/
|
|
|
|
target = request_ccb->ccb_h.path->target;
|
|
|
|
device = TAILQ_FIRST(&target->ed_entries);
|
|
|
|
if (device != NULL)
|
|
|
|
device = TAILQ_NEXT(device, links);
|
|
|
|
|
|
|
|
if ((lun_id != 0) || (device != NULL)) {
|
|
|
|
/* Try the next lun */
|
|
|
|
lun_id++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct cam_ed *device;
|
|
|
|
|
|
|
|
device = request_ccb->ccb_h.path->device;
|
|
|
|
|
|
|
|
if ((device->quirk->quirks & CAM_QUIRK_NOLUNS) == 0) {
|
|
|
|
/* Try the next lun */
|
|
|
|
lun_id++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
xpt_free_path(request_ccb->ccb_h.path);
|
|
|
|
|
|
|
|
/* Check Bounds */
|
|
|
|
if ((lun_id == request_ccb->ccb_h.target_lun)
|
|
|
|
|| lun_id > scan_info->cpi->max_lun) {
|
|
|
|
/* We're done */
|
|
|
|
|
|
|
|
xpt_free_ccb(request_ccb);
|
|
|
|
scan_info->pending_count--;
|
|
|
|
if (scan_info->pending_count == 0) {
|
|
|
|
xpt_free_ccb((union ccb *)scan_info->cpi);
|
|
|
|
request_ccb = scan_info->request_ccb;
|
|
|
|
free(scan_info, M_TEMP);
|
|
|
|
request_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(request_ccb);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Try the next device */
|
|
|
|
struct cam_path *path;
|
|
|
|
cam_status status;
|
|
|
|
|
|
|
|
path = request_ccb->ccb_h.path;
|
|
|
|
status = xpt_create_path(&path, xpt_periph,
|
|
|
|
path_id, target_id, lun_id);
|
|
|
|
if (status != CAM_REQ_CMP) {
|
|
|
|
printf("xpt_scan_bus: xpt_create_path failed "
|
|
|
|
"with status %#x, halting LUN scan\n",
|
|
|
|
status);
|
|
|
|
xpt_free_ccb(request_ccb);
|
|
|
|
scan_info->pending_count--;
|
|
|
|
if (scan_info->pending_count == 0) {
|
|
|
|
xpt_free_ccb(
|
|
|
|
(union ccb *)scan_info->cpi);
|
|
|
|
request_ccb = scan_info->request_ccb;
|
|
|
|
free(scan_info, M_TEMP);
|
|
|
|
request_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(request_ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
xpt_setup_ccb(&request_ccb->ccb_h, path,
|
|
|
|
request_ccb->ccb_h.pinfo.priority);
|
|
|
|
request_ccb->ccb_h.func_code = XPT_SCAN_LUN;
|
|
|
|
request_ccb->ccb_h.cbfcnp = xpt_scan_bus;
|
|
|
|
request_ccb->ccb_h.ppriv_ptr0 = scan_info;
|
|
|
|
request_ccb->crcn.flags =
|
|
|
|
scan_info->request_ccb->crcn.flags;
|
|
|
|
#if 0
|
|
|
|
xpt_print_path(path);
|
|
|
|
printf("xpt_scan bus probing\n");
|
|
|
|
#endif
|
|
|
|
xpt_action(request_ccb);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
PROBE_TUR,
|
|
|
|
PROBE_INQUIRY,
|
|
|
|
PROBE_MODE_SENSE,
|
|
|
|
PROBE_SERIAL_NUM,
|
|
|
|
PROBE_TUR_FOR_NEGOTIATION
|
|
|
|
} probe_action;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
PROBE_INQUIRY_CKSUM = 0x01,
|
|
|
|
PROBE_SERIAL_CKSUM = 0x02,
|
|
|
|
PROBE_NO_ANNOUNCE = 0x04
|
|
|
|
} probe_flags;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
TAILQ_HEAD(, ccb_hdr) request_ccbs;
|
|
|
|
probe_action action;
|
|
|
|
union ccb saved_ccb;
|
|
|
|
probe_flags flags;
|
|
|
|
MD5_CTX context;
|
|
|
|
u_int8_t digest[16];
|
|
|
|
} probe_softc;
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_scan_lun(struct cam_periph *periph, struct cam_path *path,
|
|
|
|
cam_flags flags, union ccb *request_ccb)
|
|
|
|
{
|
1998-12-10 04:05:49 +00:00
|
|
|
struct ccb_pathinq cpi;
|
1998-09-15 06:33:23 +00:00
|
|
|
cam_status status;
|
|
|
|
struct cam_path *new_path;
|
|
|
|
struct cam_periph *old_periph;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
CAM_DEBUG(request_ccb->ccb_h.path, CAM_DEBUG_TRACE,
|
|
|
|
("xpt_scan_lun\n"));
|
1998-12-10 04:05:49 +00:00
|
|
|
|
|
|
|
xpt_setup_ccb(&cpi.ccb_h, path, /*priority*/1);
|
|
|
|
cpi.ccb_h.func_code = XPT_PATH_INQ;
|
|
|
|
xpt_action((union ccb *)&cpi);
|
|
|
|
|
|
|
|
if (cpi.ccb_h.status != CAM_REQ_CMP) {
|
|
|
|
if (request_ccb != NULL) {
|
|
|
|
request_ccb->ccb_h.status = cpi.ccb_h.status;
|
|
|
|
xpt_done(request_ccb);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cpi.hba_misc & PIM_NOINITIATOR) != 0) {
|
|
|
|
/*
|
|
|
|
* Can't scan the bus on an adapter that
|
|
|
|
* cannot perform the initiator role.
|
|
|
|
*/
|
|
|
|
if (request_ccb != NULL) {
|
|
|
|
request_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(request_ccb);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
if (request_ccb == NULL) {
|
|
|
|
request_ccb = malloc(sizeof(union ccb), M_TEMP, M_NOWAIT);
|
|
|
|
if (request_ccb == NULL) {
|
|
|
|
xpt_print_path(path);
|
|
|
|
printf("xpt_scan_lun: can't allocate CCB, can't "
|
|
|
|
"continue\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
new_path = malloc(sizeof(*new_path), M_TEMP, M_NOWAIT);
|
|
|
|
if (new_path == NULL) {
|
|
|
|
xpt_print_path(path);
|
|
|
|
printf("xpt_scan_lun: can't allocate path, can't "
|
|
|
|
"continue\n");
|
|
|
|
free(request_ccb, M_TEMP);
|
|
|
|
return;
|
|
|
|
}
|
1998-10-13 21:29:04 +00:00
|
|
|
status = xpt_compile_path(new_path, xpt_periph,
|
|
|
|
path->bus->path_id,
|
1998-09-15 06:33:23 +00:00
|
|
|
path->target->target_id,
|
|
|
|
path->device->lun_id);
|
|
|
|
|
|
|
|
if (status != CAM_REQ_CMP) {
|
|
|
|
xpt_print_path(path);
|
|
|
|
printf("xpt_scan_lun: can't compile path, can't "
|
|
|
|
"continue\n");
|
|
|
|
free(request_ccb, M_TEMP);
|
|
|
|
free(new_path, M_TEMP);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
xpt_setup_ccb(&request_ccb->ccb_h, new_path, /*priority*/ 1);
|
|
|
|
request_ccb->ccb_h.cbfcnp = xptscandone;
|
|
|
|
request_ccb->ccb_h.func_code = XPT_SCAN_LUN;
|
|
|
|
request_ccb->crcn.flags = flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = splsoftcam();
|
|
|
|
if ((old_periph = cam_periph_find(path, "probe")) != NULL) {
|
|
|
|
probe_softc *softc;
|
|
|
|
|
|
|
|
softc = (probe_softc *)old_periph->softc;
|
|
|
|
TAILQ_INSERT_TAIL(&softc->request_ccbs, &request_ccb->ccb_h,
|
|
|
|
periph_links.tqe);
|
|
|
|
} else {
|
Fix a problem with the way we handled device invalidation when attaching
to a device failed.
In theory, the same steps that happen when we get an AC_LOST_DEVICE async
notification should have been taken when a driver fails to attach. In
practice, that wasn't the case.
This only affected the da, cd and ch drivers, but the fix affects all
peripheral drivers.
There were several possible problems:
- In the da driver, we didn't remove the peripheral's softc from the da
driver's linked list of softcs. Once the peripheral and softc got
removed, we'd get a kernel panic the next time the timeout routine
called dasendorderedtag().
- In the da, cd and possibly ch drivers, we didn't remove the
peripheral's devstat structure from the devstat queue. Once the
peripheral and softc were removed, this could cause a panic if anyone
tried to access device statistics. (one component of the linked list
wouldn't exist anymore)
- In the cd driver, we didn't take the peripheral off the changer run
queue if it was scheduled to run. In practice, it's highly unlikely,
and maybe impossible that the peripheral would have been on the
changer run queue at that stage of the probe process.
The fix is:
- Add a new peripheral callback function (the "oninvalidate" function)
that is called the first time cam_periph_invalidate() is called for a
peripheral.
- Create new foooninvalidate() routines for each peripheral driver. This
routine is always called at splsoftcam(), and contains all the stuff
that used to be in the AC_LOST_DEVICE case of the async callback
handler.
- Move the devstat cleanup call to the destructor/cleanup routines, since
some of the drivers do I/O in their close routines.
- Make sure that when we're flushing the buffer queue, we traverse it at
splbio().
- Add a check for the invalid flag in the pt driver's open routine.
Reviewed by: gibbs
1998-10-22 22:16:56 +00:00
|
|
|
status = cam_periph_alloc(proberegister, NULL, probecleanup,
|
1998-09-15 06:33:23 +00:00
|
|
|
probestart, "probe",
|
|
|
|
CAM_PERIPH_BIO,
|
|
|
|
request_ccb->ccb_h.path, NULL, 0,
|
|
|
|
request_ccb);
|
|
|
|
|
|
|
|
if (status != CAM_REQ_CMP) {
|
|
|
|
xpt_print_path(path);
|
|
|
|
printf("xpt_scan_lun: cam_alloc_periph returned an "
|
|
|
|
"error, can't continue probe\n");
|
|
|
|
request_ccb->ccb_h.status = status;
|
|
|
|
xpt_done(request_ccb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xptscandone(struct cam_periph *periph, union ccb *done_ccb)
|
|
|
|
{
|
|
|
|
xpt_release_path(done_ccb->ccb_h.path);
|
|
|
|
free(done_ccb->ccb_h.path, M_TEMP);
|
|
|
|
free(done_ccb, M_TEMP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static cam_status
|
|
|
|
proberegister(struct cam_periph *periph, void *arg)
|
|
|
|
{
|
|
|
|
struct ccb_getdev *cgd;
|
|
|
|
probe_softc *softc;
|
|
|
|
union ccb *ccb;
|
|
|
|
|
|
|
|
cgd = (struct ccb_getdev *)arg;
|
|
|
|
if (periph == NULL) {
|
|
|
|
printf("proberegister: periph was NULL!!\n");
|
|
|
|
return(CAM_REQ_CMP_ERR);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cgd == NULL) {
|
|
|
|
printf("proberegister: no getdev CCB, can't register device\n");
|
|
|
|
return(CAM_REQ_CMP_ERR);
|
|
|
|
}
|
|
|
|
|
1998-09-16 13:24:37 +00:00
|
|
|
softc = (probe_softc *)malloc(sizeof(*softc), M_TEMP, M_NOWAIT);
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
if (softc == NULL) {
|
|
|
|
printf("proberegister: Unable to probe new device. "
|
|
|
|
"Unable to allocate softc\n");
|
|
|
|
return(CAM_REQ_CMP_ERR);
|
|
|
|
}
|
|
|
|
ccb = (union ccb *)cgd;
|
|
|
|
TAILQ_INIT(&softc->request_ccbs);
|
|
|
|
TAILQ_INSERT_TAIL(&softc->request_ccbs, &ccb->ccb_h, periph_links.tqe);
|
|
|
|
softc->flags = 0;
|
|
|
|
periph->softc = softc;
|
|
|
|
cam_periph_acquire(periph);
|
|
|
|
probeschedule(periph);
|
|
|
|
return(CAM_REQ_CMP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
probeschedule(struct cam_periph *periph)
|
|
|
|
{
|
|
|
|
union ccb *ccb;
|
|
|
|
probe_softc *softc;
|
|
|
|
|
|
|
|
softc = (probe_softc *)periph->softc;
|
|
|
|
ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If a device has gone away and another device, or the same one,
|
|
|
|
* is back in the same place, it should have a unit attention
|
|
|
|
* condition pending. It will not report the unit attention in
|
|
|
|
* response to an inquiry, which may leave invalid transfer
|
|
|
|
* negotiations in effect. The TUR will reveal the unit attention
|
|
|
|
* condition. Only send the TUR for lun 0, since some devices
|
|
|
|
* will get confused by commands other than inquiry to non-existent
|
|
|
|
* luns. If you think a device has gone away start your scan from
|
|
|
|
* lun 0. This will insure that any bogus transfer settings are
|
|
|
|
* invalidated.
|
|
|
|
*/
|
|
|
|
if (((ccb->ccb_h.path->device->flags & CAM_DEV_UNCONFIGURED)==0)
|
|
|
|
&& (ccb->ccb_h.target_lun == 0))
|
|
|
|
softc->action = PROBE_TUR;
|
|
|
|
else
|
|
|
|
softc->action = PROBE_INQUIRY;
|
|
|
|
|
|
|
|
if (ccb->crcn.flags & CAM_EXPECT_INQ_CHANGE)
|
|
|
|
softc->flags |= PROBE_NO_ANNOUNCE;
|
|
|
|
else
|
|
|
|
softc->flags &= ~PROBE_NO_ANNOUNCE;
|
|
|
|
|
|
|
|
xpt_schedule(periph, ccb->ccb_h.pinfo.priority);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
probestart(struct cam_periph *periph, union ccb *start_ccb)
|
|
|
|
{
|
|
|
|
/* Probe the device that our peripheral driver points to */
|
|
|
|
struct ccb_scsiio *csio;
|
|
|
|
probe_softc *softc;
|
|
|
|
|
|
|
|
CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("probestart\n"));
|
|
|
|
|
|
|
|
softc = (probe_softc *)periph->softc;
|
|
|
|
csio = &start_ccb->csio;
|
|
|
|
|
|
|
|
switch (softc->action) {
|
|
|
|
case PROBE_TUR:
|
|
|
|
case PROBE_TUR_FOR_NEGOTIATION:
|
|
|
|
{
|
|
|
|
scsi_test_unit_ready(csio,
|
|
|
|
/*retries*/4,
|
|
|
|
probedone,
|
|
|
|
MSG_SIMPLE_Q_TAG,
|
|
|
|
SSD_FULL_SIZE,
|
1998-09-20 07:14:36 +00:00
|
|
|
/*timeout*/60000);
|
1998-09-15 06:33:23 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PROBE_INQUIRY:
|
|
|
|
{
|
|
|
|
struct scsi_inquiry_data *inq_buf;
|
|
|
|
|
|
|
|
inq_buf = &periph->path->device->inq_data;
|
|
|
|
/*
|
|
|
|
* If the device is currently configured, we calculate an
|
|
|
|
* MD5 checksum of the inquiry data, and if the serial number
|
|
|
|
* length is greater than 0, add the serial number data
|
|
|
|
* into the checksum as well. Once the inquiry and the
|
|
|
|
* serial number check finish, we attempt to figure out
|
|
|
|
* whether we still have the same device.
|
|
|
|
*/
|
|
|
|
if ((periph->path->device->flags & CAM_DEV_UNCONFIGURED) == 0) {
|
|
|
|
|
|
|
|
MD5Init(&softc->context);
|
|
|
|
MD5Update(&softc->context, (unsigned char *)inq_buf,
|
|
|
|
sizeof(struct scsi_inquiry_data));
|
|
|
|
softc->flags |= PROBE_INQUIRY_CKSUM;
|
|
|
|
if (periph->path->device->serial_num_len > 0) {
|
|
|
|
MD5Update(&softc->context,
|
|
|
|
periph->path->device->serial_num,
|
|
|
|
periph->path->device->serial_num_len);
|
|
|
|
softc->flags |= PROBE_SERIAL_CKSUM;
|
|
|
|
}
|
|
|
|
MD5Final(softc->digest, &softc->context);
|
|
|
|
}
|
|
|
|
|
|
|
|
scsi_inquiry(csio,
|
|
|
|
/*retries*/4,
|
|
|
|
probedone,
|
|
|
|
MSG_SIMPLE_Q_TAG,
|
|
|
|
(u_int8_t *)inq_buf,
|
|
|
|
sizeof(*inq_buf),
|
|
|
|
/*evpd*/FALSE,
|
|
|
|
/*page_code*/0,
|
|
|
|
SSD_MIN_SIZE,
|
1998-09-20 07:14:36 +00:00
|
|
|
/*timeout*/60 * 1000);
|
1998-09-15 06:33:23 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PROBE_MODE_SENSE:
|
|
|
|
{
|
|
|
|
void *mode_buf;
|
|
|
|
int mode_buf_len;
|
|
|
|
|
|
|
|
mode_buf_len = sizeof(struct scsi_mode_header_6)
|
|
|
|
+ sizeof(struct scsi_mode_blk_desc)
|
|
|
|
+ sizeof(struct scsi_control_page);
|
|
|
|
mode_buf = malloc(mode_buf_len, M_TEMP, M_NOWAIT);
|
|
|
|
if (mode_buf != NULL) {
|
|
|
|
scsi_mode_sense(csio,
|
|
|
|
/*retries*/4,
|
|
|
|
probedone,
|
|
|
|
MSG_SIMPLE_Q_TAG,
|
|
|
|
/*dbd*/FALSE,
|
|
|
|
SMS_PAGE_CTRL_CURRENT,
|
|
|
|
SMS_CONTROL_MODE_PAGE,
|
|
|
|
mode_buf,
|
|
|
|
mode_buf_len,
|
|
|
|
SSD_FULL_SIZE,
|
1998-09-20 07:14:36 +00:00
|
|
|
/*timeout*/60000);
|
1998-09-15 06:33:23 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
xpt_print_path(periph->path);
|
|
|
|
printf("Unable to mode sense control page - malloc failure\n");
|
|
|
|
softc->action = PROBE_SERIAL_NUM;
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
}
|
|
|
|
case PROBE_SERIAL_NUM:
|
|
|
|
{
|
|
|
|
struct scsi_vpd_unit_serial_number *serial_buf;
|
|
|
|
struct cam_ed* device;
|
|
|
|
|
|
|
|
serial_buf = NULL;
|
|
|
|
device = periph->path->device;
|
|
|
|
device->serial_num = NULL;
|
|
|
|
device->serial_num_len = 0;
|
|
|
|
|
|
|
|
if ((device->quirk->quirks & CAM_QUIRK_NOSERIAL) == 0)
|
|
|
|
serial_buf = (struct scsi_vpd_unit_serial_number *)
|
|
|
|
malloc(sizeof(*serial_buf), M_TEMP, M_NOWAIT);
|
|
|
|
|
|
|
|
if (serial_buf != NULL) {
|
|
|
|
bzero(serial_buf, sizeof(*serial_buf));
|
|
|
|
scsi_inquiry(csio,
|
|
|
|
/*retries*/4,
|
|
|
|
probedone,
|
|
|
|
MSG_SIMPLE_Q_TAG,
|
|
|
|
(u_int8_t *)serial_buf,
|
|
|
|
sizeof(*serial_buf),
|
|
|
|
/*evpd*/TRUE,
|
|
|
|
SVPD_UNIT_SERIAL_NUMBER,
|
|
|
|
SSD_MIN_SIZE,
|
1998-09-20 07:14:36 +00:00
|
|
|
/*timeout*/60 * 1000);
|
1998-09-15 06:33:23 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We'll have to do without, let our probedone
|
|
|
|
* routine finish up for us.
|
|
|
|
*/
|
|
|
|
start_ccb->csio.data_ptr = NULL;
|
|
|
|
probedone(periph, start_ccb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
xpt_action(start_ccb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
probedone(struct cam_periph *periph, union ccb *done_ccb)
|
|
|
|
{
|
|
|
|
probe_softc *softc;
|
|
|
|
struct cam_path *path;
|
|
|
|
u_int32_t priority;
|
|
|
|
|
|
|
|
CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("probedone\n"));
|
|
|
|
|
|
|
|
softc = (probe_softc *)periph->softc;
|
|
|
|
path = done_ccb->ccb_h.path;
|
|
|
|
priority = done_ccb->ccb_h.pinfo.priority;
|
|
|
|
|
|
|
|
switch (softc->action) {
|
|
|
|
case PROBE_TUR:
|
|
|
|
{
|
|
|
|
if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
|
|
|
|
|
|
|
|
if (cam_periph_error(done_ccb, 0,
|
|
|
|
SF_NO_PRINT, NULL) == ERESTART)
|
|
|
|
return;
|
|
|
|
else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
|
|
|
|
/* Don't wedge the queue */
|
|
|
|
xpt_release_devq(done_ccb->ccb_h.path->device,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
}
|
|
|
|
softc->action = PROBE_INQUIRY;
|
|
|
|
xpt_release_ccb(done_ccb);
|
|
|
|
xpt_schedule(periph, priority);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case PROBE_INQUIRY:
|
|
|
|
{
|
|
|
|
if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
|
|
|
|
struct scsi_inquiry_data *inq_buf;
|
|
|
|
u_int8_t periph_qual;
|
|
|
|
u_int8_t periph_dtype;
|
|
|
|
|
|
|
|
inq_buf = &path->device->inq_data;
|
|
|
|
|
|
|
|
periph_qual = SID_QUAL(inq_buf);
|
|
|
|
periph_dtype = SID_TYPE(inq_buf);
|
|
|
|
if (periph_dtype != T_NODEVICE) {
|
|
|
|
switch(periph_qual) {
|
|
|
|
case SID_QUAL_LU_CONNECTED:
|
|
|
|
{
|
|
|
|
xpt_find_quirk(path->device);
|
|
|
|
|
|
|
|
if ((inq_buf->flags & SID_CmdQue) != 0)
|
|
|
|
softc->action =
|
|
|
|
PROBE_MODE_SENSE;
|
|
|
|
else
|
|
|
|
softc->action =
|
|
|
|
PROBE_SERIAL_NUM;
|
|
|
|
|
|
|
|
path->device->flags &=
|
|
|
|
~CAM_DEV_UNCONFIGURED;
|
|
|
|
|
|
|
|
xpt_release_ccb(done_ccb);
|
|
|
|
xpt_schedule(periph, priority);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (cam_periph_error(done_ccb, 0,
|
|
|
|
done_ccb->ccb_h.target_lun > 0
|
|
|
|
? SF_RETRY_UA|SF_QUIET_IR
|
|
|
|
: SF_RETRY_UA,
|
|
|
|
&softc->saved_ccb) == ERESTART) {
|
|
|
|
return;
|
|
|
|
} else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
|
|
|
|
/* Don't wedge the queue */
|
|
|
|
xpt_release_devq(done_ccb->ccb_h.path->device,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we get to this point, we got an error status back
|
|
|
|
* from the inquiry and the error status doesn't require
|
|
|
|
* automatically retrying the command. Therefore, the
|
|
|
|
* inquiry failed. If we had inquiry information before
|
|
|
|
* for this device, but this latest inquiry command failed,
|
|
|
|
* the device has probably gone away. If this device isn't
|
|
|
|
* already marked unconfigured, notify the peripheral
|
|
|
|
* drivers that this device is no more.
|
|
|
|
*/
|
|
|
|
if ((path->device->flags & CAM_DEV_UNCONFIGURED) == 0)
|
|
|
|
/* Send the async notification. */
|
|
|
|
xpt_async(AC_LOST_DEVICE, path, NULL);
|
|
|
|
|
|
|
|
xpt_release_ccb(done_ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PROBE_MODE_SENSE:
|
|
|
|
{
|
|
|
|
struct ccb_scsiio *csio;
|
|
|
|
struct scsi_mode_header_6 *mode_hdr;
|
|
|
|
|
|
|
|
csio = &done_ccb->csio;
|
|
|
|
mode_hdr = (struct scsi_mode_header_6 *)csio->data_ptr;
|
|
|
|
if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
|
|
|
|
struct scsi_control_page *page;
|
|
|
|
u_int8_t *offset;
|
|
|
|
|
|
|
|
offset = ((u_int8_t *)&mode_hdr[1])
|
|
|
|
+ mode_hdr->blk_desc_len;
|
|
|
|
page = (struct scsi_control_page *)offset;
|
|
|
|
path->device->queue_flags = page->queue_flags;
|
|
|
|
} else if (cam_periph_error(done_ccb, 0,
|
|
|
|
SF_RETRY_UA|SF_NO_PRINT,
|
|
|
|
&softc->saved_ccb) == ERESTART) {
|
|
|
|
return;
|
|
|
|
} else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
|
|
|
|
/* Don't wedge the queue */
|
|
|
|
xpt_release_devq(done_ccb->ccb_h.path->device,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
}
|
|
|
|
xpt_release_ccb(done_ccb);
|
|
|
|
free(mode_hdr, M_TEMP);
|
|
|
|
softc->action = PROBE_SERIAL_NUM;
|
|
|
|
xpt_schedule(periph, priority);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case PROBE_SERIAL_NUM:
|
|
|
|
{
|
|
|
|
struct ccb_scsiio *csio;
|
|
|
|
struct scsi_vpd_unit_serial_number *serial_buf;
|
|
|
|
u_int32_t priority;
|
|
|
|
int changed;
|
|
|
|
int have_serialnum;
|
|
|
|
|
|
|
|
changed = 1;
|
|
|
|
have_serialnum = 0;
|
|
|
|
csio = &done_ccb->csio;
|
|
|
|
priority = done_ccb->ccb_h.pinfo.priority;
|
|
|
|
serial_buf =
|
|
|
|
(struct scsi_vpd_unit_serial_number *)csio->data_ptr;
|
|
|
|
|
|
|
|
/* Clean up from previous instance of this device */
|
|
|
|
if (path->device->serial_num != NULL) {
|
|
|
|
free(path->device->serial_num, M_DEVBUF);
|
|
|
|
path->device->serial_num = NULL;
|
|
|
|
path->device->serial_num_len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (serial_buf == NULL) {
|
|
|
|
/*
|
|
|
|
* Don't process the command as it was never sent
|
|
|
|
*/
|
|
|
|
} else if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP
|
|
|
|
&& (serial_buf->length > 0)) {
|
|
|
|
|
|
|
|
have_serialnum = 1;
|
|
|
|
path->device->serial_num =
|
|
|
|
(u_int8_t *)malloc((serial_buf->length + 1),
|
|
|
|
M_DEVBUF, M_NOWAIT);
|
|
|
|
if (path->device->serial_num != NULL) {
|
|
|
|
bcopy(serial_buf->serial_num,
|
|
|
|
path->device->serial_num,
|
|
|
|
serial_buf->length);
|
|
|
|
path->device->serial_num_len =
|
|
|
|
serial_buf->length;
|
|
|
|
path->device->serial_num[serial_buf->length]
|
|
|
|
= '\0';
|
|
|
|
}
|
|
|
|
} else if (cam_periph_error(done_ccb, 0,
|
|
|
|
SF_RETRY_UA|SF_NO_PRINT,
|
|
|
|
&softc->saved_ccb) == ERESTART) {
|
|
|
|
return;
|
|
|
|
} else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
|
|
|
|
/* Don't wedge the queue */
|
|
|
|
xpt_release_devq(done_ccb->ccb_h.path->device,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Let's see if we have seen this device before.
|
|
|
|
*/
|
|
|
|
if ((softc->flags & PROBE_INQUIRY_CKSUM) != 0) {
|
|
|
|
MD5_CTX context;
|
|
|
|
u_int8_t digest[16];
|
|
|
|
|
|
|
|
MD5Init(&context);
|
|
|
|
|
|
|
|
MD5Update(&context,
|
|
|
|
(unsigned char *)&path->device->inq_data,
|
|
|
|
sizeof(struct scsi_inquiry_data));
|
|
|
|
|
|
|
|
if (have_serialnum)
|
|
|
|
MD5Update(&context, serial_buf->serial_num,
|
|
|
|
serial_buf->length);
|
|
|
|
|
|
|
|
MD5Final(digest, &context);
|
|
|
|
if (bcmp(softc->digest, digest, 16) == 0)
|
|
|
|
changed = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX Do we need to do a TUR in order to ensure
|
|
|
|
* that the device really hasn't changed???
|
|
|
|
*/
|
|
|
|
if ((changed != 0)
|
|
|
|
&& ((softc->flags & PROBE_NO_ANNOUNCE) == 0))
|
|
|
|
xpt_async(AC_LOST_DEVICE, path, NULL);
|
|
|
|
}
|
|
|
|
if (serial_buf != NULL)
|
|
|
|
free(serial_buf, M_TEMP);
|
|
|
|
|
|
|
|
if (changed != 0) {
|
|
|
|
/*
|
|
|
|
* Now that we have all the necessary
|
|
|
|
* information to safely perform transfer
|
|
|
|
* negotiations... Controllers don't perform
|
|
|
|
* any negotiation or tagged queuing until
|
|
|
|
* after the first XPT_SET_TRAN_SETTINGS ccb is
|
|
|
|
* received. So, on a new device, just retreive
|
|
|
|
* the user settings, and set them as the current
|
|
|
|
* settings to set the device up.
|
|
|
|
*/
|
|
|
|
done_ccb->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
|
|
|
|
done_ccb->cts.flags = CCB_TRANS_USER_SETTINGS;
|
|
|
|
xpt_action(done_ccb);
|
|
|
|
done_ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
|
|
|
|
done_ccb->cts.flags &= ~CCB_TRANS_USER_SETTINGS;
|
|
|
|
done_ccb->cts.flags |= CCB_TRANS_CURRENT_SETTINGS;
|
|
|
|
xpt_action(done_ccb);
|
|
|
|
xpt_release_ccb(done_ccb);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform a TUR to allow the controller to
|
|
|
|
* perform any necessary transfer negotiation.
|
|
|
|
*/
|
|
|
|
softc->action = PROBE_TUR_FOR_NEGOTIATION;
|
|
|
|
xpt_schedule(periph, priority);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
xpt_release_ccb(done_ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PROBE_TUR_FOR_NEGOTIATION:
|
|
|
|
if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
|
|
|
|
/* Don't wedge the queue */
|
|
|
|
xpt_release_devq(done_ccb->ccb_h.path->device,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
path->device->flags &= ~CAM_DEV_UNCONFIGURED;
|
|
|
|
|
|
|
|
if ((softc->flags & PROBE_NO_ANNOUNCE) == 0) {
|
|
|
|
/* Inform the XPT that a new device has been found */
|
|
|
|
done_ccb->ccb_h.func_code = XPT_GDEV_TYPE;
|
|
|
|
xpt_action(done_ccb);
|
|
|
|
|
|
|
|
xpt_async(AC_FOUND_DEVICE, xpt_periph->path, done_ccb);
|
|
|
|
}
|
|
|
|
xpt_release_ccb(done_ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
done_ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs);
|
|
|
|
TAILQ_REMOVE(&softc->request_ccbs, &done_ccb->ccb_h, periph_links.tqe);
|
|
|
|
done_ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(done_ccb);
|
|
|
|
if (TAILQ_FIRST(&softc->request_ccbs) == NULL) {
|
|
|
|
cam_periph_invalidate(periph);
|
|
|
|
cam_periph_release(periph);
|
|
|
|
} else {
|
|
|
|
probeschedule(periph);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
probecleanup(struct cam_periph *periph)
|
|
|
|
{
|
|
|
|
free(periph->softc, M_TEMP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_find_quirk(struct cam_ed *device)
|
|
|
|
{
|
|
|
|
caddr_t match;
|
|
|
|
|
|
|
|
match = cam_quirkmatch((caddr_t)&device->inq_data,
|
|
|
|
(caddr_t)xpt_quirk_table,
|
|
|
|
sizeof(xpt_quirk_table)/sizeof(*xpt_quirk_table),
|
|
|
|
sizeof(*xpt_quirk_table), scsi_inquiry_match);
|
|
|
|
|
|
|
|
if (match == NULL)
|
|
|
|
panic("xpt_find_quirk: device didn't match wildcard entry!!");
|
|
|
|
|
|
|
|
device->quirk = (struct xpt_quirk_entry *)match;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
1998-09-25 22:35:56 +00:00
|
|
|
xpt_set_transfer_settings(struct ccb_trans_settings *cts, struct cam_ed *device,
|
|
|
|
int async_update)
|
1998-09-15 06:33:23 +00:00
|
|
|
{
|
|
|
|
struct cam_sim *sim;
|
|
|
|
int qfrozen;
|
|
|
|
|
|
|
|
sim = cts->ccb_h.path->bus->sim;
|
|
|
|
if (async_update == FALSE) {
|
|
|
|
struct scsi_inquiry_data *inq_data;
|
|
|
|
struct ccb_pathinq cpi;
|
|
|
|
|
1998-09-25 22:35:56 +00:00
|
|
|
if (device == NULL) {
|
|
|
|
cts->ccb_h.status = CAM_PATH_INVALID;
|
|
|
|
xpt_done((union ccb *)cts);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
/*
|
|
|
|
* Perform sanity checking against what the
|
|
|
|
* controller and device can do.
|
|
|
|
*/
|
|
|
|
xpt_setup_ccb(&cpi.ccb_h, cts->ccb_h.path, /*priority*/1);
|
|
|
|
cpi.ccb_h.func_code = XPT_PATH_INQ;
|
|
|
|
xpt_action((union ccb *)&cpi);
|
|
|
|
|
|
|
|
inq_data = &device->inq_data;
|
|
|
|
if ((inq_data->flags & SID_Sync) == 0
|
|
|
|
|| (cpi.hba_inquiry & PI_SDTR_ABLE) == 0) {
|
|
|
|
/* Force async */
|
|
|
|
cts->sync_period = 0;
|
|
|
|
cts->sync_offset = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (cts->bus_width) {
|
|
|
|
case MSG_EXT_WDTR_BUS_32_BIT:
|
|
|
|
if ((inq_data->flags & SID_WBus32) != 0
|
|
|
|
&& (cpi.hba_inquiry & PI_WIDE_32) != 0)
|
|
|
|
break;
|
|
|
|
/* Fall Through to 16-bit */
|
|
|
|
case MSG_EXT_WDTR_BUS_16_BIT:
|
|
|
|
if ((inq_data->flags & SID_WBus16) != 0
|
|
|
|
&& (cpi.hba_inquiry & PI_WIDE_16) != 0) {
|
|
|
|
cts->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Fall Through to 8-bit */
|
|
|
|
default: /* New bus width?? */
|
|
|
|
case MSG_EXT_WDTR_BUS_8_BIT:
|
|
|
|
/* All targets can do this */
|
|
|
|
cts->bus_width = MSG_EXT_WDTR_BUS_8_BIT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cts->flags & CCB_TRANS_DISC_ENB) == 0) {
|
|
|
|
/*
|
|
|
|
* Can't tag queue without disconnection.
|
|
|
|
*/
|
|
|
|
cts->flags &= ~CCB_TRANS_TAG_ENB;
|
1998-10-07 03:25:21 +00:00
|
|
|
cts->valid |= CCB_TRANS_TQ_VALID;
|
1998-09-15 06:33:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0
|
|
|
|
|| (inq_data->flags & SID_CmdQue) == 0
|
|
|
|
|| (device->queue_flags & SCP_QUEUE_DQUE) != 0
|
|
|
|
|| (device->quirk->mintags == 0)) {
|
|
|
|
/*
|
|
|
|
* Can't tag on hardware that doesn't support,
|
|
|
|
* doesn't have it enabled, or has broken tag support.
|
|
|
|
*/
|
|
|
|
cts->flags &= ~CCB_TRANS_TAG_ENB;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-09-23 03:03:19 +00:00
|
|
|
qfrozen = FALSE;
|
1998-09-25 22:35:56 +00:00
|
|
|
if ((cts->valid & CCB_TRANS_TQ_VALID) != 0) {
|
|
|
|
int device_tagenb;
|
1998-09-24 22:43:54 +00:00
|
|
|
|
1998-09-25 22:35:56 +00:00
|
|
|
/*
|
|
|
|
* If we are transitioning from tags to no-tags or
|
|
|
|
* vice-versa, we need to carefully freeze and restart
|
|
|
|
* the queue so that we don't overlap tagged and non-tagged
|
|
|
|
* commands. We also temporarily stop tags if there is
|
|
|
|
* a change in transfer negotiation settings to allow
|
|
|
|
* "tag-less" negotiation.
|
|
|
|
*/
|
|
|
|
if ((device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0
|
|
|
|
|| (device->inq_flags & SID_CmdQue) != 0)
|
|
|
|
device_tagenb = TRUE;
|
|
|
|
else
|
|
|
|
device_tagenb = FALSE;
|
1998-09-15 06:33:23 +00:00
|
|
|
|
1998-09-25 22:35:56 +00:00
|
|
|
if (((cts->flags & CCB_TRANS_TAG_ENB) != 0
|
|
|
|
&& device_tagenb == FALSE)
|
|
|
|
|| ((cts->flags & CCB_TRANS_TAG_ENB) == 0
|
|
|
|
&& device_tagenb == TRUE)) {
|
|
|
|
|
|
|
|
if ((cts->flags & CCB_TRANS_TAG_ENB) != 0) {
|
|
|
|
/*
|
|
|
|
* Delay change to use tags until after a
|
|
|
|
* few commands have gone to this device so
|
|
|
|
* the controller has time to perform transfer
|
|
|
|
* negotiations without tagged messages getting
|
|
|
|
* in the way.
|
|
|
|
*/
|
|
|
|
device->tag_delay_count = CAM_TAG_DELAY_COUNT;
|
|
|
|
device->flags |= CAM_DEV_TAG_AFTER_COUNT;
|
|
|
|
} else {
|
|
|
|
xpt_freeze_devq(cts->ccb_h.path, /*count*/1);
|
|
|
|
qfrozen = TRUE;
|
|
|
|
device->inq_flags &= ~SID_CmdQue;
|
|
|
|
xpt_dev_ccbq_resize(cts->ccb_h.path,
|
|
|
|
sim->max_dev_openings);
|
|
|
|
device->flags &= ~CAM_DEV_TAG_AFTER_COUNT;
|
|
|
|
device->tag_delay_count = 0;
|
|
|
|
}
|
|
|
|
} else if ((cts->flags & (CCB_TRANS_SYNC_RATE_VALID|
|
|
|
|
CCB_TRANS_SYNC_OFFSET_VALID|
|
|
|
|
CCB_TRANS_BUS_WIDTH_VALID)) != 0) {
|
|
|
|
xpt_toggle_tags(cts->ccb_h.path);
|
1998-09-15 06:33:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (async_update == FALSE)
|
|
|
|
(*(sim->sim_action))(sim, (union ccb *)cts);
|
|
|
|
|
|
|
|
if (qfrozen) {
|
|
|
|
struct ccb_relsim crs;
|
|
|
|
|
|
|
|
xpt_setup_ccb(&crs.ccb_h, cts->ccb_h.path,
|
|
|
|
/*priority*/1);
|
|
|
|
crs.ccb_h.func_code = XPT_REL_SIMQ;
|
|
|
|
crs.release_flags = RELSIM_RELEASE_AFTER_QEMPTY;
|
|
|
|
crs.openings
|
|
|
|
= crs.release_timeout
|
|
|
|
= crs.qfrozen_cnt
|
|
|
|
= 0;
|
|
|
|
xpt_action((union ccb *)&crs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-09-23 03:03:19 +00:00
|
|
|
static void
|
1998-09-24 22:43:54 +00:00
|
|
|
xpt_toggle_tags(struct cam_path *path)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Give controllers a chance to renegotiate
|
|
|
|
* before starting tag operations. We
|
|
|
|
* "toggle" tagged queuing off then on
|
|
|
|
* which causes the tag enable command delay
|
|
|
|
* counter to come into effect.
|
|
|
|
*/
|
|
|
|
if ((path->device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0
|
|
|
|
|| (path->device->inq_flags & SID_CmdQue) != 0) {
|
|
|
|
struct ccb_trans_settings cts;
|
|
|
|
|
|
|
|
xpt_setup_ccb(&cts.ccb_h, path, 1);
|
|
|
|
cts.flags = 0;
|
|
|
|
cts.valid = CCB_TRANS_TQ_VALID;
|
1998-09-25 22:35:56 +00:00
|
|
|
xpt_set_transfer_settings(&cts, path->device,
|
|
|
|
/*async_update*/TRUE);
|
1998-09-24 22:43:54 +00:00
|
|
|
cts.flags = CCB_TRANS_TAG_ENB;
|
1998-09-25 22:35:56 +00:00
|
|
|
xpt_set_transfer_settings(&cts, path->device,
|
|
|
|
/*async_update*/TRUE);
|
1998-09-24 22:43:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_start_tags(struct cam_path *path)
|
|
|
|
{
|
1998-09-23 03:03:19 +00:00
|
|
|
struct ccb_relsim crs;
|
|
|
|
struct cam_ed *device;
|
|
|
|
struct cam_sim *sim;
|
|
|
|
int newopenings;
|
|
|
|
|
|
|
|
device = path->device;
|
|
|
|
sim = path->bus->sim;
|
|
|
|
device->flags &= ~CAM_DEV_TAG_AFTER_COUNT;
|
|
|
|
xpt_freeze_devq(path, /*count*/1);
|
|
|
|
device->inq_flags |= SID_CmdQue;
|
|
|
|
newopenings = min(device->quirk->maxtags, sim->max_tagged_dev_openings);
|
1998-09-24 22:43:54 +00:00
|
|
|
xpt_dev_ccbq_resize(path, newopenings);
|
1998-09-23 03:03:19 +00:00
|
|
|
xpt_setup_ccb(&crs.ccb_h, path, /*priority*/1);
|
|
|
|
crs.ccb_h.func_code = XPT_REL_SIMQ;
|
|
|
|
crs.release_flags = RELSIM_RELEASE_AFTER_QEMPTY;
|
|
|
|
crs.openings
|
|
|
|
= crs.release_timeout
|
|
|
|
= crs.qfrozen_cnt
|
|
|
|
= 0;
|
|
|
|
xpt_action((union ccb *)&crs);
|
|
|
|
}
|
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
static int busses_to_config;
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptconfigbuscountfunc(struct cam_eb *bus, void *arg)
|
|
|
|
{
|
|
|
|
if (bus->path_id != CAM_XPT_PATH_ID)
|
|
|
|
busses_to_config++;
|
|
|
|
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptconfigfunc(struct cam_eb *bus, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_path *path;
|
|
|
|
union ccb *work_ccb;
|
|
|
|
|
|
|
|
if (bus->path_id != CAM_XPT_PATH_ID) {
|
|
|
|
cam_status status;
|
|
|
|
|
|
|
|
work_ccb = xpt_alloc_ccb();
|
|
|
|
if ((status = xpt_create_path(&path, xpt_periph, bus->path_id,
|
|
|
|
CAM_TARGET_WILDCARD,
|
|
|
|
CAM_LUN_WILDCARD)) !=CAM_REQ_CMP){
|
|
|
|
printf("xptconfigfunc: xpt_create_path failed with "
|
|
|
|
"status %#x for bus %d\n", status, bus->path_id);
|
|
|
|
printf("xptconfigfunc: halting bus configuration\n");
|
|
|
|
xpt_free_ccb(work_ccb);
|
1998-12-10 04:05:49 +00:00
|
|
|
busses_to_config--;
|
|
|
|
xpt_finishconfig(xpt_periph, NULL);
|
1998-09-15 06:33:23 +00:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
xpt_setup_ccb(&work_ccb->ccb_h, path, /*priority*/1);
|
1998-12-10 04:05:49 +00:00
|
|
|
work_ccb->ccb_h.func_code = XPT_PATH_INQ;
|
1998-09-15 06:33:23 +00:00
|
|
|
xpt_action(work_ccb);
|
1998-12-10 04:05:49 +00:00
|
|
|
if (work_ccb->ccb_h.status != CAM_REQ_CMP) {
|
|
|
|
printf("xptconfigfunc: CPI failed on bus %d "
|
|
|
|
"with status %d\n", bus->path_id,
|
|
|
|
work_ccb->ccb_h.status);
|
|
|
|
xpt_finishconfig(xpt_periph, work_ccb);
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((work_ccb->cpi.hba_misc & PIM_NOBUSRESET) == 0) {
|
|
|
|
xpt_setup_ccb(&work_ccb->ccb_h, path, /*priority*/1);
|
|
|
|
work_ccb->ccb_h.func_code = XPT_RESET_BUS;
|
|
|
|
work_ccb->ccb_h.cbfcnp = NULL;
|
|
|
|
CAM_DEBUG(path, CAM_DEBUG_SUBTRACE,
|
|
|
|
("Resetting Bus\n"));
|
|
|
|
xpt_action(work_ccb);
|
|
|
|
xpt_finishconfig(xpt_periph, work_ccb);
|
|
|
|
} else {
|
|
|
|
/* Act as though we performed a successful BUS RESET */
|
|
|
|
work_ccb->ccb_h.func_code = XPT_RESET_BUS;
|
|
|
|
xpt_finishconfig(xpt_periph, work_ccb);
|
|
|
|
}
|
1998-09-15 06:33:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return(1);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_config(void *arg)
|
|
|
|
{
|
|
|
|
/* Now that interrupts are enabled, go find our devices */
|
|
|
|
|
|
|
|
#ifdef CAMDEBUG
|
|
|
|
/* Setup debugging flags and path */
|
|
|
|
#ifdef CAM_DEBUG_FLAGS
|
|
|
|
cam_dflags = CAM_DEBUG_FLAGS;
|
|
|
|
#else /* !CAM_DEBUG_FLAGS */
|
|
|
|
cam_dflags = CAM_DEBUG_NONE;
|
|
|
|
#endif /* CAM_DEBUG_FLAGS */
|
|
|
|
#ifdef CAM_DEBUG_BUS
|
|
|
|
if (cam_dflags != CAM_DEBUG_NONE) {
|
|
|
|
if (xpt_create_path(&cam_dpath, xpt_periph,
|
|
|
|
CAM_DEBUG_BUS, CAM_DEBUG_TARGET,
|
|
|
|
CAM_DEBUG_LUN) != CAM_REQ_CMP) {
|
|
|
|
printf("xpt_config: xpt_create_path() failed for debug"
|
|
|
|
" target %d:%d:%d, debugging disabled\n",
|
|
|
|
CAM_DEBUG_BUS, CAM_DEBUG_TARGET, CAM_DEBUG_LUN);
|
|
|
|
cam_dflags = CAM_DEBUG_NONE;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
cam_dpath = NULL;
|
|
|
|
#else /* !CAM_DEBUG_BUS */
|
|
|
|
cam_dpath = NULL;
|
|
|
|
#endif /* CAM_DEBUG_BUS */
|
|
|
|
#endif /* CAMDEBUG */
|
|
|
|
|
|
|
|
/* Scan all installed busses */
|
|
|
|
xpt_for_all_busses(xptconfigbuscountfunc, NULL);
|
|
|
|
|
1998-09-20 05:03:34 +00:00
|
|
|
if (busses_to_config == 0) {
|
|
|
|
/* Call manually because we don't have any busses */
|
|
|
|
xpt_finishconfig(xpt_periph, NULL);
|
1998-10-10 21:10:36 +00:00
|
|
|
} else {
|
|
|
|
if (SCSI_DELAY >= 2000) {
|
|
|
|
printf("Waiting %d seconds for SCSI "
|
|
|
|
"devices to settle\n", SCSI_DELAY/1000);
|
|
|
|
}
|
1998-09-20 05:03:34 +00:00
|
|
|
xpt_for_all_busses(xptconfigfunc, NULL);
|
1998-10-10 21:10:36 +00:00
|
|
|
}
|
1998-09-15 06:33:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xptfinishconfigfunc(struct cam_ed *device, void *arg)
|
|
|
|
{
|
1998-09-17 23:58:53 +00:00
|
|
|
union ccb work_ccb;
|
|
|
|
struct cam_path path;
|
1998-09-15 06:33:23 +00:00
|
|
|
cam_status status;
|
|
|
|
|
1998-09-17 23:58:53 +00:00
|
|
|
if ((status = xpt_compile_path(&path, xpt_periph,
|
|
|
|
device->target->bus->path_id,
|
|
|
|
device->target->target_id,
|
|
|
|
device->lun_id)) != CAM_REQ_CMP) {
|
|
|
|
printf("xptfinishconfig: xpt_compile_path failed with status"
|
|
|
|
" %#x, halting device registration\n", status);
|
1998-09-15 06:33:23 +00:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
1998-09-17 23:58:53 +00:00
|
|
|
xpt_setup_ccb(&work_ccb.ccb_h, &path, /*priority*/1);
|
1998-09-15 06:33:23 +00:00
|
|
|
|
1998-09-17 23:58:53 +00:00
|
|
|
work_ccb.ccb_h.func_code = XPT_GDEV_TYPE;
|
|
|
|
xpt_action(&work_ccb);
|
|
|
|
xpt_async(AC_FOUND_DEVICE, &path, &work_ccb);
|
1998-09-15 06:33:23 +00:00
|
|
|
|
1998-09-17 23:58:53 +00:00
|
|
|
xpt_release_path(&path);
|
1998-09-15 06:33:23 +00:00
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the given device only has one peripheral attached to it, and if that
|
|
|
|
* peripheral is the passthrough driver, announce it. This insures that the
|
|
|
|
* user sees some sort of announcement for every peripheral in their system.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xptpassannouncefunc(struct cam_ed *device, void *arg)
|
|
|
|
{
|
|
|
|
struct cam_periph *periph;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (periph = SLIST_FIRST(&device->periphs), i = 0; periph != NULL;
|
|
|
|
periph = SLIST_NEXT(periph, periph_links), i++);
|
|
|
|
|
|
|
|
periph = SLIST_FIRST(&device->periphs);
|
|
|
|
if ((i == 1)
|
|
|
|
&& (strncmp(periph->periph_name, "pass", 4) == 0))
|
|
|
|
xpt_announce_periph(periph, NULL);
|
|
|
|
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xpt_finishconfig(struct cam_periph *periph, union ccb *done_ccb)
|
|
|
|
{
|
|
|
|
struct periph_driver **p_drv;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (done_ccb != NULL) {
|
|
|
|
CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_TRACE,
|
|
|
|
("xpt_finishconfig\n"));
|
|
|
|
switch(done_ccb->ccb_h.func_code) {
|
|
|
|
case XPT_RESET_BUS:
|
|
|
|
if (done_ccb->ccb_h.status == CAM_REQ_CMP) {
|
|
|
|
done_ccb->ccb_h.func_code = XPT_SCAN_BUS;
|
|
|
|
done_ccb->ccb_h.cbfcnp = xpt_finishconfig;
|
|
|
|
xpt_action(done_ccb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case XPT_SCAN_BUS:
|
1998-12-10 04:05:49 +00:00
|
|
|
default:
|
1998-09-15 06:33:23 +00:00
|
|
|
xpt_free_path(done_ccb->ccb_h.path);
|
|
|
|
busses_to_config--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (busses_to_config == 0) {
|
|
|
|
/* Register all the peripheral drivers */
|
|
|
|
/* XXX This will have to change when we have LKMs */
|
|
|
|
p_drv = (struct periph_driver **)periphdriver_set.ls_items;
|
|
|
|
for (i = 0; p_drv[i] != NULL; i++) {
|
|
|
|
(*p_drv[i]->init)();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Itterate through our devices announcing
|
|
|
|
* them in probed bus order.
|
|
|
|
*/
|
1998-09-17 23:58:53 +00:00
|
|
|
xpt_for_all_devices(xptfinishconfigfunc, NULL);
|
1998-09-15 06:33:23 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for devices with no "standard" peripheral driver
|
|
|
|
* attached. For any devices like that, announce the
|
|
|
|
* passthrough driver so the user will see something.
|
|
|
|
*/
|
|
|
|
xpt_for_all_devices(xptpassannouncefunc, NULL);
|
|
|
|
|
|
|
|
/* Release our hook so that the boot can continue. */
|
|
|
|
config_intrhook_disestablish(xpt_config_hook);
|
|
|
|
}
|
|
|
|
if (done_ccb != NULL)
|
|
|
|
xpt_free_ccb(done_ccb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
xptaction(struct cam_sim *sim, union ccb *work_ccb)
|
|
|
|
{
|
|
|
|
CAM_DEBUG(work_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("xptaction\n"));
|
|
|
|
|
|
|
|
switch (work_ccb->ccb_h.func_code) {
|
|
|
|
/* Common cases first */
|
|
|
|
case XPT_PATH_INQ: /* Path routing inquiry */
|
|
|
|
{
|
|
|
|
struct ccb_pathinq *cpi;
|
|
|
|
|
|
|
|
cpi = &work_ccb->cpi;
|
|
|
|
cpi->version_num = 1; /* XXX??? */
|
|
|
|
cpi->hba_inquiry = 0;
|
|
|
|
cpi->target_sprt = 0;
|
|
|
|
cpi->hba_misc = 0;
|
|
|
|
cpi->hba_eng_cnt = 0;
|
|
|
|
cpi->max_target = 0;
|
|
|
|
cpi->max_lun = 0;
|
|
|
|
cpi->initiator_id = 0;
|
|
|
|
strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
|
|
|
|
strncpy(cpi->hba_vid, "", HBA_IDLEN);
|
|
|
|
strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN);
|
|
|
|
cpi->unit_number = sim->unit_number;
|
|
|
|
cpi->bus_id = sim->bus_id;
|
|
|
|
cpi->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(work_ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
work_ccb->ccb_h.status = CAM_REQ_INVALID;
|
|
|
|
xpt_done(work_ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Should only be called by the machine interrupt dispatch routines,
|
|
|
|
* so put these prototypes here instead of in the header.
|
|
|
|
*
|
|
|
|
* XXX we should really have a way to dynamically register SWI handlers.
|
|
|
|
*/
|
|
|
|
|
1998-12-22 20:05:23 +00:00
|
|
|
static void
|
1998-09-15 06:33:23 +00:00
|
|
|
swi_camnet()
|
|
|
|
{
|
|
|
|
camisr(&cam_netq);
|
|
|
|
}
|
|
|
|
|
1998-12-22 20:05:23 +00:00
|
|
|
static void
|
1998-09-15 06:33:23 +00:00
|
|
|
swi_cambio()
|
|
|
|
{
|
|
|
|
camisr(&cam_bioq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
camisr(cam_isrq_t *queue)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
struct ccb_hdr *ccb_h;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
while ((ccb_h = TAILQ_FIRST(queue)) != NULL) {
|
|
|
|
int runq;
|
|
|
|
|
|
|
|
TAILQ_REMOVE(queue, ccb_h, sim_links.tqe);
|
|
|
|
ccb_h->pinfo.index = CAM_UNQUEUED_INDEX;
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
CAM_DEBUG(ccb_h->path, CAM_DEBUG_TRACE,
|
|
|
|
("camisr"));
|
|
|
|
|
|
|
|
runq = FALSE;
|
|
|
|
|
|
|
|
if (ccb_h->flags & CAM_HIGH_POWER) {
|
|
|
|
struct highpowerlist *hphead;
|
|
|
|
struct cam_ed *device;
|
|
|
|
union ccb *send_ccb;
|
|
|
|
|
|
|
|
hphead = &highpowerq;
|
|
|
|
|
|
|
|
send_ccb = (union ccb *)STAILQ_FIRST(hphead);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Increment the count since this command is done.
|
|
|
|
*/
|
|
|
|
num_highpower++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Any high powered commands queued up?
|
|
|
|
*/
|
|
|
|
if (send_ccb != NULL) {
|
|
|
|
device = send_ccb->ccb_h.path->device;
|
|
|
|
|
|
|
|
STAILQ_REMOVE_HEAD(hphead, xpt_links.stqe);
|
|
|
|
|
|
|
|
xpt_release_devq(send_ccb->ccb_h.path->device,
|
|
|
|
TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((ccb_h->func_code != XPT_ACCEPT_TARGET_IO)
|
|
|
|
&& (ccb_h->func_code != XPT_SCAN_LUN)
|
|
|
|
&& (ccb_h->func_code != XPT_SCAN_BUS)) {
|
|
|
|
struct cam_ed *dev;
|
|
|
|
|
|
|
|
dev = ccb_h->path->device;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
cam_ccbq_ccb_done(&dev->ccbq, (union ccb *)ccb_h);
|
|
|
|
|
|
|
|
ccb_h->path->bus->sim->devq->send_active--;
|
|
|
|
ccb_h->path->bus->sim->devq->send_openings++;
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
if ((dev->flags & CAM_DEV_REL_ON_COMPLETE) != 0
|
|
|
|
|| ((dev->flags & CAM_DEV_REL_ON_QUEUE_EMPTY) != 0
|
|
|
|
&& (dev->ccbq.dev_active == 0))) {
|
|
|
|
|
|
|
|
xpt_release_devq(ccb_h->path->device,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
}
|
|
|
|
|
1998-09-23 03:03:19 +00:00
|
|
|
if ((dev->flags & CAM_DEV_TAG_AFTER_COUNT) != 0
|
|
|
|
&& (--dev->tag_delay_count == 0))
|
|
|
|
xpt_start_tags(ccb_h->path);
|
|
|
|
|
1998-09-15 06:33:23 +00:00
|
|
|
if ((dev->ccbq.queue.entries > 0)
|
|
|
|
&& (dev->qfrozen_cnt == 0)
|
|
|
|
&& (device_is_send_queued(dev) == 0)) {
|
|
|
|
runq = xpt_schedule_dev_sendq(ccb_h->path->bus,
|
|
|
|
dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ccb_h->status & CAM_RELEASE_SIMQ) {
|
|
|
|
xpt_release_simq(ccb_h->path->bus->sim,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
} else if ((ccb_h->flags & CAM_DEV_QFRZDIS)
|
|
|
|
&& (ccb_h->status & CAM_DEV_QFRZN)) {
|
|
|
|
xpt_release_devq(ccb_h->path->device,
|
|
|
|
/*run_queue*/TRUE);
|
|
|
|
ccb_h->status &= ~CAM_DEV_QFRZN;
|
|
|
|
} else if (runq) {
|
|
|
|
xpt_run_dev_sendq(ccb_h->path->bus);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Call the peripheral driver's callback */
|
|
|
|
(*ccb_h->cbfcnp)(ccb_h->path->periph,
|
|
|
|
(union ccb *)ccb_h);
|
|
|
|
|
|
|
|
/* Raise IPL for while test */
|
|
|
|
s = splcam();
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
}
|