d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
e117882ba2
freebsd-nq/sys/cam/scsi/scsi_enc_ses.c
Mark Johnston b3db6c0140 Fix a memory leak in ses_get_elm_devnames(). 
After r307132 the sbuf buffer is malloc()ed, but corresponding
sbuf_delete() call was missing.

Fix a nearby whitespace bug.

MFC after:	3 days
Sponsored by:	Dell EMC Isilon
2017-06-26 19:41:14 +00:00

2885 lines
80 KiB
C
Raw Blame History

/*-
* Copyright (c) 2000 Matthew Jacob
* Copyright (c) 2010 Spectra Logic Corporation
* 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.
*/
/**
* \file scsi_enc_ses.c
*
* Structures and routines specific && private to SES only
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/ctype.h>
#include <sys/errno.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/queue.h>
#include <sys/sbuf.h>
#include <sys/sx.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <cam/cam.h>
#include <cam/cam_ccb.h>
#include <cam/cam_xpt_periph.h>
#include <cam/cam_periph.h>
#include <cam/scsi/scsi_message.h>
#include <cam/scsi/scsi_enc.h>
#include <cam/scsi/scsi_enc_internal.h>
/* SES Native Type Device Support */
/* SES Diagnostic Page Codes */
typedef enum {
SesSupportedPages = 0x0,
SesConfigPage = 0x1,
SesControlPage = 0x2,
SesStatusPage = SesControlPage,
SesHelpTxt = 0x3,
SesStringOut = 0x4,
SesStringIn = SesStringOut,
SesThresholdOut = 0x5,
SesThresholdIn = SesThresholdOut,
SesArrayControl = 0x6, /* Obsolete in SES v2 */
SesArrayStatus = SesArrayControl,
SesElementDescriptor = 0x7,
SesShortStatus = 0x8,
SesEnclosureBusy = 0x9,
SesAddlElementStatus = 0xa
} SesDiagPageCodes;
typedef struct ses_type {
const struct ses_elm_type_desc *hdr;
const char *text;
} ses_type_t;
typedef struct ses_comstat {
uint8_t comstatus;
uint8_t comstat[3];
} ses_comstat_t;
typedef union ses_addl_data {
struct ses_elm_sas_device_phy *sasdev_phys;
struct ses_elm_sas_expander_phy *sasexp_phys;
struct ses_elm_sas_port_phy *sasport_phys;
struct ses_fcobj_port *fc_ports;
} ses_add_data_t;
typedef struct ses_addl_status {
struct ses_elm_addlstatus_base_hdr *hdr;
union {
union ses_fcobj_hdr *fc;
union ses_elm_sas_hdr *sas;
} proto_hdr;
union ses_addl_data proto_data; /* array sizes stored in header */
} ses_add_status_t;
typedef struct ses_element {
uint8_t eip; /* eip bit is set */
uint16_t descr_len; /* length of the descriptor */
char *descr; /* descriptor for this object */
struct ses_addl_status addl; /* additional status info */
} ses_element_t;
typedef struct ses_control_request {
int elm_idx;
ses_comstat_t elm_stat;
int result;
TAILQ_ENTRY(ses_control_request) links;
} ses_control_request_t;
TAILQ_HEAD(ses_control_reqlist, ses_control_request);
typedef struct ses_control_reqlist ses_control_reqlist_t;
enum {
SES_SETSTATUS_ENC_IDX = -1
};
static void
ses_terminate_control_requests(ses_control_reqlist_t *reqlist, int result)
{
ses_control_request_t *req;
while ((req = TAILQ_FIRST(reqlist)) != NULL) {
TAILQ_REMOVE(reqlist, req, links);
req->result = result;
wakeup(req);
}
}
enum ses_iter_index_values {
/**
* \brief Value of an initialized but invalid index
* in a ses_iterator object.
*
* This value is used for the individual_element_index of
* overal status elements and for all index types when
* an iterator is first initialized.
*/
ITERATOR_INDEX_INVALID = -1,
/**
* \brief Value of an index in a ses_iterator object
* when the iterator has traversed past the last
* valid element..
*/
ITERATOR_INDEX_END = INT_MAX
};
/**
* \brief Structure encapsulating all data necessary to traverse the
* elements of a SES configuration.
*
* The ses_iterator object simplifies the task of iterating through all
* elements detected via the SES configuration page by tracking the numerous
* element indexes that, instead of memoizing in the softc, we calculate
* on the fly during the traversal of the element objects. The various
* indexes are necessary due to the varying needs of matching objects in
* the different SES pages. Some pages (e.g. Status/Control) contain all
* elements, while others (e.g. Additional Element Status) only contain
* individual elements (no overal status elements) of particular types.
*
* To use an iterator, initialize it with ses_iter_init(), and then
* use ses_iter_next() to traverse the elements (including the first) in
* the configuration. Once an iterator is initiailized with ses_iter_init(),
* you may also seek to any particular element by either it's global or
* individual element index via the ses_iter_seek_to() function. You may
* also return an iterator to the position just before the first element
* (i.e. the same state as after an ses_iter_init()), with ses_iter_reset().
*/
struct ses_iterator {
/**
* \brief Backlink to the overal software configuration structure.
*
* This is included for convenience so the iteration functions
* need only take a single, struct ses_iterator *, argument.
*/
enc_softc_t *enc;
enc_cache_t *cache;
/**
* \brief Index of the type of the current element within the
* ses_cache's ses_types array.
*/
int type_index;
/**
* \brief The position (0 based) of this element relative to all other
* elements of this type.
*
* This index resets to zero every time the iterator transitions
* to elements of a new type in the configuration.
*/
int type_element_index;
/**
* \brief The position (0 based) of this element relative to all
* other individual status elements in the configuration.
*
* This index ranges from 0 through the number of individual
* elements in the configuration. When the iterator returns
* an overall status element, individual_element_index is
* set to ITERATOR_INDEX_INVALID, to indicate that it does
* not apply to the current element.
*/
int individual_element_index;
/**
* \brief The position (0 based) of this element relative to
* all elements in the configration.
*
* This index is appropriate for indexing into enc->ses_elm_map.
*/
int global_element_index;
/**
* \brief The last valid individual element index of this
* iterator.
*
* When an iterator traverses an overal status element, the
* individual element index is reset to ITERATOR_INDEX_INVALID
* to prevent unintential use of the individual_element_index
* field. The saved_individual_element_index allows the iterator
* to restore it's position in the individual elements upon
* reaching the next individual element.
*/
int saved_individual_element_index;
};
typedef enum {
SES_UPDATE_NONE,
SES_UPDATE_PAGES,
SES_UPDATE_GETCONFIG,
SES_UPDATE_GETSTATUS,
SES_UPDATE_GETELMDESCS,
SES_UPDATE_GETELMADDLSTATUS,
SES_PROCESS_CONTROL_REQS,
SES_PUBLISH_PHYSPATHS,
SES_PUBLISH_CACHE,
SES_NUM_UPDATE_STATES
} ses_update_action;
static enc_softc_cleanup_t ses_softc_cleanup;
#define SCSZ 0x8000
static fsm_fill_handler_t ses_fill_rcv_diag_io;
static fsm_fill_handler_t ses_fill_control_request;
static fsm_done_handler_t ses_process_pages;
static fsm_done_handler_t ses_process_config;
static fsm_done_handler_t ses_process_status;
static fsm_done_handler_t ses_process_elm_descs;
static fsm_done_handler_t ses_process_elm_addlstatus;
static fsm_done_handler_t ses_process_control_request;
static fsm_done_handler_t ses_publish_physpaths;
static fsm_done_handler_t ses_publish_cache;
static struct enc_fsm_state enc_fsm_states[SES_NUM_UPDATE_STATES] =
{
{ "SES_UPDATE_NONE", 0, 0, 0, NULL, NULL, NULL },
{
"SES_UPDATE_PAGES",
SesSupportedPages,
SCSZ,
60 * 1000,
ses_fill_rcv_diag_io,
ses_process_pages,
enc_error
},
{
"SES_UPDATE_GETCONFIG",
SesConfigPage,
SCSZ,
60 * 1000,
ses_fill_rcv_diag_io,
ses_process_config,
enc_error
},
{
"SES_UPDATE_GETSTATUS",
SesStatusPage,
SCSZ,
60 * 1000,
ses_fill_rcv_diag_io,
ses_process_status,
enc_error
},
{
"SES_UPDATE_GETELMDESCS",
SesElementDescriptor,
SCSZ,
60 * 1000,
ses_fill_rcv_diag_io,
ses_process_elm_descs,
enc_error
},
{
"SES_UPDATE_GETELMADDLSTATUS",
SesAddlElementStatus,
SCSZ,
60 * 1000,
ses_fill_rcv_diag_io,
ses_process_elm_addlstatus,
enc_error
},
{
"SES_PROCESS_CONTROL_REQS",
SesControlPage,
SCSZ,
60 * 1000,
ses_fill_control_request,
ses_process_control_request,
enc_error
},
{
"SES_PUBLISH_PHYSPATHS",
0,
0,
0,
NULL,
ses_publish_physpaths,
NULL
},
{
"SES_PUBLISH_CACHE",
0,
0,
0,
NULL,
ses_publish_cache,
NULL
}
};
typedef struct ses_cache {
/* Source for all the configuration data pointers */
const struct ses_cfg_page *cfg_page;
/* References into the config page. */
int ses_nsubencs;
const struct ses_enc_desc * const *subencs;
int ses_ntypes;
const ses_type_t *ses_types;
/* Source for all the status pointers */
const struct ses_status_page *status_page;
/* Source for all the object descriptor pointers */
const struct ses_elem_descr_page *elm_descs_page;
/* Source for all the additional object status pointers */
const struct ses_addl_elem_status_page *elm_addlstatus_page;
} ses_cache_t;
typedef struct ses_softc {
uint32_t ses_flags;
#define SES_FLAG_TIMEDCOMP 0x01
#define SES_FLAG_ADDLSTATUS 0x02
#define SES_FLAG_DESC 0x04
ses_control_reqlist_t ses_requests;
ses_control_reqlist_t ses_pending_requests;
} ses_softc_t;
/**
* \brief Reset a SES iterator to just before the first element
* in the configuration.
*
* \param iter The iterator object to reset.
*
* The indexes within a reset iterator are invalid and will only
* become valid upon completion of a ses_iter_seek_to() or a
* ses_iter_next().
*/
static void
ses_iter_reset(struct ses_iterator *iter)
{
/*
* Set our indexes to just before the first valid element
* of the first type (ITERATOR_INDEX_INVALID == -1). This
* simplifies the implementation of ses_iter_next().
*/
iter->type_index = 0;
iter->type_element_index = ITERATOR_INDEX_INVALID;
iter->global_element_index = ITERATOR_INDEX_INVALID;
iter->individual_element_index = ITERATOR_INDEX_INVALID;
iter->saved_individual_element_index = ITERATOR_INDEX_INVALID;
}
/**
* \brief Initialize the storage of a SES iterator and reset it to
* the position just before the first element of the
* configuration.
*
* \param enc The SES softc for the SES instance whose configuration
* will be enumerated by this iterator.
* \param iter The iterator object to initialize.
*/
static void
ses_iter_init(enc_softc_t *enc, enc_cache_t *cache, struct ses_iterator *iter)
{
iter->enc = enc;
iter->cache = cache;
ses_iter_reset(iter);
}
/**
* \brief Traverse the provided SES iterator to the next element
* within the configuraiton.
*
* \param iter The iterator to move.
*
* \return If a valid next element exists, a pointer to it's enc_element_t.
* Otherwise NULL.
*/
static enc_element_t *
ses_iter_next(struct ses_iterator *iter)
{
ses_cache_t *ses_cache;
const ses_type_t *element_type;
ses_cache = iter->cache->private;
/*
* Note: Treat nelms as signed, so we will hit this case
* and immediately terminate the iteration if the
* configuration has 0 objects.
*/
if (iter->global_element_index >= (int)iter->cache->nelms - 1) {
/* Elements exhausted. */
iter->type_index = ITERATOR_INDEX_END;
iter->type_element_index = ITERATOR_INDEX_END;
iter->global_element_index = ITERATOR_INDEX_END;
iter->individual_element_index = ITERATOR_INDEX_END;
return (NULL);
}
KASSERT((iter->type_index < ses_cache->ses_ntypes),
("Corrupted element iterator. %d not less than %d",
iter->type_index, ses_cache->ses_ntypes));
element_type = &ses_cache->ses_types[iter->type_index];
iter->global_element_index++;
iter->type_element_index++;
/*
* There is an object for overal type status in addition
* to one for each allowed element, but only if the element
* count is non-zero.
*/
if (iter->type_element_index > element_type->hdr->etype_maxelt) {
/*
* We've exhausted the elements of this type.
* This next element belongs to the next type.
*/
iter->type_index++;
iter->type_element_index = 0;
iter->saved_individual_element_index
= iter->individual_element_index;
iter->individual_element_index = ITERATOR_INDEX_INVALID;
}
if (iter->type_element_index > 0) {
if (iter->type_element_index == 1) {
iter->individual_element_index
= iter->saved_individual_element_index;
}
iter->individual_element_index++;
}
return (&iter->cache->elm_map[iter->global_element_index]);
}
/**
* Element index types tracked by a SES iterator.
*/
typedef enum {
/**
* Index relative to all elements (overall and individual)
* in the system.
*/
SES_ELEM_INDEX_GLOBAL,
/**
* \brief Index relative to all individual elements in the system.
*
* This index counts only individual elements, skipping overall
* status elements. This is the index space of the additional
* element status page (page 0xa).
*/
SES_ELEM_INDEX_INDIVIDUAL
} ses_elem_index_type_t;
/**
* \brief Move the provided iterator forwards or backwards to the object
* having the give index.
*
* \param iter The iterator on which to perform the seek.
* \param element_index The index of the element to find.
* \param index_type The type (global or individual) of element_index.
*
* \return If the element is found, a pointer to it's enc_element_t.
* Otherwise NULL.
*/
static enc_element_t *
ses_iter_seek_to(struct ses_iterator *iter, int element_index,
ses_elem_index_type_t index_type)
{
enc_element_t *element;
int *cur_index;
if (index_type == SES_ELEM_INDEX_GLOBAL)
cur_index = &iter->global_element_index;
else
cur_index = &iter->individual_element_index;
if (*cur_index == element_index) {
/* Already there. */
return (&iter->cache->elm_map[iter->global_element_index]);
}
ses_iter_reset(iter);
while ((element = ses_iter_next(iter)) != NULL
&& *cur_index != element_index)
;
if (*cur_index != element_index)
return (NULL);
return (element);
}
#if 0
static int ses_encode(enc_softc_t *, uint8_t *, int, int,
struct ses_comstat *);
#endif
static int ses_set_timed_completion(enc_softc_t *, uint8_t);
#if 0
static int ses_putstatus(enc_softc_t *, int, struct ses_comstat *);
#endif
static void ses_poll_status(enc_softc_t *);
static void ses_print_addl_data(enc_softc_t *, enc_element_t *);
/*=========================== SES cleanup routines ===========================*/
static void
ses_cache_free_elm_addlstatus(enc_softc_t *enc, enc_cache_t *cache)
{
ses_cache_t *ses_cache;
ses_cache_t *other_ses_cache;
enc_element_t *cur_elm;
enc_element_t *last_elm;
ENC_DLOG(enc, "%s: enter\n", __func__);
ses_cache = cache->private;
if (ses_cache->elm_addlstatus_page == NULL)
return;
for (cur_elm = cache->elm_map,
last_elm = &cache->elm_map[cache->nelms];
cur_elm != last_elm; cur_elm++) {
ses_element_t *elmpriv;
elmpriv = cur_elm->elm_private;
/* Clear references to the additional status page. */
bzero(&elmpriv->addl, sizeof(elmpriv->addl));
}
other_ses_cache = enc_other_cache(enc, cache)->private;
if (other_ses_cache->elm_addlstatus_page
!= ses_cache->elm_addlstatus_page)
ENC_FREE(ses_cache->elm_addlstatus_page);
ses_cache->elm_addlstatus_page = NULL;
}
static void
ses_cache_free_elm_descs(enc_softc_t *enc, enc_cache_t *cache)
{
ses_cache_t *ses_cache;
ses_cache_t *other_ses_cache;
enc_element_t *cur_elm;
enc_element_t *last_elm;
ENC_DLOG(enc, "%s: enter\n", __func__);
ses_cache = cache->private;
if (ses_cache->elm_descs_page == NULL)
return;
for (cur_elm = cache->elm_map,
last_elm = &cache->elm_map[cache->nelms];
cur_elm != last_elm; cur_elm++) {
ses_element_t *elmpriv;
elmpriv = cur_elm->elm_private;
elmpriv->descr_len = 0;
elmpriv->descr = NULL;
}
other_ses_cache = enc_other_cache(enc, cache)->private;
if (other_ses_cache->elm_descs_page
!= ses_cache->elm_descs_page)
ENC_FREE(ses_cache->elm_descs_page);
ses_cache->elm_descs_page = NULL;
}
static void
ses_cache_free_status(enc_softc_t *enc, enc_cache_t *cache)
{
ses_cache_t *ses_cache;
ses_cache_t *other_ses_cache;
ENC_DLOG(enc, "%s: enter\n", __func__);
ses_cache = cache->private;
if (ses_cache->status_page == NULL)
return;
other_ses_cache = enc_other_cache(enc, cache)->private;
if (other_ses_cache->status_page != ses_cache->status_page)
ENC_FREE(ses_cache->status_page);
ses_cache->status_page = NULL;
}
static void
ses_cache_free_elm_map(enc_softc_t *enc, enc_cache_t *cache)
{
enc_element_t *cur_elm;
enc_element_t *last_elm;
ENC_DLOG(enc, "%s: enter\n", __func__);
if (cache->elm_map == NULL)
return;
ses_cache_free_elm_descs(enc, cache);
ses_cache_free_elm_addlstatus(enc, cache);
for (cur_elm = cache->elm_map,
last_elm = &cache->elm_map[cache->nelms];
cur_elm != last_elm; cur_elm++) {
ENC_FREE_AND_NULL(cur_elm->elm_private);
}
ENC_FREE_AND_NULL(cache->elm_map);
cache->nelms = 0;
ENC_DLOG(enc, "%s: exit\n", __func__);
}
static void
ses_cache_free(enc_softc_t *enc, enc_cache_t *cache)
{
ses_cache_t *other_ses_cache;
ses_cache_t *ses_cache;
ENC_DLOG(enc, "%s: enter\n", __func__);
ses_cache_free_elm_addlstatus(enc, cache);
ses_cache_free_status(enc, cache);
ses_cache_free_elm_map(enc, cache);
ses_cache = cache->private;
ses_cache->ses_ntypes = 0;
other_ses_cache = enc_other_cache(enc, cache)->private;
if (other_ses_cache->subencs != ses_cache->subencs)
ENC_FREE(ses_cache->subencs);
ses_cache->subencs = NULL;
if (other_ses_cache->ses_types != ses_cache->ses_types)
ENC_FREE(ses_cache->ses_types);
ses_cache->ses_types = NULL;
if (other_ses_cache->cfg_page != ses_cache->cfg_page)
ENC_FREE(ses_cache->cfg_page);
ses_cache->cfg_page = NULL;
ENC_DLOG(enc, "%s: exit\n", __func__);
}
static void
ses_cache_clone(enc_softc_t *enc, enc_cache_t *src, enc_cache_t *dst)
{
ses_cache_t *dst_ses_cache;
ses_cache_t *src_ses_cache;
enc_element_t *src_elm;
enc_element_t *dst_elm;
enc_element_t *last_elm;
ses_cache_free(enc, dst);
src_ses_cache = src->private;
dst_ses_cache = dst->private;
/*
* The cloned enclosure cache and ses specific cache are
* mostly identical to the source.
*/
*dst = *src;
*dst_ses_cache = *src_ses_cache;
/*
* But the ses cache storage is still independent. Restore
* the pointer that was clobbered by the structure copy above.
*/
dst->private = dst_ses_cache;
/*
* The element map is independent even though it starts out
* pointing to the same constant page data.
*/
dst->elm_map = malloc(dst->nelms * sizeof(enc_element_t),
M_SCSIENC, M_WAITOK);
memcpy(dst->elm_map, src->elm_map, dst->nelms * sizeof(enc_element_t));
for (dst_elm = dst->elm_map, src_elm = src->elm_map,
last_elm = &src->elm_map[src->nelms];
src_elm != last_elm; src_elm++, dst_elm++) {
dst_elm->elm_private = malloc(sizeof(ses_element_t),
M_SCSIENC, M_WAITOK);
memcpy(dst_elm->elm_private, src_elm->elm_private,
sizeof(ses_element_t));
}
}
/* Structure accessors. These are strongly typed to avoid errors. */
int
ses_elm_sas_descr_type(union ses_elm_sas_hdr *obj)
{
return ((obj)->base_hdr.byte1 >> 6);
}
int
ses_elm_addlstatus_proto(struct ses_elm_addlstatus_base_hdr *hdr)
{
return ((hdr)->byte0 & 0xf);
}
int
ses_elm_addlstatus_eip(struct ses_elm_addlstatus_base_hdr *hdr)
{
return ((hdr)->byte0 >> 4) & 0x1;
}
int
ses_elm_addlstatus_invalid(struct ses_elm_addlstatus_base_hdr *hdr)
{
return ((hdr)->byte0 >> 7);
}
int
ses_elm_sas_type0_not_all_phys(union ses_elm_sas_hdr *hdr)
{
return ((hdr)->type0_noneip.byte1 & 0x1);
}
int
ses_elm_sas_dev_phy_sata_dev(struct ses_elm_sas_device_phy *phy)
{
return ((phy)->target_ports & 0x1);
}
int
ses_elm_sas_dev_phy_sata_port(struct ses_elm_sas_device_phy *phy)
{
return ((phy)->target_ports >> 7);
}
int
ses_elm_sas_dev_phy_dev_type(struct ses_elm_sas_device_phy *phy)
{
return (((phy)->byte0 >> 4) & 0x7);
}
/**
* \brief Verify that the cached configuration data in our softc
* is valid for processing the page data corresponding to
* the provided page header.
*
* \param ses_cache The SES cache to validate.
* \param gen_code The 4 byte generation code from a SES diagnostic
* page header.
*
* \return non-zero if true, 0 if false.
*/
static int
ses_config_cache_valid(ses_cache_t *ses_cache, const uint8_t *gen_code)
{
uint32_t cache_gc;
uint32_t cur_gc;
if (ses_cache->cfg_page == NULL)
return (0);
cache_gc = scsi_4btoul(ses_cache->cfg_page->hdr.gen_code);
cur_gc = scsi_4btoul(gen_code);
return (cache_gc == cur_gc);
}
/**
* Function signature for consumers of the ses_devids_iter() interface.
*/
typedef void ses_devid_callback_t(enc_softc_t *, enc_element_t *,
struct scsi_vpd_id_descriptor *, void *);
/**
* \brief Iterate over and create vpd device id records from the
* additional element status data for elm, passing that data
* to the provided callback.
*
* \param enc SES instance containing elm
* \param elm Element for which to extract device ID data.
* \param callback The callback function to invoke on each generated
* device id descriptor for elm.
* \param callback_arg Argument passed through to callback on each invocation.
*/
static void
ses_devids_iter(enc_softc_t *enc, enc_element_t *elm,
ses_devid_callback_t *callback, void *callback_arg)
{
ses_element_t *elmpriv;
struct ses_addl_status *addl;
u_int i;
size_t devid_record_size;
elmpriv = elm->elm_private;
addl = &(elmpriv->addl);
/*
* Don't assume this object has additional status information, or
* that it is a SAS device, or that it is a device slot device.
*/
if (addl->hdr == NULL || addl->proto_hdr.sas == NULL
|| addl->proto_data.sasdev_phys == NULL)
return;
devid_record_size = SVPD_DEVICE_ID_DESC_HDR_LEN
+ sizeof(struct scsi_vpd_id_naa_ieee_reg);
for (i = 0; i < addl->proto_hdr.sas->base_hdr.num_phys; i++) {
uint8_t devid_buf[devid_record_size];
struct scsi_vpd_id_descriptor *devid;
uint8_t *phy_addr;
devid = (struct scsi_vpd_id_descriptor *)devid_buf;
phy_addr = addl->proto_data.sasdev_phys[i].phy_addr;
devid->proto_codeset = (SCSI_PROTO_SAS << SVPD_ID_PROTO_SHIFT)
| SVPD_ID_CODESET_BINARY;
devid->id_type = SVPD_ID_PIV
| SVPD_ID_ASSOC_PORT
| SVPD_ID_TYPE_NAA;
devid->reserved = 0;
devid->length = sizeof(struct scsi_vpd_id_naa_ieee_reg);
memcpy(devid->identifier, phy_addr, devid->length);
callback(enc, elm, devid, callback_arg);
}
}
/**
* Function signature for consumers of the ses_paths_iter() interface.
*/
typedef void ses_path_callback_t(enc_softc_t *, enc_element_t *,
struct cam_path *, void *);
/**
* Argument package passed through ses_devids_iter() by
* ses_paths_iter() to ses_path_iter_devid_callback().
*/
typedef struct ses_path_iter_args {
ses_path_callback_t *callback;
void *callback_arg;
} ses_path_iter_args_t;
/**
* ses_devids_iter() callback function used by ses_paths_iter()
* to map device ids to peripheral driver instances.
*
* \param enc SES instance containing elm
* \param elm Element on which device ID matching is active.
* \param periph A device ID corresponding to elm.
* \param arg Argument passed through to callback on each invocation.
*/
static void
ses_path_iter_devid_callback(enc_softc_t *enc, enc_element_t *elem,
struct scsi_vpd_id_descriptor *devid,
void *arg)
{
struct ccb_dev_match cdm;
struct dev_match_pattern match_pattern;
struct dev_match_result match_result;
struct device_match_result *device_match;
struct device_match_pattern *device_pattern;
ses_path_iter_args_t *args;
args = (ses_path_iter_args_t *)arg;
match_pattern.type = DEV_MATCH_DEVICE;
device_pattern = &match_pattern.pattern.device_pattern;
device_pattern->flags = DEV_MATCH_DEVID;
device_pattern->data.devid_pat.id_len =
offsetof(struct scsi_vpd_id_descriptor, identifier)
+ devid->length;
memcpy(device_pattern->data.devid_pat.id, devid,
device_pattern->data.devid_pat.id_len);
memset(&cdm, 0, sizeof(cdm));
if (xpt_create_path(&cdm.ccb_h.path, /*periph*/NULL,
CAM_XPT_PATH_ID,
CAM_TARGET_WILDCARD,
CAM_LUN_WILDCARD) != CAM_REQ_CMP)
return;
cdm.ccb_h.func_code = XPT_DEV_MATCH;
cdm.num_patterns = 1;
cdm.patterns = &match_pattern;
cdm.pattern_buf_len = sizeof(match_pattern);
cdm.match_buf_len = sizeof(match_result);
cdm.matches = &match_result;
xpt_action((union ccb *)&cdm);
xpt_free_path(cdm.ccb_h.path);
if ((cdm.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP
|| (cdm.status != CAM_DEV_MATCH_LAST
&& cdm.status != CAM_DEV_MATCH_MORE)
|| cdm.num_matches == 0)
return;
device_match = &match_result.result.device_result;
if (xpt_create_path(&cdm.ccb_h.path, /*periph*/NULL,
device_match->path_id,
device_match->target_id,
device_match->target_lun) != CAM_REQ_CMP)
return;
args->callback(enc, elem, cdm.ccb_h.path, args->callback_arg);
xpt_free_path(cdm.ccb_h.path);
}
/**
* \brief Iterate over and find the matching periph objects for the
* specified element.
*
* \param enc SES instance containing elm
* \param elm Element for which to perform periph object matching.
* \param callback The callback function to invoke with each matching
* periph object.
* \param callback_arg Argument passed through to callback on each invocation.
*/
static void
ses_paths_iter(enc_softc_t *enc, enc_element_t *elm,
ses_path_callback_t *callback, void *callback_arg)
{
ses_path_iter_args_t args;
args.callback = callback;
args.callback_arg = callback_arg;
ses_devids_iter(enc, elm, ses_path_iter_devid_callback, &args);
}
/**
* ses_paths_iter() callback function used by ses_get_elmdevname()
* to record periph driver instance strings corresponding to a SES
* element.
*
* \param enc SES instance containing elm
* \param elm Element on which periph matching is active.
* \param periph A periph instance that matches elm.
* \param arg Argument passed through to callback on each invocation.
*/
static void
ses_elmdevname_callback(enc_softc_t *enc, enc_element_t *elem,
struct cam_path *path, void *arg)
{
struct sbuf *sb;
sb = (struct sbuf *)arg;
cam_periph_list(path, sb);
}
/**
* Argument package passed through ses_paths_iter() to
* ses_getcampath_callback.
*/
typedef struct ses_setphyspath_callback_args {
struct sbuf *physpath;
int num_set;
} ses_setphyspath_callback_args_t;
/**
* \brief ses_paths_iter() callback to set the physical path on the
* CAM EDT entries corresponding to a given SES element.
*
* \param enc SES instance containing elm
* \param elm Element on which periph matching is active.
* \param periph A periph instance that matches elm.
* \param arg Argument passed through to callback on each invocation.
*/
static void
ses_setphyspath_callback(enc_softc_t *enc, enc_element_t *elm,
struct cam_path *path, void *arg)
{
struct ccb_dev_advinfo cdai;
ses_setphyspath_callback_args_t *args;
char *old_physpath;
args = (ses_setphyspath_callback_args_t *)arg;
old_physpath = malloc(MAXPATHLEN, M_SCSIENC, M_WAITOK|M_ZERO);
cam_periph_lock(enc->periph);
xpt_setup_ccb(&cdai.ccb_h, path, CAM_PRIORITY_NORMAL);
cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
cdai.buftype = CDAI_TYPE_PHYS_PATH;
cdai.flags = CDAI_FLAG_NONE;
cdai.bufsiz = MAXPATHLEN;
cdai.buf = old_physpath;
xpt_action((union ccb *)&cdai);
if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE);
if (strcmp(old_physpath, sbuf_data(args->physpath)) != 0) {
xpt_setup_ccb(&cdai.ccb_h, path, CAM_PRIORITY_NORMAL);
cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
cdai.buftype = CDAI_TYPE_PHYS_PATH;
cdai.flags = CDAI_FLAG_STORE;
cdai.bufsiz = sbuf_len(args->physpath);
cdai.buf = sbuf_data(args->physpath);
xpt_action((union ccb *)&cdai);
if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE);
if (cdai.ccb_h.status == CAM_REQ_CMP)
args->num_set++;
}
cam_periph_unlock(enc->periph);
free(old_physpath, M_SCSIENC);
}
/**
* \brief Set a device's physical path string in CAM XPT.
*
* \param enc SES instance containing elm
* \param elm Element to publish physical path string for
* \param iter Iterator whose state corresponds to elm
*
* \return 0 on success, errno otherwise.
*/
static int
ses_set_physpath(enc_softc_t *enc, enc_element_t *elm,
struct ses_iterator *iter)
{
struct ccb_dev_advinfo cdai;
ses_setphyspath_callback_args_t args;
int i, ret;
struct sbuf sb;
struct scsi_vpd_id_descriptor *idd;
uint8_t *devid;
ses_element_t *elmpriv;
const char *c;
ret = EIO;
devid = NULL;
/*
* Assemble the components of the physical path starting with
* the device ID of the enclosure itself.
*/
xpt_setup_ccb(&cdai.ccb_h, enc->periph->path, CAM_PRIORITY_NORMAL);
cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
cdai.flags = CDAI_FLAG_NONE;
cdai.buftype = CDAI_TYPE_SCSI_DEVID;
cdai.bufsiz = CAM_SCSI_DEVID_MAXLEN;
cdai.buf = devid = malloc(cdai.bufsiz, M_SCSIENC, M_WAITOK|M_ZERO);
cam_periph_lock(enc->periph);
xpt_action((union ccb *)&cdai);
if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE);
cam_periph_unlock(enc->periph);
if (cdai.ccb_h.status != CAM_REQ_CMP)
goto out;
idd = scsi_get_devid((struct scsi_vpd_device_id *)cdai.buf,
cdai.provsiz, scsi_devid_is_naa_ieee_reg);
if (idd == NULL)
goto out;
if (sbuf_new(&sb, NULL, 128, SBUF_AUTOEXTEND) == NULL) {
ret = ENOMEM;
goto out;
}
/* Next, generate the physical path string */
sbuf_printf(&sb, "id1,enc@n%jx/type@%x/slot@%x",
scsi_8btou64(idd->identifier), iter->type_index,
iter->type_element_index);
/* Append the element descriptor if one exists */
elmpriv = elm->elm_private;
if (elmpriv->descr != NULL && elmpriv->descr_len > 0) {
sbuf_cat(&sb, "/elmdesc@");
for (i = 0, c = elmpriv->descr; i < elmpriv->descr_len;
i++, c++) {
if (!isprint(*c) || isspace(*c) || *c == '/')
sbuf_putc(&sb, '_');
else
sbuf_putc(&sb, *c);
}
}
sbuf_finish(&sb);
/*
* Set this physical path on any CAM devices with a device ID
* descriptor that matches one created from the SES additional
* status data for this element.
*/
args.physpath= &sb;
args.num_set = 0;
ses_paths_iter(enc, elm, ses_setphyspath_callback, &args);
sbuf_delete(&sb);
ret = args.num_set == 0 ? ENOENT : 0;
out:
if (devid != NULL)
ENC_FREE(devid);
return (ret);
}
/**
* \brief Helper to set the CDB fields appropriately.
*
* \param cdb Buffer containing the cdb.
* \param pagenum SES diagnostic page to query for.
* \param dir Direction of query.
*/
static void
ses_page_cdb(char *cdb, int bufsiz, SesDiagPageCodes pagenum, int dir)
{
/* Ref: SPC-4 r25 Section 6.20 Table 223 */
if (dir == CAM_DIR_IN) {
cdb[0] = RECEIVE_DIAGNOSTIC;
cdb[1] = 1; /* Set page code valid bit */
cdb[2] = pagenum;
} else {
cdb[0] = SEND_DIAGNOSTIC;
cdb[1] = 0x10;
cdb[2] = pagenum;
}
cdb[3] = bufsiz >> 8; /* high bits */
cdb[4] = bufsiz & 0xff; /* low bits */
cdb[5] = 0;
}
/**
* \brief Discover whether this instance supports timed completion of a
* RECEIVE DIAGNOSTIC RESULTS command requesting the Enclosure Status
* page, and store the result in the softc, updating if necessary.
*
* \param enc SES instance to query and update.
* \param tc_en Value of timed completion to set (see \return).
*
* \return 1 if timed completion enabled, 0 otherwise.
*/
static int
ses_set_timed_completion(enc_softc_t *enc, uint8_t tc_en)
{
union ccb *ccb;
struct cam_periph *periph;
struct ses_mgmt_mode_page *mgmt;
uint8_t *mode_buf;
size_t mode_buf_len;
ses_softc_t *ses;
periph = enc->periph;
ses = enc->enc_private;
ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
mode_buf_len = sizeof(struct ses_mgmt_mode_page);
mode_buf = ENC_MALLOCZ(mode_buf_len);
if (mode_buf == NULL)
goto out;
scsi_mode_sense(&ccb->csio, /*retries*/4, NULL, MSG_SIMPLE_Q_TAG,
/*dbd*/FALSE, SMS_PAGE_CTRL_CURRENT, SES_MGMT_MODE_PAGE_CODE,
mode_buf, mode_buf_len, SSD_FULL_SIZE, /*timeout*/60 * 1000);
/*
* Ignore illegal request errors, as they are quite common and we
* will print something out in that case anyway.
*/
cam_periph_runccb(ccb, enc_error, ENC_CFLAGS,
ENC_FLAGS|SF_QUIET_IR, NULL);
if (ccb->ccb_h.status != CAM_REQ_CMP) {
ENC_VLOG(enc, "Timed Completion Unsupported\n");
goto release;
}
/* Skip the mode select if the desired value is already set */
mgmt = (struct ses_mgmt_mode_page *)mode_buf;
if ((mgmt->byte5 & SES_MGMT_TIMED_COMP_EN) == tc_en)
goto done;
/* Value is not what we wanted, set it */
if (tc_en)
mgmt->byte5 |= SES_MGMT_TIMED_COMP_EN;
else
mgmt->byte5 &= ~SES_MGMT_TIMED_COMP_EN;
/* SES2r20: a completion time of zero means as long as possible */
bzero(&mgmt->max_comp_time, sizeof(mgmt->max_comp_time));
scsi_mode_select(&ccb->csio, 5, NULL, MSG_SIMPLE_Q_TAG,
/*page_fmt*/FALSE, /*save_pages*/TRUE, mode_buf, mode_buf_len,
SSD_FULL_SIZE, /*timeout*/60 * 1000);
cam_periph_runccb(ccb, enc_error, ENC_CFLAGS, ENC_FLAGS, NULL);
if (ccb->ccb_h.status != CAM_REQ_CMP) {
ENC_VLOG(enc, "Timed Completion Set Failed\n");
goto release;
}
done:
if ((mgmt->byte5 & SES_MGMT_TIMED_COMP_EN) != 0) {
ENC_LOG(enc, "Timed Completion Enabled\n");
ses->ses_flags |= SES_FLAG_TIMEDCOMP;
} else {
ENC_LOG(enc, "Timed Completion Disabled\n");
ses->ses_flags &= ~SES_FLAG_TIMEDCOMP;
}
release:
ENC_FREE(mode_buf);
xpt_release_ccb(ccb);
out:
return (ses->ses_flags & SES_FLAG_TIMEDCOMP);
}
/**
* \brief Process the list of supported pages and update flags.
*
* \param enc SES device to query.
* \param buf Buffer containing the config page.
* \param xfer_len Length of the config page in the buffer.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_process_pages(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t **bufp, int error, int xfer_len)
{
ses_softc_t *ses;
struct scsi_diag_page *page;
int err, i, length;
CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE,
("entering %s(%p, %d)\n", __func__, bufp, xfer_len));
ses = enc->enc_private;
err = -1;
if (error != 0) {
err = error;
goto out;
}
if (xfer_len < sizeof(*page)) {
ENC_VLOG(enc, "Unable to parse Diag Pages List Header\n");
err = EIO;
goto out;
}
page = (struct scsi_diag_page *)*bufp;
length = scsi_2btoul(page->length);
if (length + offsetof(struct scsi_diag_page, params) > xfer_len) {
ENC_VLOG(enc, "Diag Pages List Too Long\n");
goto out;
}
ENC_DLOG(enc, "%s: page length %d, xfer_len %d\n",
__func__, length, xfer_len);
err = 0;
for (i = 0; i < length; i++) {
if (page->params[i] == SesElementDescriptor)
ses->ses_flags |= SES_FLAG_DESC;
else if (page->params[i] == SesAddlElementStatus)
ses->ses_flags |= SES_FLAG_ADDLSTATUS;
}
out:
ENC_DLOG(enc, "%s: exiting with err %d\n", __func__, err);
return (err);
}
/**
* \brief Process the config page and update associated structures.
*
* \param enc SES device to query.
* \param buf Buffer containing the config page.
* \param xfer_len Length of the config page in the buffer.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_process_config(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t **bufp, int error, int xfer_len)
{
struct ses_iterator iter;
ses_softc_t *ses;
enc_cache_t *enc_cache;
ses_cache_t *ses_cache;
uint8_t *buf;
int length;
int err;
int nelm;
int ntype;
struct ses_cfg_page *cfg_page;
struct ses_enc_desc *buf_subenc;
const struct ses_enc_desc **subencs;
const struct ses_enc_desc **cur_subenc;
const struct ses_enc_desc **last_subenc;
ses_type_t *ses_types;
ses_type_t *sestype;
const struct ses_elm_type_desc *cur_buf_type;
const struct ses_elm_type_desc *last_buf_type;
uint8_t *last_valid_byte;
enc_element_t *element;
const char *type_text;
CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE,
("entering %s(%p, %d)\n", __func__, bufp, xfer_len));
ses = enc->enc_private;
enc_cache = &enc->enc_daemon_cache;
ses_cache = enc_cache->private;
buf = *bufp;
err = -1;
if (error != 0) {
err = error;
goto out;
}
if (xfer_len < sizeof(cfg_page->hdr)) {
ENC_VLOG(enc, "Unable to parse SES Config Header\n");
err = EIO;
goto out;
}
cfg_page = (struct ses_cfg_page *)buf;
length = ses_page_length(&cfg_page->hdr);
if (length > xfer_len) {
ENC_VLOG(enc, "Enclosure Config Page Too Long\n");
goto out;
}
last_valid_byte = &buf[length - 1];
ENC_DLOG(enc, "%s: total page length %d, xfer_len %d\n",
__func__, length, xfer_len);
err = 0;
if (ses_config_cache_valid(ses_cache, cfg_page->hdr.gen_code)) {
/* Our cache is still valid. Proceed to fetching status. */
goto out;
}
/* Cache is no longer valid. Free old data to make way for new. */
ses_cache_free(enc, enc_cache);
ENC_VLOG(enc, "Generation Code 0x%x has %d SubEnclosures\n",
scsi_4btoul(cfg_page->hdr.gen_code),
ses_cfg_page_get_num_subenc(cfg_page));
/* Take ownership of the buffer. */
ses_cache->cfg_page = cfg_page;
*bufp = NULL;
/*
* Now waltz through all the subenclosures summing the number of
* types available in each.
*/
subencs = malloc(ses_cfg_page_get_num_subenc(cfg_page)
* sizeof(*subencs), M_SCSIENC, M_WAITOK|M_ZERO);
/*
* Sub-enclosure data is const after construction (i.e. when
* accessed via our cache object.
*
* The cast here is not required in C++ but C99 is not so
* sophisticated (see C99 6.5.16.1(1)).
*/
ses_cache->ses_nsubencs = ses_cfg_page_get_num_subenc(cfg_page);
ses_cache->subencs = subencs;
buf_subenc = cfg_page->subencs;
cur_subenc = subencs;
last_subenc = &subencs[ses_cache->ses_nsubencs - 1];
ntype = 0;
while (cur_subenc <= last_subenc) {
if (!ses_enc_desc_is_complete(buf_subenc, last_valid_byte)) {
ENC_VLOG(enc, "Enclosure %d Beyond End of "
"Descriptors\n", cur_subenc - subencs);
err = EIO;
goto out;
}
ENC_VLOG(enc, " SubEnclosure ID %d, %d Types With this ID, "
"Descriptor Length %d, offset %d\n", buf_subenc->subenc_id,
buf_subenc->num_types, buf_subenc->length,
&buf_subenc->byte0 - buf);
ENC_VLOG(enc, "WWN: %jx\n",
(uintmax_t)scsi_8btou64(buf_subenc->logical_id));
ntype += buf_subenc->num_types;
*cur_subenc = buf_subenc;
cur_subenc++;
buf_subenc = ses_enc_desc_next(buf_subenc);
}
/* Process the type headers. */
ses_types = malloc(ntype * sizeof(*ses_types),
M_SCSIENC, M_WAITOK|M_ZERO);
/*
* Type data is const after construction (i.e. when accessed via
* our cache object.
*/
ses_cache->ses_ntypes = ntype;
ses_cache->ses_types = ses_types;
cur_buf_type = (const struct ses_elm_type_desc *)
(&(*last_subenc)->length + (*last_subenc)->length + 1);
last_buf_type = cur_buf_type + ntype - 1;
type_text = (const uint8_t *)(last_buf_type + 1);
nelm = 0;
sestype = ses_types;
while (cur_buf_type <= last_buf_type) {
if (&cur_buf_type->etype_txt_len > last_valid_byte) {
ENC_VLOG(enc, "Runt Enclosure Type Header %d\n",
sestype - ses_types);
err = EIO;
goto out;
}
sestype->hdr = cur_buf_type;
sestype->text = type_text;
type_text += cur_buf_type->etype_txt_len;
ENC_VLOG(enc, " Type Desc[%d]: Type 0x%x, MaxElt %d, In Subenc "
"%d, Text Length %d: %.*s\n", sestype - ses_types,
sestype->hdr->etype_elm_type, sestype->hdr->etype_maxelt,
sestype->hdr->etype_subenc, sestype->hdr->etype_txt_len,
sestype->hdr->etype_txt_len, sestype->text);
nelm += sestype->hdr->etype_maxelt
+ /*overall status element*/1;
sestype++;
cur_buf_type++;
}
/* Create the object map. */
enc_cache->elm_map = malloc(nelm * sizeof(enc_element_t),
M_SCSIENC, M_WAITOK|M_ZERO);
enc_cache->nelms = nelm;
ses_iter_init(enc, enc_cache, &iter);
while ((element = ses_iter_next(&iter)) != NULL) {
const struct ses_elm_type_desc *thdr;
ENC_DLOG(enc, "%s: checking obj %d(%d,%d)\n", __func__,
iter.global_element_index, iter.type_index, nelm,
iter.type_element_index);
thdr = ses_cache->ses_types[iter.type_index].hdr;
element->subenclosure = thdr->etype_subenc;
element->enctype = thdr->etype_elm_type;
element->overall_status_elem = iter.type_element_index == 0;
element->elm_private = malloc(sizeof(ses_element_t),
M_SCSIENC, M_WAITOK|M_ZERO);
ENC_DLOG(enc, "%s: creating elmpriv %d(%d,%d) subenc %d "
"type 0x%x\n", __func__, iter.global_element_index,
iter.type_index, iter.type_element_index,
thdr->etype_subenc, thdr->etype_elm_type);
}
err = 0;
out:
if (err)
ses_cache_free(enc, enc_cache);
else {
ses_poll_status(enc);
enc_update_request(enc, SES_PUBLISH_CACHE);
}
ENC_DLOG(enc, "%s: exiting with err %d\n", __func__, err);
return (err);
}
/**
* \brief Update the status page and associated structures.
*
* \param enc SES softc to update for.
* \param buf Buffer containing the status page.
* \param bufsz Amount of data in the buffer.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_process_status(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t **bufp, int error, int xfer_len)
{
struct ses_iterator iter;
enc_element_t *element;
ses_softc_t *ses;
enc_cache_t *enc_cache;
ses_cache_t *ses_cache;
uint8_t *buf;
int err = -1;
int length;
struct ses_status_page *page;
union ses_status_element *cur_stat;
union ses_status_element *last_stat;
ses = enc->enc_private;
enc_cache = &enc->enc_daemon_cache;
ses_cache = enc_cache->private;
buf = *bufp;
ENC_DLOG(enc, "%s: enter (%p, %p, %d)\n", __func__, enc, buf, xfer_len);
page = (struct ses_status_page *)buf;
length = ses_page_length(&page->hdr);
if (error != 0) {
err = error;
goto out;
}
/*
* Make sure the length fits in the buffer.
*
* XXX all this means is that the page is larger than the space
* we allocated. Since we use a statically sized buffer, this
* could happen... Need to use dynamic discovery of the size.
*/
if (length > xfer_len) {
ENC_VLOG(enc, "Enclosure Status Page Too Long\n");
goto out;
}
/* Check for simple enclosure reporting short enclosure status. */
if (length >= 4 && page->hdr.page_code == SesShortStatus) {
ENC_DLOG(enc, "Got Short Enclosure Status page\n");
ses->ses_flags &= ~(SES_FLAG_ADDLSTATUS | SES_FLAG_DESC);
ses_cache_free(enc, enc_cache);
enc_cache->enc_status = page->hdr.page_specific_flags;
enc_update_request(enc, SES_PUBLISH_CACHE);
err = 0;
goto out;
}
/* Make sure the length contains at least one header and status */
if (length < (sizeof(*page) + sizeof(*page->elements))) {
ENC_VLOG(enc, "Enclosure Status Page Too Short\n");
goto out;
}
if (!ses_config_cache_valid(ses_cache, page->hdr.gen_code)) {
ENC_DLOG(enc, "%s: Generation count change detected\n",
__func__);
enc_update_request(enc, SES_UPDATE_GETCONFIG);
goto out;
}
ses_cache_free_status(enc, enc_cache);
ses_cache->status_page = page;
*bufp = NULL;
enc_cache->enc_status = page->hdr.page_specific_flags;
/*
* Read in individual element status. The element order
* matches the order reported in the config page (i.e. the
* order of an unfiltered iteration of the config objects)..
*/
ses_iter_init(enc, enc_cache, &iter);
cur_stat = page->elements;
last_stat = (union ses_status_element *)
&buf[length - sizeof(*last_stat)];
ENC_DLOG(enc, "%s: total page length %d, xfer_len %d\n",
__func__, length, xfer_len);
while (cur_stat <= last_stat
&& (element = ses_iter_next(&iter)) != NULL) {
ENC_DLOG(enc, "%s: obj %d(%d,%d) off=0x%tx status=%jx\n",
__func__, iter.global_element_index, iter.type_index,
iter.type_element_index, (uint8_t *)cur_stat - buf,
scsi_4btoul(cur_stat->bytes));
memcpy(&element->encstat, cur_stat, sizeof(element->encstat));
element->svalid = 1;
cur_stat++;
}
if (ses_iter_next(&iter) != NULL) {
ENC_VLOG(enc, "Status page, length insufficient for "
"expected number of objects\n");
} else {
if (cur_stat <= last_stat)
ENC_VLOG(enc, "Status page, exhausted objects before "
"exhausing page\n");
enc_update_request(enc, SES_PUBLISH_CACHE);
err = 0;
}
out:
ENC_DLOG(enc, "%s: exiting with error %d\n", __func__, err);
return (err);
}
typedef enum {
/**
* The enclosure should not provide additional element
* status for this element type in page 0x0A.
*
* \note This status is returned for any types not
* listed SES3r02. Further types added in a
* future specification will be incorrectly
* classified.
*/
TYPE_ADDLSTATUS_NONE,
/**
* The element type provides additional element status
* in page 0x0A.
*/
TYPE_ADDLSTATUS_MANDATORY,
/**
* The element type may provide additional element status
* in page 0x0A, but i
*/
TYPE_ADDLSTATUS_OPTIONAL
} ses_addlstatus_avail_t;
/**
* \brief Check to see whether a given type (as obtained via type headers) is
* supported by the additional status command.
*
* \param enc SES softc to check.
* \param typidx Type index to check for.
*
* \return An enumeration indicating if additional status is mandatory,
* optional, or not required for this type.
*/
static ses_addlstatus_avail_t
ses_typehasaddlstatus(enc_softc_t *enc, uint8_t typidx)
{
enc_cache_t *enc_cache;
ses_cache_t *ses_cache;
enc_cache = &enc->enc_daemon_cache;
ses_cache = enc_cache->private;
switch(ses_cache->ses_types[typidx].hdr->etype_elm_type) {
case ELMTYP_DEVICE:
case ELMTYP_ARRAY_DEV:
case ELMTYP_SAS_EXP:
return (TYPE_ADDLSTATUS_MANDATORY);
case ELMTYP_SCSI_INI:
case ELMTYP_SCSI_TGT:
case ELMTYP_ESCC:
return (TYPE_ADDLSTATUS_OPTIONAL);
default:
/* No additional status information available. */
break;
}
return (TYPE_ADDLSTATUS_NONE);
}
static int ses_get_elm_addlstatus_fc(enc_softc_t *, enc_cache_t *,
uint8_t *, int);
static int ses_get_elm_addlstatus_sas(enc_softc_t *, enc_cache_t *, uint8_t *,
int, int, int, int);
/**
* \brief Parse the additional status element data for each object.
*
* \param enc The SES softc to update.
* \param buf The buffer containing the additional status
* element response.
* \param xfer_len Size of the buffer.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_process_elm_addlstatus(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t **bufp, int error, int xfer_len)
{
struct ses_iterator iter, titer;
int eip;
int err;
int ignore_index = 0;
int length;
int offset;
enc_cache_t *enc_cache;
ses_cache_t *ses_cache;
uint8_t *buf;
ses_element_t *elmpriv;
const struct ses_page_hdr *hdr;
enc_element_t *element, *telement;
enc_cache = &enc->enc_daemon_cache;
ses_cache = enc_cache->private;
buf = *bufp;
err = -1;
if (error != 0) {
err = error;
goto out;
}
ses_cache_free_elm_addlstatus(enc, enc_cache);
ses_cache->elm_addlstatus_page =
(struct ses_addl_elem_status_page *)buf;
*bufp = NULL;
/*
* The objects appear in the same order here as in Enclosure Status,
* which itself is ordered by the Type Descriptors from the Config
* page. However, it is necessary to skip elements that are not
* supported by this page when counting them.
*/
hdr = &ses_cache->elm_addlstatus_page->hdr;
length = ses_page_length(hdr);
ENC_DLOG(enc, "Additional Element Status Page Length 0x%x\n", length);
/* Make sure the length includes at least one header. */
if (length < sizeof(*hdr)+sizeof(struct ses_elm_addlstatus_base_hdr)) {
ENC_VLOG(enc, "Runt Additional Element Status Page\n");
goto out;
}
if (length > xfer_len) {
ENC_VLOG(enc, "Additional Element Status Page Too Long\n");
goto out;
}
if (!ses_config_cache_valid(ses_cache, hdr->gen_code)) {
ENC_DLOG(enc, "%s: Generation count change detected\n",
__func__);
enc_update_request(enc, SES_UPDATE_GETCONFIG);
goto out;
}
offset = sizeof(struct ses_page_hdr);
ses_iter_init(enc, enc_cache, &iter);
while (offset < length
&& (element = ses_iter_next(&iter)) != NULL) {
struct ses_elm_addlstatus_base_hdr *elm_hdr;
int proto_info_len;
ses_addlstatus_avail_t status_type;
/*
* Additional element status is only provided for
* individual elements (i.e. overal status elements
* are excluded) and those of the types specified
* in the SES spec.
*/
status_type = ses_typehasaddlstatus(enc, iter.type_index);
if (iter.individual_element_index == ITERATOR_INDEX_INVALID
|| status_type == TYPE_ADDLSTATUS_NONE)
continue;
elm_hdr = (struct ses_elm_addlstatus_base_hdr *)&buf[offset];
eip = ses_elm_addlstatus_eip(elm_hdr);
if (eip && !ignore_index) {
struct ses_elm_addlstatus_eip_hdr *eip_hdr;
int expected_index, index;
ses_elem_index_type_t index_type;
eip_hdr = (struct ses_elm_addlstatus_eip_hdr *)elm_hdr;
if (eip_hdr->byte2 & SES_ADDL_EIP_EIIOE) {
index_type = SES_ELEM_INDEX_GLOBAL;
expected_index = iter.global_element_index;
} else {
index_type = SES_ELEM_INDEX_INDIVIDUAL;
expected_index = iter.individual_element_index;
}
titer = iter;
telement = ses_iter_seek_to(&titer,
eip_hdr->element_index, index_type);
if (telement != NULL &&
(ses_typehasaddlstatus(enc, titer.type_index) !=
TYPE_ADDLSTATUS_NONE ||
titer.type_index > ELMTYP_SAS_CONN)) {
iter = titer;
element = telement;
} else
ignore_index = 1;
if (eip_hdr->byte2 & SES_ADDL_EIP_EIIOE)
index = iter.global_element_index;
else
index = iter.individual_element_index;
if (index > expected_index
&& status_type == TYPE_ADDLSTATUS_MANDATORY) {
ENC_VLOG(enc, "%s: provided %s element"
"index %d skips mandatory status "
" element at index %d\n",
__func__, (eip_hdr->byte2 &
SES_ADDL_EIP_EIIOE) ? "global " : "",
index, expected_index);
}
}
elmpriv = element->elm_private;
elmpriv->addl.hdr = elm_hdr;
ENC_DLOG(enc, "%s: global element index=%d, type index=%d "
"type element index=%d, offset=0x%x, "
"byte0=0x%x, length=0x%x\n", __func__,
iter.global_element_index, iter.type_index,
iter.type_element_index, offset, elmpriv->addl.hdr->byte0,
elmpriv->addl.hdr->length);
/* Skip to after the length field */
offset += sizeof(struct ses_elm_addlstatus_base_hdr);
/* Make sure the descriptor is within bounds */
if ((offset + elmpriv->addl.hdr->length) > length) {
ENC_VLOG(enc, "Element %d Beyond End "
"of Additional Element Status Descriptors\n",
iter.global_element_index);
break;
}
/* Advance to the protocol data, skipping eip bytes if needed */
offset += (eip * SES_EIP_HDR_EXTRA_LEN);
proto_info_len = elmpriv->addl.hdr->length
- (eip * SES_EIP_HDR_EXTRA_LEN);
/* Errors in this block are ignored as they are non-fatal */
switch(ses_elm_addlstatus_proto(elmpriv->addl.hdr)) {
case SPSP_PROTO_FC:
if (elmpriv->addl.hdr->length == 0)
break;
ses_get_elm_addlstatus_fc(enc, enc_cache,
&buf[offset], proto_info_len);
break;
case SPSP_PROTO_SAS:
if (elmpriv->addl.hdr->length <= 2)
break;
ses_get_elm_addlstatus_sas(enc, enc_cache,
&buf[offset],
proto_info_len,
eip, iter.type_index,
iter.global_element_index);
break;
default:
ENC_VLOG(enc, "Element %d: Unknown Additional Element "
"Protocol 0x%x\n", iter.global_element_index,
ses_elm_addlstatus_proto(elmpriv->addl.hdr));
break;
}
offset += proto_info_len;
}
err = 0;
out:
if (err)
ses_cache_free_elm_addlstatus(enc, enc_cache);
enc_update_request(enc, SES_PUBLISH_PHYSPATHS);
enc_update_request(enc, SES_PUBLISH_CACHE);
return (err);
}
static int
ses_process_control_request(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t **bufp, int error, int xfer_len)
{
ses_softc_t *ses;
ses = enc->enc_private;
/*
* Possible errors:
* o Generation count wrong.
* o Some SCSI status error.
*/
ses_terminate_control_requests(&ses->ses_pending_requests, error);
ses_poll_status(enc);
return (0);
}
static int
ses_publish_physpaths(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t **bufp, int error, int xfer_len)
{
struct ses_iterator iter;
enc_cache_t *enc_cache;
enc_element_t *element;
enc_cache = &enc->enc_daemon_cache;
ses_iter_init(enc, enc_cache, &iter);
while ((element = ses_iter_next(&iter)) != NULL) {
/*
* ses_set_physpath() returns success if we changed
* the physpath of any element. This allows us to
* only announce devices once regardless of how
* many times we process additional element status.
*/
if (ses_set_physpath(enc, element, &iter) == 0)
ses_print_addl_data(enc, element);
}
return (0);
}
static int
ses_publish_cache(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t **bufp, int error, int xfer_len)
{
sx_xlock(&enc->enc_cache_lock);
ses_cache_clone(enc, /*src*/&enc->enc_daemon_cache,
/*dst*/&enc->enc_cache);
sx_xunlock(&enc->enc_cache_lock);
return (0);
}
/**
* \brief Parse the descriptors for each object.
*
* \param enc The SES softc to update.
* \param buf The buffer containing the descriptor list response.
* \param xfer_len Size of the buffer.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_process_elm_descs(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t **bufp, int error, int xfer_len)
{
ses_softc_t *ses;
struct ses_iterator iter;
enc_element_t *element;
int err;
int offset;
u_long length, plength;
enc_cache_t *enc_cache;
ses_cache_t *ses_cache;
uint8_t *buf;
ses_element_t *elmpriv;
const struct ses_page_hdr *phdr;
const struct ses_elm_desc_hdr *hdr;
ses = enc->enc_private;
enc_cache = &enc->enc_daemon_cache;
ses_cache = enc_cache->private;
buf = *bufp;
err = -1;
if (error != 0) {
err = error;
goto out;
}
ses_cache_free_elm_descs(enc, enc_cache);
ses_cache->elm_descs_page = (struct ses_elem_descr_page *)buf;
*bufp = NULL;
phdr = &ses_cache->elm_descs_page->hdr;
plength = ses_page_length(phdr);
if (xfer_len < sizeof(struct ses_page_hdr)) {
ENC_VLOG(enc, "Runt Element Descriptor Page\n");
goto out;
}
if (plength > xfer_len) {
ENC_VLOG(enc, "Element Descriptor Page Too Long\n");
goto out;
}
if (!ses_config_cache_valid(ses_cache, phdr->gen_code)) {
ENC_VLOG(enc, "%s: Generation count change detected\n",
__func__);
enc_update_request(enc, SES_UPDATE_GETCONFIG);
goto out;
}
offset = sizeof(struct ses_page_hdr);
ses_iter_init(enc, enc_cache, &iter);
while (offset < plength
&& (element = ses_iter_next(&iter)) != NULL) {
if ((offset + sizeof(struct ses_elm_desc_hdr)) > plength) {
ENC_VLOG(enc, "Element %d Descriptor Header Past "
"End of Buffer\n", iter.global_element_index);
goto out;
}
hdr = (struct ses_elm_desc_hdr *)&buf[offset];
length = scsi_2btoul(hdr->length);
ENC_DLOG(enc, "%s: obj %d(%d,%d) length=%d off=%d\n", __func__,
iter.global_element_index, iter.type_index,
iter.type_element_index, length, offset);
if ((offset + sizeof(*hdr) + length) > plength) {
ENC_VLOG(enc, "Element%d Descriptor Past "
"End of Buffer\n", iter.global_element_index);
goto out;
}
offset += sizeof(*hdr);
if (length > 0) {
elmpriv = element->elm_private;
elmpriv->descr_len = length;
elmpriv->descr = &buf[offset];
}
/* skip over the descriptor itself */
offset += length;
}
err = 0;
out:
if (err == 0) {
if (ses->ses_flags & SES_FLAG_ADDLSTATUS)
enc_update_request(enc, SES_UPDATE_GETELMADDLSTATUS);
}
enc_update_request(enc, SES_PUBLISH_CACHE);
return (err);
}
static int
ses_fill_rcv_diag_io(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t *buf)
{
if (enc->enc_type == ENC_SEMB_SES) {
semb_receive_diagnostic_results(&ccb->ataio, /*retries*/5,
NULL, MSG_SIMPLE_Q_TAG, /*pcv*/1,
state->page_code, buf, state->buf_size,
state->timeout);
} else {
scsi_receive_diagnostic_results(&ccb->csio, /*retries*/5,
NULL, MSG_SIMPLE_Q_TAG, /*pcv*/1,
state->page_code, buf, state->buf_size,
SSD_FULL_SIZE, state->timeout);
}
return (0);
}
/**
* \brief Encode the object status into the response buffer, which is
* expected to contain the current enclosure status. This function
* turns off all the 'select' bits for the objects except for the
* object specified, then sends it back to the enclosure.
*
* \param enc SES enclosure the change is being applied to.
* \param buf Buffer containing the current enclosure status response.
* \param amt Length of the response in the buffer.
* \param req The control request to be applied to buf.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_encode(enc_softc_t *enc, uint8_t *buf, int amt, ses_control_request_t *req)
{
struct ses_iterator iter;
enc_element_t *element;
int offset;
struct ses_control_page_hdr *hdr;
ses_iter_init(enc, &enc->enc_cache, &iter);
hdr = (struct ses_control_page_hdr *)buf;
if (req->elm_idx == -1) {
/* for enclosure status, at least 2 bytes are needed */
if (amt < 2)
return EIO;
hdr->control_flags =
req->elm_stat.comstatus & SES_SET_STATUS_MASK;
ENC_DLOG(enc, "Set EncStat %x\n", hdr->control_flags);
return (0);
}
element = ses_iter_seek_to(&iter, req->elm_idx, SES_ELEM_INDEX_GLOBAL);
if (element == NULL)
return (ENXIO);
/*
* Seek to the type set that corresponds to the requested object.
* The +1 is for the overall status element for the type.
*/
offset = sizeof(struct ses_control_page_hdr)
+ (iter.global_element_index * sizeof(struct ses_comstat));
/* Check for buffer overflow. */
if (offset + sizeof(struct ses_comstat) > amt)
return (EIO);
/* Set the status. */
memcpy(&buf[offset], &req->elm_stat, sizeof(struct ses_comstat));
ENC_DLOG(enc, "Set Type 0x%x Obj 0x%x (offset %d) with %x %x %x %x\n",
iter.type_index, iter.global_element_index, offset,
req->elm_stat.comstatus, req->elm_stat.comstat[0],
req->elm_stat.comstat[1], req->elm_stat.comstat[2]);
return (0);
}
static int
ses_fill_control_request(enc_softc_t *enc, struct enc_fsm_state *state,
union ccb *ccb, uint8_t *buf)
{
ses_softc_t *ses;
enc_cache_t *enc_cache;
ses_cache_t *ses_cache;
struct ses_control_page_hdr *hdr;
ses_control_request_t *req;
size_t plength;
size_t offset;
ses = enc->enc_private;
enc_cache = &enc->enc_daemon_cache;
ses_cache = enc_cache->private;
hdr = (struct ses_control_page_hdr *)buf;
if (ses_cache->status_page == NULL) {
ses_terminate_control_requests(&ses->ses_requests, EIO);
return (EIO);
}
plength = ses_page_length(&ses_cache->status_page->hdr);
memcpy(buf, ses_cache->status_page, plength);
/* Disable the select bits in all status entries. */
offset = sizeof(struct ses_control_page_hdr);
for (offset = sizeof(struct ses_control_page_hdr);
offset < plength; offset += sizeof(struct ses_comstat)) {
buf[offset] &= ~SESCTL_CSEL;
}
/* And make sure the INVOP bit is clear. */
hdr->control_flags &= ~SES_ENCSTAT_INVOP;
/* Apply incoming requests. */
while ((req = TAILQ_FIRST(&ses->ses_requests)) != NULL) {
TAILQ_REMOVE(&ses->ses_requests, req, links);
req->result = ses_encode(enc, buf, plength, req);
if (req->result != 0) {
wakeup(req);
continue;
}
TAILQ_INSERT_TAIL(&ses->ses_pending_requests, req, links);
}
if (TAILQ_EMPTY(&ses->ses_pending_requests) != 0)
return (ENOENT);
/* Fill out the ccb */
if (enc->enc_type == ENC_SEMB_SES) {
semb_send_diagnostic(&ccb->ataio, /*retries*/5, NULL,
MSG_SIMPLE_Q_TAG,
buf, ses_page_length(&ses_cache->status_page->hdr),
state->timeout);
} else {
scsi_send_diagnostic(&ccb->csio, /*retries*/5, NULL,
MSG_SIMPLE_Q_TAG, /*unit_offline*/0,
/*device_offline*/0, /*self_test*/0,
/*page_format*/1, /*self_test_code*/0,
buf, ses_page_length(&ses_cache->status_page->hdr),
SSD_FULL_SIZE, state->timeout);
}
return (0);
}
static int
ses_get_elm_addlstatus_fc(enc_softc_t *enc, enc_cache_t *enc_cache,
uint8_t *buf, int bufsiz)
{
ENC_VLOG(enc, "FC Device Support Stubbed in Additional Status Page\n");
return (ENODEV);
}
#define SES_PRINT_PORTS(p, type) do { \
sbuf_printf(sbp, " %s(", type); \
if (((p) & SES_SASOBJ_DEV_PHY_PROTOMASK) == 0) \
sbuf_printf(sbp, " None"); \
else { \
if ((p) & SES_SASOBJ_DEV_PHY_SMP) \
sbuf_printf(sbp, " SMP"); \
if ((p) & SES_SASOBJ_DEV_PHY_STP) \
sbuf_printf(sbp, " STP"); \
if ((p) & SES_SASOBJ_DEV_PHY_SSP) \
sbuf_printf(sbp, " SSP"); \
} \
sbuf_printf(sbp, " )"); \
} while(0)
/**
* \brief Print the additional element status data for this object, for SAS
* type 0 objects. See SES2 r20 Section 6.1.13.3.2.
*
* \param sesname SES device name associated with the object.
* \param sbp Sbuf to print to.
* \param obj The object to print the data for.
* \param periph_name Peripheral string associated with the object.
*/
static void
ses_print_addl_data_sas_type0(char *sesname, struct sbuf *sbp,
enc_element_t *obj, char *periph_name)
{
int i;
ses_element_t *elmpriv;
struct ses_addl_status *addl;
struct ses_elm_sas_device_phy *phy;
elmpriv = obj->elm_private;
addl = &(elmpriv->addl);
if (addl->proto_hdr.sas == NULL)
return;
sbuf_printf(sbp, "%s: %s: SAS Device Slot Element:",
sesname, periph_name);
sbuf_printf(sbp, " %d Phys", addl->proto_hdr.sas->base_hdr.num_phys);
if (ses_elm_addlstatus_eip(addl->hdr))
sbuf_printf(sbp, " at Slot %d",
addl->proto_hdr.sas->type0_eip.dev_slot_num);
if (ses_elm_sas_type0_not_all_phys(addl->proto_hdr.sas))
sbuf_printf(sbp, ", Not All Phys");
sbuf_printf(sbp, "\n");
if (addl->proto_data.sasdev_phys == NULL)
return;
for (i = 0;i < addl->proto_hdr.sas->base_hdr.num_phys;i++) {
phy = &addl->proto_data.sasdev_phys[i];
sbuf_printf(sbp, "%s: phy %d:", sesname, i);
if (ses_elm_sas_dev_phy_sata_dev(phy))
/* Spec says all other fields are specific values */
sbuf_printf(sbp, " SATA device\n");
else {
sbuf_printf(sbp, " SAS device type %d id %d\n",
ses_elm_sas_dev_phy_dev_type(phy), phy->phy_id);
sbuf_printf(sbp, "%s: phy %d: protocols:", sesname, i);
SES_PRINT_PORTS(phy->initiator_ports, "Initiator");
SES_PRINT_PORTS(phy->target_ports, "Target");
sbuf_printf(sbp, "\n");
}
sbuf_printf(sbp, "%s: phy %d: parent %jx addr %jx\n",
sesname, i,
(uintmax_t)scsi_8btou64(phy->parent_addr),
(uintmax_t)scsi_8btou64(phy->phy_addr));
}
}
#undef SES_PRINT_PORTS
/**
* \brief Report whether a given enclosure object is an expander.
*
* \param enc SES softc associated with object.
* \param obj Enclosure object to report for.
*
* \return 1 if true, 0 otherwise.
*/
static int
ses_obj_is_expander(enc_softc_t *enc, enc_element_t *obj)
{
return (obj->enctype == ELMTYP_SAS_EXP);
}
/**
* \brief Print the additional element status data for this object, for SAS
* type 1 objects. See SES2 r20 Sections 6.1.13.3.3 and 6.1.13.3.4.
*
* \param enc SES enclosure, needed for type identification.
* \param sesname SES device name associated with the object.
* \param sbp Sbuf to print to.
* \param obj The object to print the data for.
* \param periph_name Peripheral string associated with the object.
*/
static void
ses_print_addl_data_sas_type1(enc_softc_t *enc, char *sesname,
struct sbuf *sbp, enc_element_t *obj, char *periph_name)
{
int i, num_phys;
ses_element_t *elmpriv;
struct ses_addl_status *addl;
struct ses_elm_sas_expander_phy *exp_phy;
struct ses_elm_sas_port_phy *port_phy;
elmpriv = obj->elm_private;
addl = &(elmpriv->addl);
if (addl->proto_hdr.sas == NULL)
return;
sbuf_printf(sbp, "%s: %s: SAS ", sesname, periph_name);
if (ses_obj_is_expander(enc, obj)) {
num_phys = addl->proto_hdr.sas->base_hdr.num_phys;
sbuf_printf(sbp, "Expander: %d Phys", num_phys);
if (addl->proto_data.sasexp_phys == NULL)
return;
for (i = 0;i < num_phys;i++) {
exp_phy = &addl->proto_data.sasexp_phys[i];
sbuf_printf(sbp, "%s: phy %d: connector %d other %d\n",
sesname, i, exp_phy->connector_index,
exp_phy->other_index);
}
} else {
num_phys = addl->proto_hdr.sas->base_hdr.num_phys;
sbuf_printf(sbp, "Port: %d Phys", num_phys);
if (addl->proto_data.sasport_phys == NULL)
return;
for (i = 0;i < num_phys;i++) {
port_phy = &addl->proto_data.sasport_phys[i];
sbuf_printf(sbp,
"%s: phy %d: id %d connector %d other %d\n",
sesname, i, port_phy->phy_id,
port_phy->connector_index, port_phy->other_index);
sbuf_printf(sbp, "%s: phy %d: addr %jx\n", sesname, i,
(uintmax_t)scsi_8btou64(port_phy->phy_addr));
}
}
}
/**
* \brief Print the additional element status data for this object.
*
* \param enc SES softc associated with the object.
* \param obj The object to print the data for.
*/
static void
ses_print_addl_data(enc_softc_t *enc, enc_element_t *obj)
{
ses_element_t *elmpriv;
struct ses_addl_status *addl;
struct sbuf sesname, name, out;
elmpriv = obj->elm_private;
if (elmpriv == NULL)
return;
addl = &(elmpriv->addl);
if (addl->hdr == NULL)
return;
sbuf_new(&sesname, NULL, 16, SBUF_AUTOEXTEND);
sbuf_new(&name, NULL, 16, SBUF_AUTOEXTEND);
sbuf_new(&out, NULL, 512, SBUF_AUTOEXTEND);
ses_paths_iter(enc, obj, ses_elmdevname_callback, &name);
if (sbuf_len(&name) == 0)
sbuf_printf(&name, "(none)");
sbuf_finish(&name);
sbuf_printf(&sesname, "%s%d", enc->periph->periph_name,
enc->periph->unit_number);
sbuf_finish(&sesname);
if (elmpriv->descr != NULL)
sbuf_printf(&out, "%s: %s: Element descriptor: '%s'\n",
sbuf_data(&sesname), sbuf_data(&name), elmpriv->descr);
switch(ses_elm_addlstatus_proto(addl->hdr)) {
case SPSP_PROTO_SAS:
switch(ses_elm_sas_descr_type(addl->proto_hdr.sas)) {
case SES_SASOBJ_TYPE_SLOT:
ses_print_addl_data_sas_type0(sbuf_data(&sesname),
&out, obj, sbuf_data(&name));
break;
case SES_SASOBJ_TYPE_OTHER:
ses_print_addl_data_sas_type1(enc, sbuf_data(&sesname),
&out, obj, sbuf_data(&name));
break;
default:
break;
}
break;
case SPSP_PROTO_FC: /* stubbed for now */
break;
default:
break;
}
sbuf_finish(&out);
printf("%s", sbuf_data(&out));
sbuf_delete(&out);
sbuf_delete(&name);
sbuf_delete(&sesname);
}
/**
* \brief Update the softc with the additional element status data for this
* object, for SAS type 0 objects.
*
* \param enc SES softc to be updated.
* \param buf The additional element status response buffer.
* \param bufsiz Size of the response buffer.
* \param eip The EIP bit value.
* \param nobj Number of objects attached to the SES softc.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_get_elm_addlstatus_sas_type0(enc_softc_t *enc, enc_cache_t *enc_cache,
uint8_t *buf, int bufsiz, int eip, int nobj)
{
int err, offset, physz;
enc_element_t *obj;
ses_element_t *elmpriv;
struct ses_addl_status *addl;
err = offset = 0;
/* basic object setup */
obj = &(enc_cache->elm_map[nobj]);
elmpriv = obj->elm_private;
addl = &(elmpriv->addl);
addl->proto_hdr.sas = (union ses_elm_sas_hdr *)&buf[offset];
/* Don't assume this object has any phys */
bzero(&addl->proto_data, sizeof(addl->proto_data));
if (addl->proto_hdr.sas->base_hdr.num_phys == 0)
goto out;
/* Skip forward to the phy list */
if (eip)
offset += sizeof(struct ses_elm_sas_type0_eip_hdr);
else
offset += sizeof(struct ses_elm_sas_type0_base_hdr);
/* Make sure the phy list fits in the buffer */
physz = addl->proto_hdr.sas->base_hdr.num_phys;
physz *= sizeof(struct ses_elm_sas_device_phy);
if (physz > (bufsiz - offset + 4)) {
ENC_VLOG(enc, "Element %d Device Phy List Beyond End Of Buffer\n",
nobj);
err = EIO;
goto out;
}
/* Point to the phy list */
addl->proto_data.sasdev_phys =
(struct ses_elm_sas_device_phy *)&buf[offset];
out:
return (err);
}
/**
* \brief Update the softc with the additional element status data for this
* object, for SAS type 1 objects.
*
* \param enc SES softc to be updated.
* \param buf The additional element status response buffer.
* \param bufsiz Size of the response buffer.
* \param eip The EIP bit value.
* \param nobj Number of objects attached to the SES softc.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_get_elm_addlstatus_sas_type1(enc_softc_t *enc, enc_cache_t *enc_cache,
uint8_t *buf, int bufsiz, int eip, int nobj)
{
int err, offset, physz;
enc_element_t *obj;
ses_element_t *elmpriv;
struct ses_addl_status *addl;
err = offset = 0;
/* basic object setup */
obj = &(enc_cache->elm_map[nobj]);
elmpriv = obj->elm_private;
addl = &(elmpriv->addl);
addl->proto_hdr.sas = (union ses_elm_sas_hdr *)&buf[offset];
/* Don't assume this object has any phys */
bzero(&addl->proto_data, sizeof(addl->proto_data));
if (addl->proto_hdr.sas->base_hdr.num_phys == 0)
goto out;
/* Process expanders differently from other type1 cases */
if (ses_obj_is_expander(enc, obj)) {
offset += sizeof(struct ses_elm_sas_type1_expander_hdr);
physz = addl->proto_hdr.sas->base_hdr.num_phys *
sizeof(struct ses_elm_sas_expander_phy);
if (physz > (bufsiz - offset)) {
ENC_VLOG(enc, "Element %d: Expander Phy List Beyond "
"End Of Buffer\n", nobj);
err = EIO;
goto out;
}
addl->proto_data.sasexp_phys =
(struct ses_elm_sas_expander_phy *)&buf[offset];
} else {
offset += sizeof(struct ses_elm_sas_type1_nonexpander_hdr);
physz = addl->proto_hdr.sas->base_hdr.num_phys *
sizeof(struct ses_elm_sas_port_phy);
if (physz > (bufsiz - offset + 4)) {
ENC_VLOG(enc, "Element %d: Port Phy List Beyond End "
"Of Buffer\n", nobj);
err = EIO;
goto out;
}
addl->proto_data.sasport_phys =
(struct ses_elm_sas_port_phy *)&buf[offset];
}
out:
return (err);
}
/**
* \brief Update the softc with the additional element status data for this
* object, for SAS objects.
*
* \param enc SES softc to be updated.
* \param buf The additional element status response buffer.
* \param bufsiz Size of the response buffer.
* \param eip The EIP bit value.
* \param tidx Type index for this object.
* \param nobj Number of objects attached to the SES softc.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_get_elm_addlstatus_sas(enc_softc_t *enc, enc_cache_t *enc_cache,
uint8_t *buf, int bufsiz, int eip, int tidx,
int nobj)
{
int dtype, err;
ses_cache_t *ses_cache;
union ses_elm_sas_hdr *hdr;
/* Need to be able to read the descriptor type! */
if (bufsiz < sizeof(union ses_elm_sas_hdr)) {
err = EIO;
goto out;
}
ses_cache = enc_cache->private;
hdr = (union ses_elm_sas_hdr *)buf;
dtype = ses_elm_sas_descr_type(hdr);
switch(dtype) {
case SES_SASOBJ_TYPE_SLOT:
switch(ses_cache->ses_types[tidx].hdr->etype_elm_type) {
case ELMTYP_DEVICE:
case ELMTYP_ARRAY_DEV:
break;
default:
ENC_VLOG(enc, "Element %d has Additional Status type 0, "
"invalid for SES element type 0x%x\n", nobj,
ses_cache->ses_types[tidx].hdr->etype_elm_type);
err = ENODEV;
goto out;
}
err = ses_get_elm_addlstatus_sas_type0(enc, enc_cache,
buf, bufsiz, eip,
nobj);
break;
case SES_SASOBJ_TYPE_OTHER:
switch(ses_cache->ses_types[tidx].hdr->etype_elm_type) {
case ELMTYP_SAS_EXP:
case ELMTYP_SCSI_INI:
case ELMTYP_SCSI_TGT:
case ELMTYP_ESCC:
break;
default:
ENC_VLOG(enc, "Element %d has Additional Status type 1, "
"invalid for SES element type 0x%x\n", nobj,
ses_cache->ses_types[tidx].hdr->etype_elm_type);
err = ENODEV;
goto out;
}
err = ses_get_elm_addlstatus_sas_type1(enc, enc_cache, buf,
bufsiz, eip, nobj);
break;
default:
ENC_VLOG(enc, "Element %d of type 0x%x has Additional Status "
"of unknown type 0x%x\n", nobj,
ses_cache->ses_types[tidx].hdr->etype_elm_type, dtype);
err = ENODEV;
break;
}
out:
return (err);
}
static void
ses_softc_invalidate(enc_softc_t *enc)
{
ses_softc_t *ses;
ses = enc->enc_private;
ses_terminate_control_requests(&ses->ses_requests, ENXIO);
}
static void
ses_softc_cleanup(enc_softc_t *enc)
{
ses_cache_free(enc, &enc->enc_cache);
ses_cache_free(enc, &enc->enc_daemon_cache);
ENC_FREE_AND_NULL(enc->enc_private);
ENC_FREE_AND_NULL(enc->enc_cache.private);
ENC_FREE_AND_NULL(enc->enc_daemon_cache.private);
}
static int
ses_init_enc(enc_softc_t *enc)
{
return (0);
}
static int
ses_get_enc_status(enc_softc_t *enc, int slpflag)
{
/* Automatically updated, caller checks enc_cache->encstat itself */
return (0);
}
static int
ses_set_enc_status(enc_softc_t *enc, uint8_t encstat, int slpflag)
{
ses_control_request_t req;
ses_softc_t *ses;
ses = enc->enc_private;
req.elm_idx = SES_SETSTATUS_ENC_IDX;
req.elm_stat.comstatus = encstat & 0xf;
TAILQ_INSERT_TAIL(&ses->ses_requests, &req, links);
enc_update_request(enc, SES_PROCESS_CONTROL_REQS);
cam_periph_sleep(enc->periph, &req, PUSER, "encstat", 0);
return (req.result);
}
static int
ses_get_elm_status(enc_softc_t *enc, encioc_elm_status_t *elms, int slpflag)
{
unsigned int i = elms->elm_idx;
memcpy(elms->cstat, &enc->enc_cache.elm_map[i].encstat, 4);
return (0);
}
static int
ses_set_elm_status(enc_softc_t *enc, encioc_elm_status_t *elms, int slpflag)
{
ses_control_request_t req;
ses_softc_t *ses;
/* If this is clear, we don't do diddly. */
if ((elms->cstat[0] & SESCTL_CSEL) == 0)
return (0);
ses = enc->enc_private;
req.elm_idx = elms->elm_idx;
memcpy(&req.elm_stat, elms->cstat, sizeof(req.elm_stat));
TAILQ_INSERT_TAIL(&ses->ses_requests, &req, links);
enc_update_request(enc, SES_PROCESS_CONTROL_REQS);
cam_periph_sleep(enc->periph, &req, PUSER, "encstat", 0);
return (req.result);
}
static int
ses_get_elm_desc(enc_softc_t *enc, encioc_elm_desc_t *elmd)
{
int i = (int)elmd->elm_idx;
ses_element_t *elmpriv;
/* Assume caller has already checked obj_id validity */
elmpriv = enc->enc_cache.elm_map[i].elm_private;
/* object might not have a descriptor */
if (elmpriv == NULL || elmpriv->descr == NULL) {
elmd->elm_desc_len = 0;
return (0);
}
if (elmd->elm_desc_len > elmpriv->descr_len)
elmd->elm_desc_len = elmpriv->descr_len;
copyout(elmpriv->descr, elmd->elm_desc_str, elmd->elm_desc_len);
return (0);
}
/**
* \brief Respond to ENCIOC_GETELMDEVNAME, providing a device name for the
* given object id if one is available.
*
* \param enc SES softc to examine.
* \param objdn ioctl structure to read/write device name info.
*
* \return 0 on success, errno otherwise.
*/
static int
ses_get_elm_devnames(enc_softc_t *enc, encioc_elm_devnames_t *elmdn)
{
struct sbuf sb;
int len;
len = elmdn->elm_names_size;
if (len < 0)
return (EINVAL);
cam_periph_unlock(enc->periph);
sbuf_new(&sb, NULL, len, SBUF_FIXEDLEN);
ses_paths_iter(enc, &enc->enc_cache.elm_map[elmdn->elm_idx],
ses_elmdevname_callback, &sb);
sbuf_finish(&sb);
elmdn->elm_names_len = sbuf_len(&sb);
copyout(sbuf_data(&sb), elmdn->elm_devnames, elmdn->elm_names_len + 1);
sbuf_delete(&sb);
cam_periph_lock(enc->periph);
return (elmdn->elm_names_len > 0 ? 0 : ENODEV);
}
/**
* \brief Send a string to the primary subenclosure using the String Out
* SES diagnostic page.
*
* \param enc SES enclosure to run the command on.
* \param sstr SES string structure to operate on
* \param ioc Ioctl being performed
*
* \return 0 on success, errno otherwise.
*/
static int
ses_handle_string(enc_softc_t *enc, encioc_string_t *sstr, int ioc)
{
ses_softc_t *ses;
enc_cache_t *enc_cache;
ses_cache_t *ses_cache;
const struct ses_enc_desc *enc_desc;
int amt, payload, ret;
char cdb[6];
char str[32];
char vendor[9];
char product[17];
char rev[5];
uint8_t *buf;
size_t size, rsize;
ses = enc->enc_private;
enc_cache = &enc->enc_daemon_cache;
ses_cache = enc_cache->private;
/* Implement SES2r20 6.1.6 */
if (sstr->bufsiz > 0xffff)
return (EINVAL); /* buffer size too large */
if (ioc == ENCIOC_SETSTRING) {
payload = sstr->bufsiz + 4; /* header for SEND DIAGNOSTIC */
amt = 0 - payload;
buf = ENC_MALLOC(payload);
if (buf == NULL)
return ENOMEM;
ses_page_cdb(cdb, payload, 0, CAM_DIR_OUT);
/* Construct the page request */
buf[0] = SesStringOut;
buf[1] = 0;
buf[2] = sstr->bufsiz >> 8;
buf[3] = sstr->bufsiz & 0xff;
memcpy(&buf[4], sstr->buf, sstr->bufsiz);
} else if (ioc == ENCIOC_GETSTRING) {
payload = sstr->bufsiz;
amt = payload;
ses_page_cdb(cdb, payload, SesStringIn, CAM_DIR_IN);
buf = sstr->buf;
} else if (ioc == ENCIOC_GETENCNAME) {
if (ses_cache->ses_nsubencs < 1)
return (ENODEV);
enc_desc = ses_cache->subencs[0];
cam_strvis(vendor, enc_desc->vendor_id,
sizeof(enc_desc->vendor_id), sizeof(vendor));
cam_strvis(product, enc_desc->product_id,
sizeof(enc_desc->product_id), sizeof(product));
cam_strvis(rev, enc_desc->product_rev,
sizeof(enc_desc->product_rev), sizeof(rev));
rsize = snprintf(str, sizeof(str), "%s %s %s",
vendor, product, rev) + 1;
if (rsize > sizeof(str))
rsize = sizeof(str);
copyout(&rsize, &sstr->bufsiz, sizeof(rsize));
size = rsize;
if (size > sstr->bufsiz)
size = sstr->bufsiz;
copyout(str, sstr->buf, size);
return (size == rsize ? 0 : ENOMEM);
} else if (ioc == ENCIOC_GETENCID) {
if (ses_cache->ses_nsubencs < 1)
return (ENODEV);
enc_desc = ses_cache->subencs[0];
rsize = snprintf(str, sizeof(str), "%16jx",
scsi_8btou64(enc_desc->logical_id)) + 1;
if (rsize > sizeof(str))
rsize = sizeof(str);
copyout(&rsize, &sstr->bufsiz, sizeof(rsize));
size = rsize;
if (size > sstr->bufsiz)
size = sstr->bufsiz;
copyout(str, sstr->buf, size);
return (size == rsize ? 0 : ENOMEM);
} else
return EINVAL;
ret = enc_runcmd(enc, cdb, 6, buf, &amt);
if (ioc == ENCIOC_SETSTRING)
ENC_FREE(buf);
return ret;
}
/**
* \invariant Called with cam_periph mutex held.
*/
static void
ses_poll_status(enc_softc_t *enc)
{
ses_softc_t *ses;
ses = enc->enc_private;
enc_update_request(enc, SES_UPDATE_GETSTATUS);
if (ses->ses_flags & SES_FLAG_DESC)
enc_update_request(enc, SES_UPDATE_GETELMDESCS);
if (ses->ses_flags & SES_FLAG_ADDLSTATUS)
enc_update_request(enc, SES_UPDATE_GETELMADDLSTATUS);
}
/**
* \brief Notification received when CAM detects a new device in the
* SCSI domain in which this SEP resides.
*
* \param enc SES enclosure instance.
*/
static void
ses_device_found(enc_softc_t *enc)
{
ses_poll_status(enc);
enc_update_request(enc, SES_PUBLISH_PHYSPATHS);
}
static struct enc_vec ses_enc_vec =
{
.softc_invalidate = ses_softc_invalidate,
.softc_cleanup = ses_softc_cleanup,
.init_enc = ses_init_enc,
.get_enc_status = ses_get_enc_status,
.set_enc_status = ses_set_enc_status,
.get_elm_status = ses_get_elm_status,
.set_elm_status = ses_set_elm_status,
.get_elm_desc = ses_get_elm_desc,
.get_elm_devnames = ses_get_elm_devnames,
.handle_string = ses_handle_string,
.device_found = ses_device_found,
.poll_status = ses_poll_status
};
/**
* \brief Initialize a new SES instance.
*
* \param enc SES softc structure to set up the instance in.
* \param doinit Do the initialization (see main driver).
*
* \return 0 on success, errno otherwise.
*/
int
ses_softc_init(enc_softc_t *enc)
{
ses_softc_t *ses_softc;
CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE,
("entering enc_softc_init(%p)\n", enc));
enc->enc_vec = ses_enc_vec;
enc->enc_fsm_states = enc_fsm_states;
if (enc->enc_private == NULL)
enc->enc_private = ENC_MALLOCZ(sizeof(ses_softc_t));
if (enc->enc_cache.private == NULL)
enc->enc_cache.private = ENC_MALLOCZ(sizeof(ses_cache_t));
if (enc->enc_daemon_cache.private == NULL)
enc->enc_daemon_cache.private =
ENC_MALLOCZ(sizeof(ses_cache_t));
if (enc->enc_private == NULL
|| enc->enc_cache.private == NULL
|| enc->enc_daemon_cache.private == NULL) {
ENC_FREE_AND_NULL(enc->enc_private);
ENC_FREE_AND_NULL(enc->enc_cache.private);
ENC_FREE_AND_NULL(enc->enc_daemon_cache.private);
return (ENOMEM);
}
ses_softc = enc->enc_private;
TAILQ_INIT(&ses_softc->ses_requests);
TAILQ_INIT(&ses_softc->ses_pending_requests);
enc_update_request(enc, SES_UPDATE_PAGES);
// XXX: Move this to the FSM so it doesn't hang init
if (0) (void) ses_set_timed_completion(enc, 1);
return (0);
}
Reference in New Issue View Git Blame Copy Permalink