Ticket #1653: smartctl.diff

File smartctl.diff, 16.9 KB (added by steven.song, 17 months ago)

New patch

  • ChangeLog

     
    11$Id$
    22
     3<<<<<<< .mine
     42022-11-25 Steven Song <steven.song@3snic.com>
     5
     6        Add SSSRAID (3SNIC RAID Controller) support on Linux
     7
     8=======
    392022-11-22  Christian Franke  <franke@computer.org>
    410
    511        os_win32.cpp: Decode Windows 10 and 11 22H2 build numbers.
    … …  
    327333        should be reversed (and then put back in after the release,
    328334        for the next cycle).
    329335
     336>>>>>>> .r5419
    3303372022-02-28  Christian Franke  <franke@computer.org>
    331338
    332339        smartmontools 7.3

  • Makefile.am

     
    115115        dev_areca.h \
    116116        dev_legacy.cpp \
    117117        linux_nvme_ioctl.h \
    118         megaraid.h
     118        megaraid.h \
     119        sssraid.h
    119120
    120121if OS_WIN32_MINGW
    121122
    … …  
    188189        linux_nvme_ioctl.h \
    189190        freebsd_nvme_ioctl.h \
    190191        netbsd_nvme_ioctl.h \
    191         megaraid.h
     192        megaraid.h \
     193        sssraid.h
    192194
    193195if OS_POSIX
    194196

  • os_linux.cpp

     
    7373#include "utility.h"
    7474#include "cciss.h"
    7575#include "megaraid.h"
     76#include "sssraid.h"
    7677#include "aacraid.h"
    7778#include "nvmecmds.h"
    7879
    … …  
    13751376}
    13761377
    13771378/////////////////////////////////////////////////////////////////////////////
     1379/// 3SNIC RAID support
     1380
     1381class linux_sssraid_device
     1382: public /* implements */ scsi_device,
     1383  public /* extends */ linux_smart_device
     1384{
     1385public:
     1386  linux_sssraid_device(smart_interface *intf, const char *name,
     1387    unsigned int eid, unsigned int sid);
     1388
     1389  virtual bool scsi_pass_through(scsi_cmnd_io *iop) override;
     1390
     1391private:
     1392  unsigned int m_eid;
     1393  unsigned int m_sid;
     1394
     1395  bool scsi_cmd(int cdbLen, void *cdb, int dataLen, void *data, int direction);
     1396};
     1397
     1398linux_sssraid_device::linux_sssraid_device(smart_interface *intf,
     1399  const char *dev_name, unsigned int eid, unsigned int sid)
     1400 : smart_device(intf, dev_name, "sssraid", "sssraid"),
     1401   linux_smart_device(O_RDWR | O_NONBLOCK),
     1402   m_eid(eid), m_sid(sid)
     1403{
     1404  set_info().info_name = strprintf("%s [sssraid_disk_%02d_%02d]", dev_name, eid, sid);
     1405  set_info().dev_type = strprintf("sssraid,%d,%d", eid, sid);
     1406}
     1407
     1408bool linux_sssraid_device::scsi_pass_through(scsi_cmnd_io *iop)
     1409{
     1410  int report = scsi_debugmode;
     1411  if (report > 0) {
     1412    int k, j;
     1413    const unsigned char * ucp = iop->cmnd;
     1414    const char * np;
     1415    char buff[256];
     1416    const int sz = (int)sizeof(buff);
     1417
     1418    np = scsi_get_opcode_name(ucp[0]);
     1419    j = snprintf(buff, sz, " [%s: ", np ? np : "<unknown opcode>");
     1420    for (k = 0; k < (int)iop->cmnd_len; ++k)
     1421      j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "%02x ", ucp[k]);
     1422    if ((report > 1) && (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
     1423      int trunc = (iop->dxfer_len > 256) ? 1 : 0;
     1424
     1425      snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n  Outgoing "
     1426              "data, len=%d%s:\n", (int)iop->dxfer_len,
     1427              (trunc ? " [only first 256 bytes shown]" : ""));
     1428      dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len) , 1);
     1429    }
     1430    else
     1431      snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n");
     1432    pout("%s", buff);
     1433  }
     1434
     1435  bool r = scsi_cmd(iop->cmnd_len, iop->cmnd,
     1436          iop->dxfer_len, iop->dxferp, iop->dxfer_dir);
     1437  return r;
     1438}
     1439
     1440/* Issue passthrough scsi commands to sssraid controllers */
     1441bool linux_sssraid_device::scsi_cmd(int cdbLen, void *cdb,
     1442  int dataLen, void *data, int dxfer_dir)
     1443{
     1444  struct sg_io_v4 io_hdr_v4;
     1445  struct cmd_scsi_passthrough scsi_param;
     1446  unsigned char sense_buff[96] = { 0 };
     1447  struct bsg_ioctl_cmd bsg_param;
     1448  memset(&io_hdr_v4, 0, sizeof(io_hdr_v4));
     1449  memset(&scsi_param, 0, sizeof(scsi_param));
     1450  memset(&bsg_param, 0, sizeof(bsg_param));
     1451  scsi_param.sense_buffer = sense_buff;
     1452  scsi_param.sense_buffer_len = 96;
     1453  scsi_param.cdb_len = cdbLen;
     1454  memcpy(scsi_param.cdb, cdb, cdbLen);
     1455  scsi_param.loc.enc_id = m_eid;
     1456  scsi_param.loc.slot_id = m_sid;
     1457
     1458  io_hdr_v4.guard = 'Q';
     1459  io_hdr_v4.protocol = BSG_PROTOCOL_SCSI;
     1460  io_hdr_v4.subprotocol = BSG_SUB_PROTOCOL_SCSI_TRANSPORT;
     1461  io_hdr_v4.response = (uintptr_t)sense_buff;
     1462  io_hdr_v4.max_response_len = ADM_SCSI_CDB_SENSE_MAX_LEN;
     1463  io_hdr_v4.request_len = sizeof(struct bsg_ioctl_cmd);
     1464  io_hdr_v4.request = (uintptr_t)(&bsg_param);
     1465  io_hdr_v4.timeout =  BSG_APPEND_TIMEOUT_MS + DEFAULT_CONMMAND_TIMEOUT_MS;
     1466
     1467  switch (dxfer_dir) {
     1468    case DXFER_NONE:
     1469    case DXFER_FROM_DEVICE:
     1470      io_hdr_v4.din_xferp = (uintptr_t)data;
     1471      io_hdr_v4.din_xfer_len = dataLen;
     1472      bsg_param.ioctl_pthru.opcode = ADM_RAID_READ;
     1473      break;
     1474    case DXFER_TO_DEVICE:
     1475      io_hdr_v4.dout_xferp = (uintptr_t)data;
     1476      io_hdr_v4.dout_xfer_len = dataLen;
     1477      bsg_param.ioctl_pthru.opcode = ADM_RAID_WRITE;
     1478      break;
     1479    default:
     1480      pout("scsi_cmd: bad dxfer_dir\n");
     1481      return set_err(EINVAL, "scsi_cmd: bad dxfer_dir\n");
     1482  }
     1483
     1484  bsg_param.msgcode = ADM_BSG_MSGCODE_SCSI_PTHRU;
     1485  bsg_param.ioctl_pthru.timeout_ms = DEFAULT_CONMMAND_TIMEOUT_MS;
     1486  bsg_param.ioctl_pthru.info_1.subopcode = ADM_CMD_SCSI_PASSTHROUGH;
     1487  bsg_param.ioctl_pthru.addr = (uintptr_t)data;
     1488  bsg_param.ioctl_pthru.data_len = dataLen;
     1489
     1490  bsg_param.ioctl_pthru.info_0.cdb_len = scsi_param.cdb_len;
     1491  bsg_param.ioctl_pthru.sense_addr = (uintptr_t)scsi_param.sense_buffer;
     1492  bsg_param.ioctl_pthru.info_0.res_sense_len = scsi_param.sense_buffer_len;
     1493  io_hdr_v4.response = (uintptr_t)scsi_param.sense_buffer;
     1494  io_hdr_v4.response_len = scsi_param.sense_buffer_len;
     1495  bsg_param.ioctl_pthru.info_3.eid = scsi_param.loc.enc_id;
     1496  bsg_param.ioctl_pthru.info_3.sid = scsi_param.loc.slot_id;
     1497  bsg_param.ioctl_pthru.info_4.did = scsi_param.loc.did;
     1498  bsg_param.ioctl_pthru.info_4.did_flag = scsi_param.loc.flag;
     1499
     1500  memcpy(&bsg_param.ioctl_pthru.cdw16, scsi_param.cdb, scsi_param.cdb_len);
     1501
     1502  int r = ioctl(get_fd(), SG_IO, &io_hdr_v4);
     1503  if (r < 0) {
     1504    return (r);
     1505  }
     1506
     1507  return true;
     1508}
     1509
     1510/////////////////////////////////////////////////////////////////////////////
    13781511/// CCISS RAID support
    13791512
    13801513#ifdef HAVE_LINUX_CCISS_IOCTL_H
    … …  
    27122845  int megasas_dcmd_cmd(int bus_no, uint32_t opcode, void *buf,
    27132846    size_t bufsize, uint8_t *mbox, size_t mboxlen, uint8_t *statusp);
    27142847  int megasas_pd_add_list(int bus_no, smart_device_list & devlist);
     2848  bool get_dev_sssraid(smart_device_list & devlist);
     2849  int sssraid_pd_add_list(int bus_no, smart_device_list & devlist);
     2850  int sssraid_pdlist_cmd(int bus_no, uint16_t start_idx, void *buf, size_t bufsize, uint8_t *statusp);
    27152851};
    27162852
    27172853std::string linux_smart_interface::get_os_version_str()
    … …  
    28923028  return true;
    28933029}
    28943030
     3031// getting devices from 3SNIC Raid, if available
     3032bool linux_smart_interface::get_dev_sssraid(smart_device_list & devlist)
     3033{
     3034  /* Scanning of disks on sssraid device */
     3035  char line[128];
     3036  FILE * fp = NULL;
     3037
     3038  // getting bus numbers with 3snic sas devices
     3039  // we are using sysfs to get list of all scsi hosts
     3040  DIR * dp = opendir ("/sys/class/scsi_host/");
     3041  if (dp != NULL)
     3042  {
     3043    struct dirent *ep;
     3044    while ((ep = readdir (dp)) != NULL) {
     3045      unsigned int host_no = 0;
     3046      if (!sscanf(ep->d_name, "host%u", &host_no))
     3047        continue;
     3048      /* proc_name should be sssraid */
     3049      char sysfsdir[256];
     3050      snprintf(sysfsdir, sizeof(sysfsdir) - 1,
     3051        "/sys/class/scsi_host/host%u/proc_name", host_no);
     3052      if((fp = fopen(sysfsdir, "r")) == NULL)
     3053        continue;
     3054      if(fgets(line, sizeof(line), fp) != NULL && !strncmp(line,"sssraid",7)) {
     3055        sssraid_pd_add_list(host_no, devlist);
     3056      }
     3057      fclose(fp);
     3058    }
     3059    (void) closedir (dp);
     3060  } else { /* sysfs not mounted ? */
     3061    for(unsigned i = 0; i <=16; i++) // trying to add devices on first 16 buses
     3062      sssraid_pd_add_list(i, devlist);
     3063  }
     3064  return true;
     3065}
     3066
    28953067bool linux_smart_interface::scan_smart_devices(smart_device_list & devlist,
    28963068  const smart_devtype_list & types, const char * pattern /*= 0*/)
    28973069{
    … …  
    29483120
    29493121    // get device list from the megaraid device
    29503122    get_dev_megasas(devlist);
     3123    // get device list from the sssraid device
     3124    get_dev_sssraid(devlist);
    29513125  }
    29523126
    29533127  if (type_nvme) {
    … …  
    30743248  return (0);
    30753249}
    30763250
     3251int
     3252linux_smart_interface::sssraid_pdlist_cmd(int bus_no, uint16_t start_idx_param, void *buf, size_t bufsize, uint8_t *statusp)
     3253{
     3254  struct sg_io_v4 io_hdr_v4;
     3255  unsigned char sense_buff[ADM_SCSI_CDB_SENSE_MAX_LEN] = { 0 };
     3256  struct bsg_ioctl_cmd bsg_param;
     3257  u8 cmd_param[24] = { 0 };
     3258
     3259  memset(&io_hdr_v4, 0, sizeof(io_hdr_v4));
     3260  memset(&bsg_param, 0, sizeof(bsg_param));
     3261  io_hdr_v4.guard = 'Q';
     3262  io_hdr_v4.protocol = BSG_PROTOCOL_SCSI;
     3263  io_hdr_v4.subprotocol = BSG_SUB_PROTOCOL_SCSI_TRANSPORT;
     3264  io_hdr_v4.response = (uintptr_t)sense_buff;
     3265  io_hdr_v4.max_response_len = ADM_SCSI_CDB_SENSE_MAX_LEN;
     3266  io_hdr_v4.request_len = sizeof(struct bsg_ioctl_cmd);
     3267  io_hdr_v4.request = (uintptr_t)(&bsg_param);
     3268  io_hdr_v4.timeout = BSG_APPEND_TIMEOUT_MS + DEFAULT_CONMMAND_TIMEOUT_MS;
     3269
     3270  if (bufsize >0)  {
     3271    io_hdr_v4.din_xferp = (uintptr_t)buf;
     3272    io_hdr_v4.din_xfer_len = bufsize;
     3273  }
     3274
     3275  bsg_param.msgcode = 0;
     3276  bsg_param.ioctl_r64.opcode = ADM_RAID_READ;
     3277  bsg_param.ioctl_r64.timeout_ms = DEFAULT_CONMMAND_TIMEOUT_MS;
     3278  bsg_param.ioctl_r64.info_0.subopcode = ADM_CMD_SHOW_PDLIST;
     3279  bsg_param.ioctl_r64.addr = (uintptr_t)buf;
     3280  bsg_param.ioctl_r64.info_1.data_len = bufsize;
     3281  bsg_param.ioctl_r64.data_len = bufsize;
     3282  bsg_param.ioctl_r64.info_1.param_len = sizeof(struct cmd_pdlist_idx);
     3283  memset(&cmd_param, 0, 24);
     3284  struct cmd_pdlist_idx *p_cmd_param = (struct cmd_pdlist_idx *)(&cmd_param);
     3285  p_cmd_param->start_idx = start_idx_param;
     3286  p_cmd_param->count = CMD_PDLIST_ONCE_NUM;
     3287  memcpy((u32*)&bsg_param.ioctl_r64.cdw10, cmd_param, sizeof(struct cmd_pdlist_idx));
     3288
     3289  int fd;
     3290  char line[128];
     3291  snprintf(line, sizeof(line) - 1, "/dev/bsg/sssraid%d", bus_no);
     3292  if ((fd = ::open(line, O_RDONLY)) < 0) {
     3293    pout("open %s error %d\n", line, fd);
     3294    return (errno);
     3295  }
     3296
     3297  int r = ioctl(fd, SG_IO, &io_hdr_v4);
     3298  ::close(fd);
     3299  if (r < 0) {
     3300    return (r);
     3301  }
     3302
     3303  if (statusp != NULL) {
     3304    *statusp = (io_hdr_v4.transport_status << 0x8) | io_hdr_v4.device_status;
     3305    pout("statusp = 0x%x\n", *statusp);
     3306    if (*statusp) {
     3307      pout("controller returns an error - 0x%x", *statusp);
     3308      return (-1);
     3309    }
     3310  }
     3311  return (0);
     3312}
     3313
     3314int
     3315linux_smart_interface::sssraid_pd_add_list(int bus_no, smart_device_list & devlist)
     3316{
     3317  unsigned disk_num = 0;
     3318  struct cmd_pdlist_entry pdlist[CMD_PDS_MAX_NUM];
     3319  while (disk_num < CMD_PDS_MAX_NUM) {
     3320    struct cmd_show_pdlist list;
     3321    memset(&list, 0, sizeof(list));
     3322    if (sssraid_pdlist_cmd(bus_no, disk_num, &list, sizeof(struct cmd_show_pdlist), NULL) < 0)
     3323    {
     3324      return (-1);
     3325    }
     3326    if (list.num == 0)
     3327      break;
     3328    memcpy(&pdlist[disk_num], list.disks, list.num * sizeof(struct cmd_pdlist_entry));
     3329    disk_num += list.num;
     3330    if (list.num < CMD_PDLIST_ONCE_NUM)
     3331      break;
     3332  }
     3333
     3334  // adding all SCSI devices
     3335  for (unsigned i = 0; i < disk_num; i++) {
     3336    if(!(pdlist[i].interface == ADM_DEVICE_TYPE_SATA || pdlist[i].interface == ADM_DEVICE_TYPE_SAS
     3337        || pdlist[i].interface == ADM_DEVICE_TYPE_NVME))
     3338      continue; /* non disk device found */
     3339    char line[128];
     3340    snprintf(line, sizeof(line) - 1, "/dev/bsg/sssraid%d", bus_no);
     3341    smart_device * dev = new linux_sssraid_device(this, line, (unsigned int)pdlist[i].enc_id, (unsigned int)pdlist[i].slot_id);
     3342    devlist.push_back(dev);
     3343  }
     3344  return (0);
     3345}
     3346
    30773347// Return kernel release as integer ("2.6.31" -> 206031)
    30783348static unsigned get_kernel_release()
    30793349{
    … …  
    33313601    return new linux_megaraid_device(this, name, disknum);
    33323602  }
    33333603
     3604  // SSSRAID
     3605  unsigned eid = -1, sid = -1;
     3606  if (sscanf(type, "sssraid,%u,%u", &eid, &sid) == 2) {
     3607    return get_sat_device("sat,auto", new linux_sssraid_device(this, name, eid, sid));
     3608  }
     3609
    33343610  //aacraid?
    33353611  unsigned host, chan, device;
    33363612  if (sscanf(type, "aacraid,%u,%u,%u", &host, &chan, &device) == 3) {
    … …  
    33453621
    33463622std::string linux_smart_interface::get_valid_custom_dev_types_str()
    33473623{
    3348   return "marvell, areca,N/E, 3ware,N, hpt,L/M/N, megaraid,N, aacraid,H,L,ID"
     3624  return "marvell, areca,N/E, 3ware,N, hpt,L/M/N, megaraid,N, aacraid,H,L,ID, sssraid,E,S"
    33493625#ifdef HAVE_LINUX_CCISS_IOCTL_H
    33503626                                              ", cciss,N"
    33513627#endif

  • smartctl.8.in

     
    532532.Sp
    533533.\" %ENDIF OS Linux
    534534.\" %IF OS Linux Windows Cygwin
     535
     536.I sssraid,E,S
     537\- [Linux only] the device consists of one or more SCSI/SAS disks connected
     538to a SSSRAID controller.  The non-negative integer E (in the range of 0 to
     5398) denotes the enclosure and S (range 0 to 128) denotes the slot.
     540Use syntax such as:
     541.\" %ENDIF OS Linux
     542.\" %IF OS ALL
     543.br
     544Linux:
     545.\" %ENDIF OS ALL
     546.\" %IF OS Linux
     547.br
     548\fBsmartctl \-a \-d sssraid,0,1 /dev/bsg/sssraid0\fP
     549.br
     550It is possible to set RAID device name as /dev/bsg/sssraidN, where N is a SCSI bus
     551number.
     552.Sp
     553.\" %ENDIF OS Linux
     554
    535555.I aacraid,H,L,ID
    536556\- [Linux, Windows and Cygwin only] the device consists of one or more
    537557SCSI/SAS or SATA disks connected to an AacRaid controller.

  • sssraid.h

     
     1/*
     2 * sssraid.h
     3 *
     4 * Home page of code is: http://www.smartmontools.org
     5 *
     6 * Copyright (C) 2022 3SNIC Inc.
     7 *
     8 * SPDX-License-Identifier: GPL-2.0-or-later
     9 */
     10
     11#ifndef _SSSRAID_H_
     12#define _SSSRAID_H_
     13#include <stdint.h>
     14#define u8  uint8_t
     15#define u16 uint16_t
     16#define u32 uint32_t
     17#define u64 uint64_t
     18#define ADM_MAX_DATA_SIZE 0x1000U               // 4096
     19#define ADM_SCSI_CDB_MAX_LEN 32
     20#define ADM_SCSI_CDB_SENSE_MAX_LEN 96
     21#define ADM_SCSI_CDB_SENSE_LEN32 32
     22#define ADM_CMD_SHOW_PDLIST 0x502               // 1282
     23#define ADM_CMD_SCSI_PASSTHROUGH 0x51e  // 1310
     24#define BSG_APPEND_TIMEOUT_MS 600000
     25#define DEFAULT_CONMMAND_TIMEOUT_MS 180000
     26#define ADM_BSG_MSGCODE_SCSI_PTHRU  1
     27
     28#define ADM_RAID_SET 0xc0
     29#define ADM_RAID_WRITE 0xc1
     30#define ADM_RAID_READ 0xc2
     31#define ADM_RAID_PARAM_WRITE 0xc3
     32#define ADM_RAID_READ_FROM_CQE 0xc4
     33
     34// pdlist device type interface
     35enum adm_pdlist_intf {
     36    ADM_DEVICE_TYPE_SAS = 1,
     37    ADM_DEVICE_TYPE_EXP = 2,
     38    ADM_DEVICE_TYPE_SATA = 8,
     39    ADM_DEVICE_TYPE_PLANE = 9,
     40    ADM_DEVICE_TYPE_NVME = 10,
     41    ADM_DEVICE_TYPE_UNKNOW,
     42    ADM_DEVICE_TYPE_BUTT
     43};
     44
     45struct cmd_pdlist_idx {
     46    u16 start_idx;
     47    u16 count;
     48    u32 rsvd;
     49};
     50
     51struct cmd_pdlist_entry {
     52    u16 enc_id;
     53    u16 slot_id;
     54    u8 interface;
     55    u8 media_type;
     56    u8 logi_type;
     57    u8 logi_status;
     58        u32 reserve[26];
     59};
     60#define CMD_PDS_MAX_NUM 256U
     61#define CMD_PDLIST_ONCE_NUM ((ADM_MAX_DATA_SIZE - 64) / sizeof(struct cmd_pdlist_entry))
     62
     63struct cmd_show_pdlist {
     64    u16 num;
     65    u16 rsvd0;
     66    u32 rsvd1[15];
     67    struct cmd_pdlist_entry disks[CMD_PDLIST_ONCE_NUM];
     68};
     69
     70struct multi_disk_location {
     71    u16 enc_id;
     72    u16 slot_id;
     73    u16 did;
     74    u8 flag;
     75    u8 rsvd;
     76};
     77
     78struct cmd_scsi_passthrough {
     79    struct multi_disk_location loc;
     80    u8 lun;
     81    u8 cdb_len;
     82    u8 sense_buffer_len;
     83    u8 rsvd0;
     84    u8 cdb[32];
     85    u32 rsvd1;
     86    u8 *sense_buffer;
     87};
     88
     89struct sssraid_passthru_common_cmd {
     90        u8      opcode;
     91        u8      flags;
     92        u16     rsvd0;
     93        u32     nsid;
     94        union {
     95                struct {
     96                        u16 subopcode;
     97                        u16 rsvd1;
     98                } info_0;
     99                u32 cdw2;
     100        };
     101        union {
     102                struct {
     103                        u16 data_len;
     104                        u16 param_len;
     105                } info_1;
     106                u32 cdw3;
     107        };
     108        u64 metadata;
     109
     110        u64 addr;
     111    u32 metadata_len;
     112    u32 data_len;
     113
     114        u32 cdw10;
     115        u32 cdw11;
     116        u32 cdw12;
     117        u32 cdw13;
     118        u32 cdw14;
     119        u32 cdw15;
     120        u32 timeout_ms;
     121        u32 result0;
     122        u32 result1;
     123};
     124
     125struct sssraid_ioq_passthru_cmd {
     126        u8  opcode;
     127        u8  flags;
     128        u16 rsvd0;
     129        u32 nsid;
     130        union {
     131                struct {
     132                        u16 res_sense_len;
     133                        u8  cdb_len;
     134                        u8  rsvd0;
     135                } info_0;
     136                u32 cdw2;
     137        };
     138        union {
     139                struct {
     140                        u16 subopcode;
     141                        u16 rsvd1;
     142                } info_1;
     143                u32 cdw3;
     144        };
     145        union {
     146                struct {
     147                        u16 rsvd;
     148                        u16 param_len;
     149                } info_2;
     150                u32 cdw4;
     151        };
     152        u32 cdw5;
     153        u64 addr;
     154        u64 prp2;
     155        union {
     156                struct {
     157                        u16 eid;
     158                        u16 sid;
     159                } info_3;
     160                u32 cdw10;
     161        };
     162        union {
     163                struct {
     164                        u16 did;
     165                        u8  did_flag;
     166                        u8  rsvd2;
     167                } info_4;
     168                u32 cdw11;
     169        };
     170        u32 cdw12;
     171        u32 cdw13;
     172        u32 cdw14;
     173        u32 data_len;
     174        u32 cdw16;
     175        u32 cdw17;
     176        u32 cdw18;
     177        u32 cdw19;
     178        u32 cdw20;
     179        u32 cdw21;
     180        u32 cdw22;
     181        u32 cdw23;
     182        u64 sense_addr;
     183        u32 cdw26[4];
     184        u32 timeout_ms;
     185        u32 result0;
     186        u32 result1;
     187};
     188
     189struct bsg_ioctl_cmd {
     190    u32 msgcode;
     191    u32 control;
     192    union {
     193        struct sssraid_passthru_common_cmd ioctl_r64;
     194        struct sssraid_ioq_passthru_cmd ioctl_pthru;
     195    };
     196};
     197
     198#endif // _SSSRAID_H
     199 No newline at end of file