393 lines
9.2 KiB
C
393 lines
9.2 KiB
C
/* $OpenBSD: mpath_rdac.c,v 1.27 2022/07/02 08:50:42 visa Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2010 David Gwynne <dlg@openbsd.org>
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
/* Redundant Disk Array Controller support for mpath(4) */
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/device.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/rwlock.h>
|
|
#include <sys/pool.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <scsi/scsi_all.h>
|
|
#include <scsi/scsiconf.h>
|
|
#include <scsi/mpathvar.h>
|
|
|
|
struct rdac_common_mode_page {
|
|
u_int8_t controller_serial[16];
|
|
u_int8_t alt_controller_serial[16];
|
|
u_int8_t mode[2];
|
|
u_int8_t alt_mode[2];
|
|
u_int8_t timeout;
|
|
u_int8_t options;
|
|
};
|
|
|
|
/*
|
|
* RDAC VPD pages
|
|
*/
|
|
#define RDAC_VPD_HDWVER 0xc0 /* Hardware Version */
|
|
#define RDAC_VPD_SERNUM 0xc1 /* Serial Numbers */
|
|
#define RDAC_VPD_SFWVER 0xc2
|
|
#define RDAC_VPD_FEAPAR 0xc3 /* Feature Parameters */
|
|
#define RDAC_VPD_SUBSYS 0xc4
|
|
#define RDAC_VPD_HSTINT 0xc5
|
|
#define RDAC_VPD_DGM 0xc6
|
|
#define RDAC_VPD_HSTINT2 0xc7
|
|
#define RDAC_VPD_EXTDEVID 0xc8
|
|
#define RDAC_VPD_VOLACCESSCTL 0xc9
|
|
|
|
struct rdac_vpd_hdwver {
|
|
struct scsi_vpd_hdr hdr; /* RDAC_VPD_HDWVER */
|
|
u_int8_t pg_id[4];
|
|
#define RDAC_VPD_ID_HDWVER 0x68777234 /* "hwr4" */
|
|
u_int8_t num_channels;
|
|
u_int8_t flags;
|
|
u_int8_t proc_memory_size;
|
|
u_int8_t _reserved1[5];
|
|
u_int8_t board_name[64];
|
|
u_int8_t board_part_number[16];
|
|
u_int8_t schematic_number[12];
|
|
u_int8_t schematic_revision[4];
|
|
u_int8_t serial_number[16];
|
|
u_int8_t _reserved2[16];
|
|
u_int8_t date_manufactured[8];
|
|
u_int8_t board_revision[2];
|
|
u_int8_t board_identifier[4];
|
|
};
|
|
|
|
struct rdac_vpd_subsys {
|
|
struct scsi_vpd_hdr hdr; /* RDAC_VPD_SUBSYS */
|
|
u_int8_t pg_id[4];
|
|
#define RDAC_VPD_ID_SUBSYS 0x73756273 /* "subs" */
|
|
u_int8_t subsystem_id[16];
|
|
u_int8_t subsystem_revision[4];
|
|
u_int8_t controller_slot_id[2];
|
|
u_int8_t _reserved[2];
|
|
};
|
|
|
|
struct rdac_vpd_extdevid {
|
|
struct scsi_vpd_hdr hdr; /* RDAC_VPD_EXTDEVID */
|
|
u_int8_t pg_id[4];
|
|
#define RDAC_VPD_ID_EXTDEVID 0x65646964 /* "edid" */
|
|
u_int8_t _reserved[3];
|
|
u_int8_t vol_id_len;
|
|
u_int8_t vol_id[16];
|
|
u_int8_t vol_label_len;
|
|
u_int8_t vol_label[60];
|
|
u_int8_t array_id_len;
|
|
u_int8_t array_id[16];
|
|
u_int8_t array_label_len;
|
|
u_int8_t array_label[60];
|
|
u_int8_t lun[8];
|
|
};
|
|
|
|
struct rdac_vpd_volaccessctl {
|
|
struct scsi_vpd_hdr hdr; /* RDAC_VPD_VOLACCESSCTL */
|
|
u_int8_t pg_id[4];
|
|
#define RDAC_VPD_ID_VOLACCESSCTL 0x76616331 /* "vac1" */
|
|
u_int8_t avtcvp;
|
|
#define RDAC_VOLACCESSCTL_OWNER 0x01
|
|
#define RDAC_VOLACCESSCTL_AVT 0x70
|
|
u_int8_t _reserved1;
|
|
u_int8_t asym_access_state_cur;
|
|
u_int8_t vendor_specific_cur;
|
|
u_int8_t _reserved[36];
|
|
};
|
|
|
|
struct rdac_softc {
|
|
struct device sc_dev;
|
|
struct mpath_path sc_path;
|
|
struct scsi_xshandler sc_xsh;
|
|
struct rdac_vpd_volaccessctl *sc_pg;
|
|
};
|
|
#define DEVNAME(_s) ((_s)->sc_dev.dv_xname)
|
|
|
|
int rdac_match(struct device *, void *, void *);
|
|
void rdac_attach(struct device *, struct device *, void *);
|
|
int rdac_detach(struct device *, int);
|
|
int rdac_activate(struct device *, int);
|
|
|
|
const struct cfattach rdac_ca = {
|
|
sizeof(struct rdac_softc),
|
|
rdac_match,
|
|
rdac_attach,
|
|
rdac_detach,
|
|
rdac_activate
|
|
};
|
|
|
|
struct cfdriver rdac_cd = {
|
|
NULL,
|
|
"rdac",
|
|
DV_DULL
|
|
};
|
|
|
|
void rdac_mpath_start(struct scsi_xfer *);
|
|
int rdac_mpath_checksense(struct scsi_xfer *);
|
|
void rdac_mpath_status(struct scsi_link *);
|
|
|
|
const struct mpath_ops rdac_mpath_ops = {
|
|
"rdac",
|
|
rdac_mpath_checksense,
|
|
rdac_mpath_status
|
|
};
|
|
|
|
int rdac_extdevid(struct rdac_softc *);
|
|
int rdac_groupid(struct rdac_softc *);
|
|
|
|
void rdac_status(struct scsi_xfer *);
|
|
void rdac_status_done(struct scsi_xfer *);
|
|
|
|
struct rdac_device {
|
|
char *vendor;
|
|
char *product;
|
|
};
|
|
|
|
struct rdac_device rdac_devices[] = {
|
|
/* " vendor " " device " */
|
|
/* "01234567" "0123456789012345" */
|
|
{ "SUN ", "CSM200_" },
|
|
{ "DELL ", "MD3000 " },
|
|
{ "DELL ", "MD3000i " },
|
|
{ "DELL ", "MD32xx " },
|
|
{ "DELL ", "MD32xxi " }
|
|
};
|
|
|
|
int
|
|
rdac_match(struct device *parent, void *match, void *aux)
|
|
{
|
|
struct scsi_attach_args *sa = aux;
|
|
struct scsi_inquiry_data *inq = &sa->sa_sc_link->inqdata;
|
|
struct rdac_device *s;
|
|
int i;
|
|
|
|
if (mpath_path_probe(sa->sa_sc_link) != 0)
|
|
return (0);
|
|
|
|
for (i = 0; i < nitems(rdac_devices); i++) {
|
|
s = &rdac_devices[i];
|
|
|
|
if (bcmp(s->vendor, inq->vendor, strlen(s->vendor)) == 0 &&
|
|
bcmp(s->product, inq->product, strlen(s->product)) == 0)
|
|
return (8);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
rdac_attach(struct device *parent, struct device *self, void *aux)
|
|
{
|
|
struct rdac_softc *sc = (struct rdac_softc *)self;
|
|
struct scsi_attach_args *sa = aux;
|
|
struct scsi_link *link = sa->sa_sc_link;
|
|
int id;
|
|
|
|
printf("\n");
|
|
|
|
/* init link */
|
|
link->device_softc = sc;
|
|
|
|
/* init path */
|
|
scsi_xsh_set(&sc->sc_path.p_xsh, link, rdac_mpath_start);
|
|
sc->sc_path.p_link = link;
|
|
|
|
/* init status handler */
|
|
scsi_xsh_set(&sc->sc_xsh, link, rdac_status);
|
|
sc->sc_pg = dma_alloc(sizeof(*sc->sc_pg), PR_WAITOK);
|
|
|
|
/* let's go */
|
|
if (rdac_extdevid(sc) != 0)
|
|
return;
|
|
|
|
id = rdac_groupid(sc);
|
|
if (id == -1) {
|
|
/* error printed by rdac_groupid */
|
|
return;
|
|
}
|
|
|
|
if (mpath_path_attach(&sc->sc_path, id, &rdac_mpath_ops) != 0)
|
|
printf("%s: unable to attach path\n", DEVNAME(sc));
|
|
}
|
|
|
|
int
|
|
rdac_detach(struct device *self, int flags)
|
|
{
|
|
struct rdac_softc *sc = (struct rdac_softc *)self;
|
|
|
|
dma_free(sc->sc_pg, sizeof(*sc->sc_pg));
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
rdac_activate(struct device *self, int act)
|
|
{
|
|
struct rdac_softc *sc = (struct rdac_softc *)self;
|
|
|
|
switch (act) {
|
|
case DVACT_DEACTIVATE:
|
|
if (scsi_xsh_del(&sc->sc_xsh))
|
|
mpath_path_status(&sc->sc_path, MPATH_S_UNKNOWN);
|
|
if (sc->sc_path.p_group != NULL)
|
|
mpath_path_detach(&sc->sc_path);
|
|
break;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
rdac_mpath_start(struct scsi_xfer *xs)
|
|
{
|
|
struct rdac_softc *sc = xs->sc_link->device_softc;
|
|
|
|
mpath_start(&sc->sc_path, xs);
|
|
}
|
|
|
|
int
|
|
rdac_mpath_checksense(struct scsi_xfer *xs)
|
|
{
|
|
struct scsi_sense_data *sense = &xs->sense;
|
|
u_int8_t skey;
|
|
|
|
if ((sense->error_code & SSD_ERRCODE) != SSD_ERRCODE_CURRENT)
|
|
return (MPATH_SENSE_DECLINED);
|
|
|
|
skey = sense->flags & SSD_KEY;
|
|
|
|
/* i wish i knew what the magic numbers meant */
|
|
|
|
/* invalid request due to current lu ownership */
|
|
if (skey == SKEY_ILLEGAL_REQUEST && ASC_ASCQ(sense) == 0x9401)
|
|
return (MPATH_SENSE_FAILOVER);
|
|
|
|
if (skey == SKEY_UNIT_ATTENTION && ASC_ASCQ(sense) == 0x8b02)
|
|
return (MPATH_SENSE_FAILOVER);
|
|
|
|
return (MPATH_SENSE_DECLINED);
|
|
}
|
|
|
|
void
|
|
rdac_mpath_status(struct scsi_link *link)
|
|
{
|
|
struct rdac_softc *sc = link->device_softc;
|
|
|
|
scsi_xsh_add(&sc->sc_xsh);
|
|
}
|
|
|
|
void
|
|
rdac_status(struct scsi_xfer *xs)
|
|
{
|
|
struct scsi_link *link = xs->sc_link;
|
|
struct rdac_softc *sc = link->device_softc;
|
|
|
|
scsi_init_inquiry(xs, SI_EVPD, RDAC_VPD_VOLACCESSCTL,
|
|
sc->sc_pg, sizeof(*sc->sc_pg));
|
|
|
|
xs->done = rdac_status_done;
|
|
|
|
scsi_xs_exec(xs);
|
|
}
|
|
|
|
void
|
|
rdac_status_done(struct scsi_xfer *xs)
|
|
{
|
|
struct scsi_link *link = xs->sc_link;
|
|
struct rdac_softc *sc = link->device_softc;
|
|
struct rdac_vpd_volaccessctl *pg = sc->sc_pg;
|
|
int status = MPATH_S_UNKNOWN;
|
|
|
|
if (xs->error == XS_NOERROR &&
|
|
_4btol(pg->pg_id) == RDAC_VPD_ID_VOLACCESSCTL) {
|
|
status = (ISSET(pg->avtcvp, RDAC_VOLACCESSCTL_AVT) ||
|
|
ISSET(pg->avtcvp, RDAC_VOLACCESSCTL_OWNER)) ?
|
|
MPATH_S_ACTIVE : MPATH_S_PASSIVE;
|
|
}
|
|
|
|
scsi_xs_put(xs);
|
|
mpath_path_status(&sc->sc_path, status);
|
|
}
|
|
|
|
int
|
|
rdac_groupid(struct rdac_softc *sc)
|
|
{
|
|
struct rdac_vpd_subsys *pg;
|
|
int rv = -1;
|
|
|
|
pg = dma_alloc(sizeof(*pg), PR_WAITOK | PR_ZERO);
|
|
|
|
if (scsi_inquire_vpd(sc->sc_path.p_link, pg, sizeof(*pg),
|
|
RDAC_VPD_SUBSYS, scsi_autoconf) != 0) {
|
|
printf("%s: unable to fetch subsys vpd page\n", DEVNAME(sc));
|
|
goto done;
|
|
}
|
|
|
|
if (_4btol(pg->pg_id) != RDAC_VPD_ID_SUBSYS) {
|
|
printf("%s: subsys page is invalid\n", DEVNAME(sc));
|
|
goto done;
|
|
}
|
|
|
|
rv = _2btol(pg->controller_slot_id);
|
|
|
|
done:
|
|
dma_free(pg, sizeof(*pg));
|
|
return (rv);
|
|
}
|
|
|
|
int
|
|
rdac_extdevid(struct rdac_softc *sc)
|
|
{
|
|
struct rdac_vpd_extdevid *pg;
|
|
char array[31];
|
|
char vol[31];
|
|
int i;
|
|
int rv = 1;
|
|
|
|
pg = dma_alloc(sizeof(*pg), PR_WAITOK | PR_ZERO);
|
|
|
|
if (scsi_inquire_vpd(sc->sc_path.p_link, pg, sizeof(*pg),
|
|
RDAC_VPD_EXTDEVID, scsi_autoconf) != 0) {
|
|
printf("%s: unable to fetch extdevid vpd page\n", DEVNAME(sc));
|
|
goto done;
|
|
}
|
|
|
|
if (_4btol(pg->pg_id) != RDAC_VPD_ID_EXTDEVID) {
|
|
printf("%s: extdevid page is invalid\n", DEVNAME(sc));
|
|
goto done;
|
|
}
|
|
|
|
memset(array, 0, sizeof(array));
|
|
for (i = 0; i < sizeof(pg->array_label) / 2; i++)
|
|
array[i] = pg->array_label[i * 2 + 1];
|
|
|
|
memset(vol, 0, sizeof(vol));
|
|
for (i = 0; i < sizeof(pg->vol_label) / 2; i++)
|
|
vol[i] = pg->vol_label[i * 2 + 1];
|
|
|
|
printf("%s: array %s, volume %s\n", DEVNAME(sc), array, vol);
|
|
|
|
rv = 0;
|
|
done:
|
|
dma_free(pg, sizeof(*pg));
|
|
return (rv);
|
|
}
|