Add '-d megaraid' support on the FreeBSD (#734)

git-svn-id: http://svn.code.sf.net/p/smartmontools/code/trunk@5247 4ea69e1a-61f1-4043-bf83-b5c94c648137
pull/120/head
samm-git 10 months ago
parent 3d8aea7674
commit adb5d26ef6
  1. 6
      smartmontools/ChangeLog
  2. 2
      smartmontools/NEWS
  3. 378
      smartmontools/os_freebsd.cpp
  4. 160
      smartmontools/os_freebsd.h
  5. 24
      smartmontools/smartctl.8.in
  6. 25
      smartmontools/smartd.conf.5.in

@ -1,5 +1,11 @@
$Id$
2021-11-22 Alex Samorukov <samm@os2.kiev.ua>
os_freebsd.cpp: initial support of the direct MegaRaid access using
'-d megaraid' option. Code is initially based on Linux version but adopted to
be compatible with FreeBSD IOCTL-s.
2021-11-13 Christian Franke <franke@computer.org>
smartctl.8.in, smartd.8.in: Remove EXPERIMENTAL notes for features

@ -39,6 +39,8 @@ Summary: smartmontools release 7.3
- OpenBSD: Fixed too short command timeouts.
- OpenBSD: Fixed device name used for autodetection.
- OpenBSD: Fixed SAT autodetection of sd* devices.
- FreeBSD: Added direct access ('-d megaraid,N') and scanning for LSI RAID on
'mfi' and 'mrsas' controllers.
- Windows: Disabled '-d aacraid' support due to unresolved bugs.
Added '-d accraid,...,force' flag to try anyway.

@ -26,6 +26,7 @@
#endif
#include <sys/stat.h>
#include <unistd.h>
#include <sys/uio.h>
#include <glob.h>
#include <stddef.h>
#include <paths.h>
@ -199,6 +200,9 @@ static const char smartctl_examples[] =
" smartctl -a --device=areca,3/1 /dev/arcmsr0\n"
" (Prints all SMART information for 3rd disk in the 1st enclosure \n"
" on first ARECA RAID controller)\n"
" smartctl -a --device=megaraid,3 /dev/mrsas0\n"
" (Prints all SMART information for 3rd disk\n"
" on first LSI RAID controller)\n"
;
@ -761,6 +765,239 @@ bool freebsd_escalade_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_ou
return true;
}
/////////////////////////////////////////////////////////////////////////////
/// LSI MegaRAID support
class freebsd_megaraid_device
: public /* implements */ scsi_device,
public /* extends */ freebsd_smart_device
{
public:
freebsd_megaraid_device(smart_interface *intf, const char *name,
unsigned int tgt);
virtual ~freebsd_megaraid_device();
virtual smart_device * autodetect_open();
virtual bool open();
virtual bool close();
virtual bool scsi_pass_through(scsi_cmnd_io *iop);
private:
unsigned int m_disknum;
unsigned int m_hba;
int m_fd;
bool (freebsd_megaraid_device::*pt_cmd)(int cdblen, void *cdb, int dataLen, void *data,
int senseLen, void *sense, int report, int direction, int timeout);
bool megasas_cmd(int cdbLen, void *cdb, int dataLen, void *data,
int senseLen, void *sense, int report, int direction, int timeout);
};
freebsd_megaraid_device::freebsd_megaraid_device(smart_interface *intf,
const char *dev_name, unsigned int tgt)
: smart_device(intf, dev_name, "megaraid", "megaraid"),
freebsd_smart_device(),
m_disknum(tgt), m_hba(0),
m_fd(-1), pt_cmd(0)
{
set_info().info_name = strprintf("%s [megaraid_disk_%02d]", dev_name, m_disknum);
set_info().dev_type = strprintf("megaraid,%d", tgt);
}
freebsd_megaraid_device::~freebsd_megaraid_device()
{
if (m_fd >= 0)
::close(m_fd);
}
smart_device * freebsd_megaraid_device::autodetect_open()
{
int report = scsi_debugmode;
// Open device
if (!open())
return this;
// The code below is based on smartd.cpp:SCSIFilterKnown()
if (strcmp(get_req_type(), "megaraid"))
return this;
// Get INQUIRY
unsigned char req_buff[64] = {0, };
int req_len = 36;
if (scsiStdInquiry(this, req_buff, req_len)) {
close();
set_err(EIO, "INQUIRY failed");
return this;
}
int avail_len = req_buff[4] + 5;
int len = (avail_len < req_len ? avail_len : req_len);
if (len < 36)
return this;
if (report)
pout("Got MegaRAID inquiry.. %s\n", req_buff+8);
// Use INQUIRY to detect type
{
// SAT?
ata_device * newdev = smi()->autodetect_sat_device(this, req_buff, len);
if (newdev) // NOTE: 'this' is now owned by '*newdev'
return newdev;
}
// Nothing special found
return this;
}
bool freebsd_megaraid_device::open()
{
/* Open Device IOCTL node */
if ((m_fd = ::open(get_dev_name(), O_RDWR)) >= 0) {
pt_cmd = &freebsd_megaraid_device::megasas_cmd;
}
else {
int err = errno;
freebsd_smart_device::close();
return set_err(err, "cannot open %s",get_dev_name());
}
set_fd(m_fd);
return true;
}
bool freebsd_megaraid_device::close()
{
if (m_fd >= 0)
::close(m_fd);
m_fd = -1; m_hba = 0; pt_cmd = 0;
set_fd(m_fd);
return true;
}
bool freebsd_megaraid_device::scsi_pass_through(scsi_cmnd_io *iop)
{
int report = scsi_debugmode;
if (report > 0) {
int k, j;
const unsigned char * ucp = iop->cmnd;
const char * np;
char buff[256];
const int sz = (int)sizeof(buff);
np = scsi_get_opcode_name(ucp[0]);
j = snprintf(buff, sz, " [%s: ", np ? np : "<unknown opcode>");
for (k = 0; k < (int)iop->cmnd_len; ++k)
j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "%02x ", ucp[k]);
if ((report > 1) &&
(DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
int trunc = (iop->dxfer_len > 256) ? 1 : 0;
snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n Outgoing "
"data, len=%d%s:\n", (int)iop->dxfer_len,
(trunc ? " [only first 256 bytes shown]" : ""));
dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len) , 1);
}
else
snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n");
pout("%s", buff);
}
// Controller rejects Test Unit Ready
if (iop->cmnd[0] == 0x00)
return true;
if (iop->cmnd[0] == SAT_ATA_PASSTHROUGH_12 || iop->cmnd[0] == SAT_ATA_PASSTHROUGH_16) {
// Controller does not return ATA output registers in SAT sense data
if (iop->cmnd[2] & (1 << 5)) // chk_cond
return set_err(ENOSYS, "ATA return descriptor not supported by controller firmware");
}
// SMART WRITE LOG SECTOR causing media errors
if ((iop->cmnd[0] == SAT_ATA_PASSTHROUGH_16 // SAT16 WRITE LOG
&& iop->cmnd[14] == ATA_SMART_CMD && iop->cmnd[3]==0 && iop->cmnd[4] == ATA_SMART_WRITE_LOG_SECTOR) ||
(iop->cmnd[0] == SAT_ATA_PASSTHROUGH_12 // SAT12 WRITE LOG
&& iop->cmnd[9] == ATA_SMART_CMD && iop->cmnd[3] == ATA_SMART_WRITE_LOG_SECTOR))
{
if(!failuretest_permissive)
return set_err(ENOSYS, "SMART WRITE LOG SECTOR may cause problems, try with -T permissive to force");
}
if (pt_cmd == NULL)
return false;
return (this->*pt_cmd)(iop->cmnd_len, iop->cmnd,
iop->dxfer_len, iop->dxferp,
iop->max_sense_len, iop->sensep, report, iop->dxfer_dir, iop->timeout);
}
bool freebsd_megaraid_device::megasas_cmd(int cdbLen, void *cdb,
int dataLen, void *data,
int senseLen, void * sense, int /*report*/, int dxfer_dir, int timeout)
{
struct mfi_pass_frame * pthru;
struct mfi_ioc_packet uio;
pthru = (struct mfi_pass_frame *)&uio.mfi_frame.raw;
memset(&uio, 0, sizeof(uio));
pthru->header.cmd = MFI_CMD_PD_SCSI_IO;
pthru->header.cmd_status = 0;
pthru->header.scsi_status = 0x0;
pthru->header.target_id = m_disknum;
pthru->header.lun_id = 0; // FIXME, should be bus number?
pthru->header.sense_len = senseLen;
pthru->sense_addr_lo = (uintptr_t)sense ;
pthru->sense_addr_hi = (uintptr_t)((uint64_t)sense >> 32);
pthru->header.cdb_len = cdbLen;
pthru->header.timeout = timeout;
switch (dxfer_dir) {
case DXFER_FROM_DEVICE:
pthru->header.flags = MFI_FRAME_DIR_READ;
break;
case DXFER_TO_DEVICE:
pthru->header.flags = MFI_FRAME_DIR_WRITE;
break;
case DXFER_NONE:
pthru->header.flags = MFI_FRAME_DIR_NONE;
break;
}
if (dataLen > 0) {
uio.mfi_sge_count = 1;
uio.mfi_sgl_off = offsetof(struct mfi_pass_frame,sgl);
uio.mfi_sgl[0].iov_base = data;
uio.mfi_sgl[0].iov_len = dataLen;
pthru->header.sg_count = 1;
pthru->header.data_len = dataLen;
// tested on amd64 kernel in native and 32bit mode
pthru->sgl.sg64[0].addr = (intptr_t)data;
pthru->sgl.sg64[0].len = (uint32_t)dataLen;
}
memcpy(pthru->cdb, cdb, cdbLen);
uio.mfi_adapter_no = m_hba;
uio.mfi_sense_len = senseLen;
uio.mfi_sense_off = offsetof(struct mfi_pass_frame, sense_addr_lo);
errno = 0;
int rc = ioctl(m_fd, MFI_CMD, &uio);
if (pthru->header.cmd_status || rc != 0) {
if (pthru->header.cmd_status == 12) {
return set_err(EIO, "megasas_cmd: Device %d does not exist\n", m_disknum);
}
return set_err((errno ? errno : EIO), "megasas_cmd result: %d.%d = %d/%d",
m_hba, m_disknum, errno,
pthru->header.cmd_status);
}
return true;
}
/////////////////////////////////////////////////////////////////////////////
/// Implement Highpoint RAID support with old functions
@ -1399,6 +1636,15 @@ smart_device * freebsd_scsi_device::autodetect_open()
return this;
}
// DELL?
if (!memcmp(req_buff + 8, "DELL PERC", 12) || !memcmp(req_buff + 8, "MegaRAID", 8)
|| !memcmp(req_buff + 16, "PERC H", 6) || !memcmp(req_buff + 8, "LSI\0",4)
) {
close();
set_err(EINVAL, "DELL or MegaRaid controller, use '-d megaraid,N'");
return this;
}
// SAT or USB, skip MFI controllers because of bugs
{
smart_device * newdev = smi()->autodetect_sat_device(this, req_buff, len);
@ -1451,6 +1697,10 @@ protected:
virtual std::string get_valid_custom_dev_types_str() override;
private:
bool get_nvme_devlist(smart_device_list & devlist, const char * type);
bool get_dev_megaraid(smart_device_list & devlist);
int megaraid_pd_add_list(const char * devname, smart_device_list & devlist);
int megaraid_dcmd_cmd(const char * devname, uint32_t opcode, void *buf,
size_t bufsize, uint8_t *mbox, size_t mboxlen, uint8_t *statusp);
};
@ -1773,6 +2023,9 @@ bool freebsd_smart_interface::scan_smart_devices(smart_device_list & devlist,
}
}
// add devices from LSI MegaRaid controllers
get_dev_megaraid(devlist);
if (scan_nvme)
get_nvme_devlist(devlist, type);
return true;
@ -1798,6 +2051,114 @@ bool freebsd_smart_interface::get_nvme_devlist(smart_device_list & devlist,
return true;
}
// getting devices from LSI SAS MegaRaid, if available
bool freebsd_smart_interface::get_dev_megaraid(smart_device_list & devlist)
{
/* Scanning of disks on MegaRaid device */
char ctrlpath[64];
// trying to add devices on first 32 buses, same as StorCLI does
for(unsigned i = 0; i <=32; i++) {
sprintf(ctrlpath, "%s%d", MFI_CTRLR_PREFIX, i);
megaraid_pd_add_list(ctrlpath, devlist);
sprintf(ctrlpath, "%s%d", MRSAS_CTRLR_PREFIX, i);
megaraid_pd_add_list(ctrlpath, devlist);
}
return true;
}
int
freebsd_smart_interface::megaraid_dcmd_cmd(const char * devname, uint32_t opcode, void *buf,
size_t bufsize, uint8_t *mbox, size_t mboxlen, uint8_t *statusp)
{
struct mfi_ioc_packet ioc;
struct mfi_dcmd_frame * dcmd;
if ((mbox != NULL && (mboxlen == 0 || mboxlen > MFI_MBOX_SIZE)) ||
(mbox == NULL && mboxlen != 0))
{
errno = EINVAL;
return (-1);
}
memset(&ioc, 0, sizeof(ioc));
dcmd = (struct mfi_dcmd_frame *)&ioc.mfi_frame.raw;
if (mbox)
memcpy(dcmd->mbox, mbox, mboxlen);
dcmd->header.cmd = MFI_CMD_DCMD;
dcmd->header.data_len = bufsize;
dcmd->opcode = opcode;
if (bufsize > 0) {
ioc.mfi_sge_count = 1;
ioc.mfi_sgl_off = offsetof(struct mfi_dcmd_frame,sgl);
ioc.mfi_sgl[0].iov_base = buf;
ioc.mfi_sgl[0].iov_len = bufsize;
dcmd->header.sg_count = 1;
dcmd->header.data_len = bufsize;
// tested on amd64 kernel in native and 32bit mode
dcmd->sgl.sg64[0].addr = (intptr_t)buf;
dcmd->sgl.sg64[0].len = (uint32_t)bufsize;
}
int fd;
if ((fd = ::open(devname, O_RDWR)) < 0) {
return (errno);
}
// We are using MFI_CMD as it seems to be supported by all LSI BSD drivers
int r = ioctl(fd, MFI_CMD, &ioc);
::close(fd);
if (r < 0) {
return (r);
}
if (statusp != NULL)
*statusp = dcmd->header.cmd_status;
else if (dcmd->header.cmd_status != MFI_STAT_OK) {
fprintf(stderr, "command %x returned error status %x\n",
opcode, dcmd->header.cmd_status);
errno = EIO;
return (-1);
}
return (0);
}
int
freebsd_smart_interface::megaraid_pd_add_list(const char * devname, smart_device_list & devlist)
{
/*
* Keep fetching the list in a loop until we have a large enough
* buffer to hold the entire list.
*/
mfi_pd_list * list = 0;
for (unsigned list_size = 1024; ; ) {
list = reinterpret_cast<mfi_pd_list *>(realloc(list, list_size));
if (!list)
throw std::bad_alloc();
memset(list, 0, list_size);
if (megaraid_dcmd_cmd(devname, MFI_DCMD_PD_GET_LIST, list, list_size, NULL, 0,
NULL) < 0)
{
free(list);
return (-1);
}
if (list->size <= list_size)
break;
list_size = list->size;
}
// adding all SCSI devices
for (unsigned i = 0; i < list->count; i++) {
if(list->addr[i].scsi_dev_type)
continue; /* non disk device found */
smart_device * dev = new freebsd_megaraid_device(this, devname, list->addr[i].device_id);
devlist.push_back(dev);
}
free(list);
return (0);
}
#if (FREEBSDVER < 800000) // without this build fail on FreeBSD 8
static char done[USB_MAX_DEVICES];
@ -2032,8 +2393,15 @@ smart_device * freebsd_smart_interface::autodetect_smart_device(const char * nam
}
}
// device is LSI raid supported by mfi driver
if(!strncmp("/dev/mfid", test_name, strlen("/dev/mfid")))
set_err(EINVAL, "To monitor disks on LSI RAID load mfip.ko module and run 'smartctl -a /dev/passX' to show SMART information");
if(!strncmp("/dev/mfid", test_name, strlen("/dev/mfid"))) {
set_err(EINVAL, "To access disks on LSI RAID load mfip.ko and use /dev/passX or use -d 'megaraid,N' with /dev/mfiX devices");
return 0;
}
if(!strncmp(MFI_CTRLR_PREFIX, test_name, strlen(MFI_CTRLR_PREFIX)) || !strncmp(MRSAS_CTRLR_PREFIX, test_name, strlen(MRSAS_CTRLR_PREFIX))) {
set_err(EINVAL, "To access disks on %s use '-d megaraid,N' device type", test_name);
return 0;
}
// form /dev/nvme* or nvme*
if(!strncmp("/dev/nvme", test_name, strlen("/dev/nvme")))
@ -2140,12 +2508,16 @@ smart_device * freebsd_smart_interface::get_custom_smart_device(const char * nam
return new freebsd_areca_ata_device(this, name, disknum, encnum);
}
if (sscanf(type, "megaraid,%d", &disknum) == 1) {
return new freebsd_megaraid_device(this, name, disknum);
}
return 0;
}
std::string freebsd_smart_interface::get_valid_custom_dev_types_str()
{
return "3ware,N, hpt,L/M/N, cciss,N, areca,N/E"
return "3ware,N, hpt,L/M/N, cciss,N, areca,N/E, megaraid,N"
#if FREEBSDVER > 800100
", atacam"
#endif

@ -606,4 +606,164 @@ HPT_PASS_THROUGH_HEADER, *PHPT_PASS_THROUGH_HEADER;
#define __unused __attribute__ ((__unused__))
#endif
// MFI definition from the kernel sources, see sys/dev/mfi
#define MFI_STAT_OK 0x00
#define MFI_DCMD_PD_GET_LIST 0x02010000
#define MFI_CTRLR_PREFIX "/dev/mfi"
#define MRSAS_CTRLR_PREFIX "/dev/mrsas"
/*
* MFI Frame flags
*/
#define MFI_FRAME_POST_IN_REPLY_QUEUE 0x0000
#define MFI_FRAME_DONT_POST_IN_REPLY_QUEUE 0x0001
#define MFI_FRAME_SGL32 0x0000
#define MFI_FRAME_SGL64 0x0002
#define MFI_FRAME_SENSE32 0x0000
#define MFI_FRAME_SENSE64 0x0004
#define MFI_FRAME_DIR_NONE 0x0000
#define MFI_FRAME_DIR_WRITE 0x0008
#define MFI_FRAME_DIR_READ 0x0010
#define MFI_FRAME_DIR_BOTH 0x0018
#define MFI_FRAME_IEEE_SGL 0x0020
#define MFI_FRAME_FMT "\20" \
"\1NOPOST" \
"\2SGL64" \
"\3SENSE64" \
"\4WRITE" \
"\5READ" \
"\6IEEESGL"
/* MFI Commands */
typedef enum {
MFI_CMD_INIT = 0x00,
MFI_CMD_LD_READ,
MFI_CMD_LD_WRITE,
MFI_CMD_LD_SCSI_IO,
MFI_CMD_PD_SCSI_IO,
MFI_CMD_DCMD,
MFI_CMD_ABORT,
MFI_CMD_SMP,
MFI_CMD_STP
} mfi_cmd_t;
/* Scatter Gather elements */
struct mfi_sg32 {
uint32_t addr;
uint32_t len;
} __packed;
struct mfi_sg64 {
uint64_t addr;
uint32_t len;
} __packed;
struct mfi_sg_skinny {
uint64_t addr;
uint32_t len;
uint32_t flag;
} __packed;
union mfi_sgl {
struct mfi_sg32 sg32[1];
struct mfi_sg64 sg64[1];
struct mfi_sg_skinny sg_skinny[1];
} __packed;
/* Message frames. All messages have a common header */
struct mfi_frame_header {
uint8_t cmd;
uint8_t sense_len;
uint8_t cmd_status;
uint8_t scsi_status;
uint8_t target_id;
uint8_t lun_id;
uint8_t cdb_len;
uint8_t sg_count;
uint32_t context;
/*
* pad0 is MSI Specific. Not used by Driver. Zero the value before
* sending the command to f/w.
*/
uint32_t pad0;
uint16_t flags;
#define MFI_FRAME_DATAOUT 0x08
#define MFI_FRAME_DATAIN 0x10
uint16_t timeout;
uint32_t data_len;
} __packed;
#define MFI_PASS_FRAME_SIZE 48
struct mfi_pass_frame {
struct mfi_frame_header header;
uint32_t sense_addr_lo;
uint32_t sense_addr_hi;
uint8_t cdb[16];
union mfi_sgl sgl;
} __packed;
#define MFI_DCMD_FRAME_SIZE 40
#define MFI_MBOX_SIZE 12
struct mfi_dcmd_frame {
struct mfi_frame_header header;
uint32_t opcode;
uint8_t mbox[MFI_MBOX_SIZE];
union mfi_sgl sgl;
} __packed;
#define MAX_IOCTL_SGE 16
struct mfi_ioc_packet {
uint16_t mfi_adapter_no;
uint16_t mfi_pad1;
uint32_t mfi_sgl_off;
uint32_t mfi_sge_count;
uint32_t mfi_sense_off;
uint32_t mfi_sense_len;
union {
uint8_t raw[128];
struct mfi_frame_header hdr;
} mfi_frame;
struct iovec mfi_sgl[MAX_IOCTL_SGE];
} __packed;
#ifdef COMPAT_FREEBSD32
struct mfi_ioc_packet32 {
uint16_t mfi_adapter_no;
uint16_t mfi_pad1;
uint32_t mfi_sgl_off;
uint32_t mfi_sge_count;
uint32_t mfi_sense_off;
uint32_t mfi_sense_len;
union {
uint8_t raw[128];
struct mfi_frame_header hdr;
} mfi_frame;
struct iovec32 mfi_sgl[MAX_IOCTL_SGE];
} __packed;
#endif
struct mfi_pd_address {
uint16_t device_id;
uint16_t encl_device_id;
uint8_t encl_index;
uint8_t slot_number;
uint8_t scsi_dev_type; /* 0 = disk */
uint8_t connect_port_bitmap;
uint64_t sas_addr[2];
} __packed;
#define MAX_SYS_PDS 240
struct mfi_pd_list {
uint32_t size;
uint32_t count;
struct mfi_pd_address addr[MAX_SYS_PDS];
} __packed;
#define MFI_CMD _IOWR('M', 1, struct mfi_ioc_packet)
#endif /* OS_FREEBSD_H_ */

@ -482,16 +482,33 @@ this device type is for NVMe disks that are behind a Realtek USB to NVMe
bridge.
.Sp
.\" %ENDIF NOT OS Darwin
.\" %IF OS Linux
.\" %IF OS Linux FreeBSD
.I marvell
\- [Linux only] interact with SATA disks behind Marvell chip-set
controllers (using the Marvell rather than libata driver).
.Sp
.I megaraid,N
\- [Linux only] the device consists of one or more SCSI/SAS disks connected
\- [FreeBSD and Linux only] the device consists of one or more SCSI/SAS disks connected
to a MegaRAID controller. The non-negative integer N (in the range of 0 to
127 inclusive) denotes which disk on the controller is monitored.
127 inclusive) denotes which disk on the controller is monitored. This interface
will also work for Dell PERC controllers.
Use syntax such as:
.\" %ENDIF OS Linux FreeBSD
.\" %IF OS ALL
FreeBSD:
.\" %ENDIF OS ALL
.\" %IF OS FreeBSD
.br
\fBsmartctl \-a \-d megaraid,2 /dev/mfi0\fP
.br
\fBsmartctl \-a \-d megaraid,0 /dev/mrsas0\fP
.br
.Sp
.\" %ENDIF OS FreeBSD
.\" %IF OS ALL
Linux:
.\" %ENDIF OS ALL
.\" %IF OS Linux
.br
\fBsmartctl \-a \-d megaraid,2 /dev/sda\fP
.br
@ -499,7 +516,6 @@ Use syntax such as:
.br
\fBsmartctl \-a \-d megaraid,0 /dev/bus/0\fP
.br
This interface will also work for Dell PERC controllers.
It is possible to set RAID device name as /dev/bus/N, where N is a SCSI bus
number.
.Sp

@ -116,15 +116,27 @@ Section below!
# may become common with SATA disks in SAS and FC
# environments.
/dev/sda \-a \-d sat
.\" %IF OS Linux
.\" %IF OS FreeBSD Linux
#
# Three disks connected to a MegaRAID controller
# Disks connected to a MegaRAID controller
# Start short self\-tests daily between 1\-2, 2\-3, and
# 3\-4 am.
.\" %ENDIF OS FreeBSD Linux
.\" %IF OS Linux
# Linux:
/dev/sda \-d megaraid,0 \-a \-s S/../.././01
/dev/sda \-d megaraid,1 \-a \-s S/../.././02
/dev/sda \-d megaraid,2 \-a \-s S/../.././03
/dev/bus/0 \-d megaraid,2 \-a \-s S/../.././03
.\" %ENDIF OS Linux
.\" %IF OS FreeBSD
# FreeBSD:
/dev/mfi0 \-d megaraid,0 \-a \-s S/../.././01
/dev/mfi0 \-d megaraid,1 \-a \-s S/../.././02
/dev/mfi0 \-d megaraid,2 \-a \-s S/../.././03
/dev/mrsas0 \-d megaraid,2 \-a \-s S/../.././03
.\" %ENDIF OS FreeBSD
.\" %IF OS Linux
#
# Three disks connected to an AacRaid controller
# Start short self\-tests daily between 1\-2, 2\-3, and
@ -468,18 +480,19 @@ bridge.
\- [Linux only] interact with SATA disks behind Marvell chip-set
controllers (using the Marvell rather than libata driver).
.Sp
.\" %ENDIF OS FreeBSD Linux
.\" %IF OS FreeBSD Linux
.I megaraid,N
\- [Linux only] the device consists of one or more SCSI/SAS disks connected
\- [Linux and FreeBSD only] the device consists of one or more SCSI/SAS disks connected
to a MegaRAID controller. The non-negative integer N (in the range of 0 to
127 inclusive) denotes which disk on the controller is monitored.
This interface will also work for Dell PERC controllers.
In log files and email messages this disk will be identified as
megaraid_disk_XXX with XXX in the range from 000 to 127 inclusive.
It is possible to set RAID device name as /dev/bus/N, where N is a SCSI bus
number.
Please see the \fBsmartctl\fP(8) man page for further details.
.Sp
.\" %ENDIF OS Linux
.\" %ENDIF OS FreeBSD Linux
.\" %IF OS Linux Windows Cygwin
.I aacraid,H,L,ID
\- [Linux, Windows and Cygwin only] the device consists of one or more

Loading…
Cancel
Save