root/trunk/smartmontools/os_linux.cpp @ 2948

Revision 2948, 100.7 KB (checked in by samm2, 5 years ago)

Linux: Fixed IDE drives support on megaraid device (see ticket #15)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
Line 
1/*
2 *  os_linux.cpp
3 *
4 * Home page of code is: http://smartmontools.sourceforge.net
5 *
6 * Copyright (C) 2003-8 Bruce Allen <smartmontools-support@lists.sourceforge.net>
7 * Copyright (C) 2003-8 Doug Gilbert <dougg@torque.net>
8 * Copyright (C) 2008   Hank Wu <hank@areca.com.tw>
9 * Copyright (C) 2008   Oliver Bock <brevilo@users.sourceforge.net>
10 * Copyright (C) 2008-9 Christian Franke <smartmontools-support@lists.sourceforge.net>
11 * Copyright (C) 2008   Jordan Hargrave <jordan_hargrave@dell.com>
12 *
13 *  Parts of this file are derived from code that was
14 *
15 *  Written By: Adam Radford <linux@3ware.com>
16 *  Modifications By: Joel Jacobson <linux@3ware.com>
17 *                   Arnaldo Carvalho de Melo <acme@conectiva.com.br>
18 *                    Brad Strand <linux@3ware.com>
19 *
20 *  Copyright (C) 1999-2003 3ware Inc.
21 *
22 *  Kernel compatablity By:     Andre Hedrick <andre@suse.com>
23 *  Non-Copyright (C) 2000      Andre Hedrick <andre@suse.com>
24 *
25 * Other ars of this file are derived from code that was
26 *
27 * Copyright (C) 1999-2000 Michael Cornwell <cornwell@acm.org>
28 * Copyright (C) 2000 Andre Hedrick <andre@linux-ide.org>
29 *
30 * This program is free software; you can redistribute it and/or modify
31 * it under the terms of the GNU General Public License as published by
32 * the Free Software Foundation; either version 2, or (at your option)
33 * any later version.
34 *
35 * You should have received a copy of the GNU General Public License
36 * (for example COPYING); If not, see <http://www.gnu.org/licenses/>.
37 *
38 * This code was originally developed as a Senior Thesis by Michael Cornwell
39 * at the Concurrent Systems Laboratory (now part of the Storage Systems
40 * Research Center), Jack Baskin School of Engineering, University of
41 * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
42 *
43 */
44
45// This file contains the linux-specific IOCTL parts of
46// smartmontools. It includes one interface routine for ATA devices,
47// one for SCSI devices, and one for ATA devices behind escalade
48// controllers.
49
50#include "config.h"
51
52#include <errno.h>
53#include <fcntl.h>
54#include <glob.h>
55
56#include <scsi/scsi.h>
57#include <scsi/scsi_ioctl.h>
58#include <scsi/sg.h>
59#include <stdlib.h>
60#include <string.h>
61#include <sys/ioctl.h>
62#include <sys/stat.h>
63#include <sys/file.h>
64#include <unistd.h>
65#include <sys/uio.h>
66#include <sys/types.h>
67#ifndef makedev // old versions of types.h do not include sysmacros.h
68#include <sys/sysmacros.h>
69#endif
70#ifdef WITH_SELINUX
71#include <selinux/selinux.h>
72#endif
73
74#include "int64.h"
75#include "atacmds.h"
76#include "extern.h"
77#include "os_linux.h"
78#include "scsicmds.h"
79#include "utility.h"
80#include "extern.h"
81#include "cciss.h"
82#include "megaraid.h"
83
84#include "dev_interface.h"
85#include "dev_ata_cmd_set.h"
86
87#ifndef ENOTSUP
88#define ENOTSUP ENOSYS
89#endif
90
91#define ARGUSED(x) ((void)(x))
92
93const char *os_XXXX_c_cvsid="$Id$" \
94ATACMDS_H_CVSID CONFIG_H_CVSID INT64_H_CVSID OS_LINUX_H_CVSID SCSICMDS_H_CVSID UTILITY_H_CVSID;
95
96/* for passing global control variables */
97// (con->reportscsiioctl only)
98extern smartmonctrl *con;
99
100
101namespace os_linux { // No need to publish anything, name provided for Doxygen
102
103/////////////////////////////////////////////////////////////////////////////
104/// Shared open/close routines
105
106class linux_smart_device
107: virtual public /*implements*/ smart_device
108{
109public:
110  explicit linux_smart_device(int flags, int retry_flags = -1)
111    : smart_device(never_called),
112      m_fd(-1),
113      m_flags(flags), m_retry_flags(retry_flags)
114      { }
115
116  virtual ~linux_smart_device() throw();
117
118  virtual bool is_open() const;
119
120  virtual bool open();
121
122  virtual bool close();
123
124protected:
125  /// Return filedesc for derived classes.
126  int get_fd() const
127    { return m_fd; }
128
129private:
130  int m_fd; ///< filedesc, -1 if not open.
131  int m_flags; ///< Flags for ::open()
132  int m_retry_flags; ///< Flags to retry ::open(), -1 if no retry
133};
134
135
136linux_smart_device::~linux_smart_device() throw()
137{
138  if (m_fd >= 0)
139    ::close(m_fd);
140}
141
142bool linux_smart_device::is_open() const
143{
144  return (m_fd >= 0);
145}
146
147bool linux_smart_device::open()
148{
149  m_fd = ::open(get_dev_name(), m_flags);
150
151  if (m_fd < 0 && errno == EROFS && m_retry_flags != -1)
152    // Retry
153    m_fd = ::open(get_dev_name(), m_retry_flags);
154
155  if (m_fd < 0) {
156    if (errno == EBUSY && (m_flags & O_EXCL))
157      // device is locked
158      return set_err(EBUSY,
159        "The requested controller is used exclusively by another process!\n"
160        "(e.g. smartctl or smartd)\n"
161        "Please quit the impeding process or try again later...");
162    return set_err((errno==ENOENT || errno==ENOTDIR) ? ENODEV : errno);
163  }
164
165  if (m_fd >= 0) {
166    // sets FD_CLOEXEC on the opened device file descriptor.  The
167    // descriptor is otherwise leaked to other applications (mail
168    // sender) which may be considered a security risk and may result
169    // in AVC messages on SELinux-enabled systems.
170    if (-1 == fcntl(m_fd, F_SETFD, FD_CLOEXEC))
171      // TODO: Provide an error printing routine in class smart_interface
172      pout("fcntl(set  FD_CLOEXEC) failed, errno=%d [%s]\n", errno, strerror(errno));
173  }
174
175  return true;
176}
177
178// equivalent to close(file descriptor)
179bool linux_smart_device::close()
180{
181  int fd = m_fd; m_fd = -1;
182  if (::close(fd) < 0)
183    return set_err(errno);
184  return true;
185}
186
187// examples for smartctl
188static const char  smartctl_examples[] =
189                  "=================================================== SMARTCTL EXAMPLES =====\n\n"
190                  "  smartctl --all /dev/hda                    (Prints all SMART information)\n\n"
191                  "  smartctl --smart=on --offlineauto=on --saveauto=on /dev/hda\n"
192                  "                                              (Enables SMART on first disk)\n\n"
193                  "  smartctl --test=long /dev/hda          (Executes extended disk self-test)\n\n"
194                  "  smartctl --attributes --log=selftest --quietmode=errorsonly /dev/hda\n"
195                  "                                      (Prints Self-Test & Attribute errors)\n"
196                  "  smartctl --all --device=3ware,2 /dev/sda\n"
197                  "  smartctl --all --device=3ware,2 /dev/twe0\n"
198                  "  smartctl --all --device=3ware,2 /dev/twa0\n"
199                  "          (Prints all SMART info for 3rd ATA disk on 3ware RAID controller)\n"
200                  "  smartctl --all --device=hpt,1/1/3 /dev/sda\n"
201                  "          (Prints all SMART info for the SATA disk attached to the 3rd PMPort\n"
202                  "           of the 1st channel on the 1st HighPoint RAID controller)\n"
203                  "  smartctl --all --device=areca,3 /dev/sg2\n"
204                  "          (Prints all SMART info for 3rd ATA disk on Areca RAID controller)\n"
205  ;
206
207
208/////////////////////////////////////////////////////////////////////////////
209/// Linux ATA support
210
211class linux_ata_device
212: public /*implements*/ ata_device_with_command_set,
213  public /*extends*/ linux_smart_device
214{
215public:
216  linux_ata_device(smart_interface * intf, const char * dev_name, const char * req_type);
217
218protected:
219  virtual int ata_command_interface(smart_command_set command, int select, char * data);
220};
221
222linux_ata_device::linux_ata_device(smart_interface * intf, const char * dev_name, const char * req_type)
223: smart_device(intf, dev_name, "ata", req_type),
224  linux_smart_device(O_RDONLY | O_NONBLOCK)
225{
226}
227
228// PURPOSE
229//   This is an interface routine meant to isolate the OS dependent
230//   parts of the code, and to provide a debugging interface.  Each
231//   different port and OS needs to provide it's own interface.  This
232//   is the linux one.
233// DETAILED DESCRIPTION OF ARGUMENTS
234//   device: is the file descriptor provided by open()
235//   command: defines the different operations.
236//   select: additional input data if needed (which log, which type of
237//           self-test).
238//   data:   location to write output data, if needed (512 bytes).
239//   Note: not all commands use all arguments.
240// RETURN VALUES
241//  -1 if the command failed
242//   0 if the command succeeded,
243//   STATUS_CHECK routine:
244//  -1 if the command failed
245//   0 if the command succeeded and disk SMART status is "OK"
246//   1 if the command succeeded and disk SMART status is "FAILING"
247
248
249#define BUFFER_LENGTH (4+512)
250
251int linux_ata_device::ata_command_interface(smart_command_set command, int select, char * data)
252{
253  unsigned char buff[BUFFER_LENGTH];
254  // positive: bytes to write to caller.  negative: bytes to READ from
255  // caller. zero: non-data command
256  int copydata=0;
257
258  const int HDIO_DRIVE_CMD_OFFSET = 4;
259
260  // See struct hd_drive_cmd_hdr in hdreg.h.  Before calling ioctl()
261  // buff[0]: ATA COMMAND CODE REGISTER
262  // buff[1]: ATA SECTOR NUMBER REGISTER == LBA LOW REGISTER
263  // buff[2]: ATA FEATURES REGISTER
264  // buff[3]: ATA SECTOR COUNT REGISTER
265
266  // Note that on return:
267  // buff[2] contains the ATA SECTOR COUNT REGISTER
268
269  // clear out buff.  Large enough for HDIO_DRIVE_CMD (4+512 bytes)
270  memset(buff, 0, BUFFER_LENGTH);
271
272  buff[0]=ATA_SMART_CMD;
273  switch (command){
274  case CHECK_POWER_MODE:
275    buff[0]=ATA_CHECK_POWER_MODE;
276    copydata=1;
277    break;
278  case READ_VALUES:
279    buff[2]=ATA_SMART_READ_VALUES;
280    buff[3]=1;
281    copydata=512;
282    break;
283  case READ_THRESHOLDS:
284    buff[2]=ATA_SMART_READ_THRESHOLDS;
285    buff[1]=buff[3]=1;
286    copydata=512;
287    break;
288  case READ_LOG:
289    buff[2]=ATA_SMART_READ_LOG_SECTOR;
290    buff[1]=select;
291    buff[3]=1;
292    copydata=512;
293    break;
294  case WRITE_LOG:
295    break;
296  case IDENTIFY:
297    buff[0]=ATA_IDENTIFY_DEVICE;
298    buff[3]=1;
299    copydata=512;
300    break;
301  case PIDENTIFY:
302    buff[0]=ATA_IDENTIFY_PACKET_DEVICE;
303    buff[3]=1;
304    copydata=512;
305    break;
306  case ENABLE:
307    buff[2]=ATA_SMART_ENABLE;
308    buff[1]=1;
309    break;
310  case DISABLE:
311    buff[2]=ATA_SMART_DISABLE;
312    buff[1]=1;
313    break;
314  case STATUS:
315    // this command only says if SMART is working.  It could be
316    // replaced with STATUS_CHECK below.
317    buff[2]=ATA_SMART_STATUS;
318    break;
319  case AUTO_OFFLINE:
320    // NOTE: According to ATAPI 4 and UP, this command is obsolete
321    // select == 241 for enable but no data transfer.  Use TASK ioctl.
322    buff[1]=ATA_SMART_AUTO_OFFLINE;
323    buff[2]=select;
324    break;
325  case AUTOSAVE:
326    // select == 248 for enable but no data transfer.  Use TASK ioctl.
327    buff[1]=ATA_SMART_AUTOSAVE;
328    buff[2]=select;
329    break;
330  case IMMEDIATE_OFFLINE:
331    buff[2]=ATA_SMART_IMMEDIATE_OFFLINE;
332    buff[1]=select;
333    break;
334  case STATUS_CHECK:
335    // This command uses HDIO_DRIVE_TASK and has different syntax than
336    // the other commands.
337    buff[1]=ATA_SMART_STATUS;
338    break;
339  default:
340    pout("Unrecognized command %d in linux_ata_command_interface()\n"
341         "Please contact " PACKAGE_BUGREPORT "\n", command);
342    errno=ENOSYS;
343    return -1;
344  }
345
346  // This command uses the HDIO_DRIVE_TASKFILE ioctl(). This is the
347  // only ioctl() that can be used to WRITE data to the disk.
348  if (command==WRITE_LOG) {
349    unsigned char task[sizeof(ide_task_request_t)+512];
350    ide_task_request_t *reqtask=(ide_task_request_t *) task;
351    task_struct_t      *taskfile=(task_struct_t *) reqtask->io_ports;
352    int retval;
353
354    memset(task,      0, sizeof(task));
355
356    taskfile->data           = 0;
357    taskfile->feature        = ATA_SMART_WRITE_LOG_SECTOR;
358    taskfile->sector_count   = 1;
359    taskfile->sector_number  = select;
360    taskfile->low_cylinder   = 0x4f;
361    taskfile->high_cylinder  = 0xc2;
362    taskfile->device_head    = 0;
363    taskfile->command        = ATA_SMART_CMD;
364
365    reqtask->data_phase      = TASKFILE_OUT;
366    reqtask->req_cmd         = IDE_DRIVE_TASK_OUT;
367    reqtask->out_size        = 512;
368    reqtask->in_size         = 0;
369
370    // copy user data into the task request structure
371    memcpy(task+sizeof(ide_task_request_t), data, 512);
372
373    if ((retval=ioctl(get_fd(), HDIO_DRIVE_TASKFILE, task))) {
374      if (retval==-EINVAL)
375        pout("Kernel lacks HDIO_DRIVE_TASKFILE support; compile kernel with CONFIG_IDE_TASKFILE_IO set\n");
376      return -1;
377    }
378    return 0;
379  }
380
381  // There are two different types of ioctls().  The HDIO_DRIVE_TASK
382  // one is this:
383  if (command==STATUS_CHECK || command==AUTOSAVE || command==AUTO_OFFLINE){
384    int retval;
385
386    // NOT DOCUMENTED in /usr/src/linux/include/linux/hdreg.h. You
387    // have to read the IDE driver source code.  Sigh.
388    // buff[0]: ATA COMMAND CODE REGISTER
389    // buff[1]: ATA FEATURES REGISTER
390    // buff[2]: ATA SECTOR_COUNT
391    // buff[3]: ATA SECTOR NUMBER
392    // buff[4]: ATA CYL LO REGISTER
393    // buff[5]: ATA CYL HI REGISTER
394    // buff[6]: ATA DEVICE HEAD
395
396    unsigned const char normal_lo=0x4f, normal_hi=0xc2;
397    unsigned const char failed_lo=0xf4, failed_hi=0x2c;
398    buff[4]=normal_lo;
399    buff[5]=normal_hi;
400
401    if ((retval=ioctl(get_fd(), HDIO_DRIVE_TASK, buff))) {
402      if (retval==-EINVAL) {
403        pout("Error SMART Status command via HDIO_DRIVE_TASK failed");
404        pout("Rebuild older linux 2.2 kernels with HDIO_DRIVE_TASK support added\n");
405      }
406      else
407        syserror("Error SMART Status command failed");
408      return -1;
409    }
410
411    // Cyl low and Cyl high unchanged means "Good SMART status"
412    if (buff[4]==normal_lo && buff[5]==normal_hi)
413      return 0;
414
415    // These values mean "Bad SMART status"
416    if (buff[4]==failed_lo && buff[5]==failed_hi)
417      return 1;
418
419    // We haven't gotten output that makes sense; print out some debugging info
420    syserror("Error SMART Status command failed");
421    pout("Please get assistance from " PACKAGE_HOMEPAGE "\n");
422    pout("Register values returned from SMART Status command are:\n");
423    pout("ST =0x%02x\n",(int)buff[0]);
424    pout("ERR=0x%02x\n",(int)buff[1]);
425    pout("NS =0x%02x\n",(int)buff[2]);
426    pout("SC =0x%02x\n",(int)buff[3]);
427    pout("CL =0x%02x\n",(int)buff[4]);
428    pout("CH =0x%02x\n",(int)buff[5]);
429    pout("SEL=0x%02x\n",(int)buff[6]);
430    return -1;
431  }
432
433#if 1
434  // Note to people doing ports to other OSes -- don't worry about
435  // this block -- you can safely ignore it.  I have put it here
436  // because under linux when you do IDENTIFY DEVICE to a packet
437  // device, it generates an ugly kernel syslog error message.  This
438  // is harmless but frightens users.  So this block detects packet
439  // devices and make IDENTIFY DEVICE fail "nicely" without a syslog
440  // error message.
441  //
442  // If you read only the ATA specs, it appears as if a packet device
443  // *might* respond to the IDENTIFY DEVICE command.  This is
444  // misleading - it's because around the time that SFF-8020 was
445  // incorporated into the ATA-3/4 standard, the ATA authors were
446  // sloppy. See SFF-8020 and you will see that ATAPI devices have
447  // *always* had IDENTIFY PACKET DEVICE as a mandatory part of their
448  // command set, and return 'Command Aborted' to IDENTIFY DEVICE.
449  if (command==IDENTIFY || command==PIDENTIFY){
450    unsigned short deviceid[256];
451    // check the device identity, as seen when the system was booted
452    // or the device was FIRST registered.  This will not be current
453    // if the user has subsequently changed some of the parameters. If
454    // device is a packet device, swap the command interpretations.
455    if (!ioctl(get_fd(), HDIO_GET_IDENTITY, deviceid) && (deviceid[0] & 0x8000))
456      buff[0]=(command==IDENTIFY)?ATA_IDENTIFY_PACKET_DEVICE:ATA_IDENTIFY_DEVICE;
457  }
458#endif
459
460  // We are now doing the HDIO_DRIVE_CMD type ioctl.
461  if ((ioctl(get_fd(), HDIO_DRIVE_CMD, buff)))
462    return -1;
463
464  // CHECK POWER MODE command returns information in the Sector Count
465  // register (buff[3]).  Copy to return data buffer.
466  if (command==CHECK_POWER_MODE)
467    buff[HDIO_DRIVE_CMD_OFFSET]=buff[2];
468
469  // if the command returns data then copy it back
470  if (copydata)
471    memcpy(data, buff+HDIO_DRIVE_CMD_OFFSET, copydata);
472
473  return 0;
474}
475
476// >>>>>> Start of general SCSI specific linux code
477
478/* Linux specific code.
479 * Historically smartmontools (and smartsuite before it) used the
480 * SCSI_IOCTL_SEND_COMMAND ioctl which is available to all linux device
481 * nodes that use the SCSI subsystem. A better interface has been available
482 * via the SCSI generic (sg) driver but this involves the extra step of
483 * mapping disk devices (e.g. /dev/sda) to the corresponding sg device
484 * (e.g. /dev/sg2). In the linux kernel 2.6 series most of the facilities of
485 * the sg driver have become available via the SG_IO ioctl which is available
486 * on all SCSI devices (on SCSI tape devices from lk 2.6.6).
487 * So the strategy below is to find out if the SG_IO ioctl is available and
488 * if so use it; failing that use the older SCSI_IOCTL_SEND_COMMAND ioctl.
489 * Should work in 2.0, 2.2, 2.4 and 2.6 series linux kernels. */
490
491#define MAX_DXFER_LEN 1024      /* can be increased if necessary */
492#define SEND_IOCTL_RESP_SENSE_LEN 16    /* ioctl limitation */
493#define SG_IO_RESP_SENSE_LEN 64 /* large enough see buffer */
494#define LSCSI_DRIVER_MASK  0xf /* mask out "suggestions" */
495#define LSCSI_DRIVER_SENSE  0x8 /* alternate CHECK CONDITION indication */
496#define LSCSI_DRIVER_TIMEOUT  0x6
497#define LSCSI_DID_TIME_OUT  0x3
498#define LSCSI_DID_BUS_BUSY  0x2
499#define LSCSI_DID_NO_CONNECT  0x1
500
501#ifndef SCSI_IOCTL_SEND_COMMAND
502#define SCSI_IOCTL_SEND_COMMAND 1
503#endif
504
505#define SG_IO_PRESENT_UNKNOWN 0
506#define SG_IO_PRESENT_YES 1
507#define SG_IO_PRESENT_NO 2
508
509static int sg_io_cmnd_io(int dev_fd, struct scsi_cmnd_io * iop, int report,
510                         int unknown);
511static int sisc_cmnd_io(int dev_fd, struct scsi_cmnd_io * iop, int report);
512
513static int sg_io_state = SG_IO_PRESENT_UNKNOWN;
514
515/* Preferred implementation for issuing SCSI commands in linux. This
516 * function uses the SG_IO ioctl. Return 0 if command issued successfully
517 * (various status values should still be checked). If the SCSI command
518 * cannot be issued then a negative errno value is returned. */
519static int sg_io_cmnd_io(int dev_fd, struct scsi_cmnd_io * iop, int report,
520                         int unknown)
521{
522#ifndef SG_IO
523    ARGUSED(dev_fd); ARGUSED(iop); ARGUSED(report);
524    return -ENOTTY;
525#else
526    struct sg_io_hdr io_hdr;
527
528    if (report > 0) {
529        int k, j;
530        const unsigned char * ucp = iop->cmnd;
531        const char * np;
532        char buff[256];
533        const int sz = (int)sizeof(buff);
534
535        np = scsi_get_opcode_name(ucp[0]);
536        j = snprintf(buff, sz, " [%s: ", np ? np : "<unknown opcode>");
537        for (k = 0; k < (int)iop->cmnd_len; ++k)
538            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "%02x ", ucp[k]);
539        if ((report > 1) &&
540            (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
541            int trunc = (iop->dxfer_len > 256) ? 1 : 0;
542
543            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n  Outgoing "
544                          "data, len=%d%s:\n", (int)iop->dxfer_len,
545                          (trunc ? " [only first 256 bytes shown]" : ""));
546            dStrHex((const char *)iop->dxferp,
547                    (trunc ? 256 : iop->dxfer_len) , 1);
548        }
549        else
550            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n");
551        pout("%s", buff);
552    }
553    memset(&io_hdr, 0, sizeof(struct sg_io_hdr));
554    io_hdr.interface_id = 'S';
555    io_hdr.cmd_len = iop->cmnd_len;
556    io_hdr.mx_sb_len = iop->max_sense_len;
557    io_hdr.dxfer_len = iop->dxfer_len;
558    io_hdr.dxferp = iop->dxferp;
559    io_hdr.cmdp = iop->cmnd;
560    io_hdr.sbp = iop->sensep;
561    /* sg_io_hdr interface timeout has millisecond units. Timeout of 0
562       defaults to 60 seconds. */
563    io_hdr.timeout = ((0 == iop->timeout) ? 60 : iop->timeout) * 1000;
564    switch (iop->dxfer_dir) {
565        case DXFER_NONE:
566            io_hdr.dxfer_direction = SG_DXFER_NONE;
567            break;
568        case DXFER_FROM_DEVICE:
569            io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
570            break;
571        case DXFER_TO_DEVICE:
572            io_hdr.dxfer_direction = SG_DXFER_TO_DEV;
573            break;
574        default:
575            pout("do_scsi_cmnd_io: bad dxfer_dir\n");
576            return -EINVAL;
577    }
578    iop->resp_sense_len = 0;
579    iop->scsi_status = 0;
580    iop->resid = 0;
581    if (ioctl(dev_fd, SG_IO, &io_hdr) < 0) {
582        if (report && (! unknown))
583            pout("  SG_IO ioctl failed, errno=%d [%s]\n", errno,
584                 strerror(errno));
585        return -errno;
586    }
587    iop->resid = io_hdr.resid;
588    iop->scsi_status = io_hdr.status;
589    if (report > 0) {
590        pout("  scsi_status=0x%x, host_status=0x%x, driver_status=0x%x\n"
591             "  info=0x%x  duration=%d milliseconds  resid=%d\n", io_hdr.status,
592             io_hdr.host_status, io_hdr.driver_status, io_hdr.info,
593             io_hdr.duration, io_hdr.resid);
594        if (report > 1) {
595            if (DXFER_FROM_DEVICE == iop->dxfer_dir) {
596                int trunc, len;
597
598                len = iop->dxfer_len - iop->resid;
599                trunc = (len > 256) ? 1 : 0;
600                if (len > 0) {
601                    pout("  Incoming data, len=%d%s:\n", len,
602                         (trunc ? " [only first 256 bytes shown]" : ""));
603                    dStrHex((const char*)iop->dxferp, (trunc ? 256 : len),
604                            1);
605                } else
606                    pout("  Incoming data trimmed to nothing by resid\n");
607            }
608        }
609    }
610
611    if (io_hdr.info | SG_INFO_CHECK) { /* error or warning */
612        int masked_driver_status = (LSCSI_DRIVER_MASK & io_hdr.driver_status);
613
614        if (0 != io_hdr.host_status) {
615            if ((LSCSI_DID_NO_CONNECT == io_hdr.host_status) ||
616                (LSCSI_DID_BUS_BUSY == io_hdr.host_status) ||
617                (LSCSI_DID_TIME_OUT == io_hdr.host_status))
618                return -ETIMEDOUT;
619            else
620                return -EIO;    /* catch all */
621        }
622        if (0 != masked_driver_status) {
623            if (LSCSI_DRIVER_TIMEOUT == masked_driver_status)
624                return -ETIMEDOUT;
625            else if (LSCSI_DRIVER_SENSE != masked_driver_status)
626                return -EIO;
627        }
628        if (LSCSI_DRIVER_SENSE == masked_driver_status)
629            iop->scsi_status = SCSI_STATUS_CHECK_CONDITION;
630        iop->resp_sense_len = io_hdr.sb_len_wr;
631        if ((SCSI_STATUS_CHECK_CONDITION == iop->scsi_status) &&
632            iop->sensep && (iop->resp_sense_len > 0)) {
633            if (report > 1) {
634                pout("  >>> Sense buffer, len=%d:\n",
635                     (int)iop->resp_sense_len);
636                dStrHex((const char *)iop->sensep, iop->resp_sense_len , 1);
637            }
638        }
639        if (report) {
640            if (SCSI_STATUS_CHECK_CONDITION == iop->scsi_status) {
641                if ((iop->sensep[0] & 0x7f) > 0x71)
642                    pout("  status=%x: [desc] sense_key=%x asc=%x ascq=%x\n",
643                         iop->scsi_status, iop->sensep[1] & 0xf,
644                         iop->sensep[2], iop->sensep[3]);
645                else
646                    pout("  status=%x: sense_key=%x asc=%x ascq=%x\n",
647                         iop->scsi_status, iop->sensep[2] & 0xf,
648                         iop->sensep[12], iop->sensep[13]);
649            }
650            else
651                pout("  status=0x%x\n", iop->scsi_status);
652        }
653    }
654    return 0;
655#endif
656}
657
658struct linux_ioctl_send_command
659{
660    int inbufsize;
661    int outbufsize;
662    UINT8 buff[MAX_DXFER_LEN + 16];
663};
664
665/* The Linux SCSI_IOCTL_SEND_COMMAND ioctl is primitive and it doesn't
666 * support: CDB length (guesses it from opcode), resid and timeout.
667 * Patches in Linux 2.4.21 and 2.5.70 to extend SEND DIAGNOSTIC timeout
668 * to 2 hours in order to allow long foreground extended self tests. */
669static int sisc_cmnd_io(int dev_fd, struct scsi_cmnd_io * iop, int report)
670{
671    struct linux_ioctl_send_command wrk;
672    int status, buff_offset;
673    size_t len;
674
675    memcpy(wrk.buff, iop->cmnd, iop->cmnd_len);
676    buff_offset = iop->cmnd_len;
677    if (report > 0) {
678        int k, j;
679        const unsigned char * ucp = iop->cmnd;
680        const char * np;
681        char buff[256];
682        const int sz = (int)sizeof(buff);
683
684        np = scsi_get_opcode_name(ucp[0]);
685        j = snprintf(buff, sz, " [%s: ", np ? np : "<unknown opcode>");
686        for (k = 0; k < (int)iop->cmnd_len; ++k)
687            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "%02x ", ucp[k]);
688        if ((report > 1) &&
689            (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
690            int trunc = (iop->dxfer_len > 256) ? 1 : 0;
691
692            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n  Outgoing "
693                          "data, len=%d%s:\n", (int)iop->dxfer_len,
694                          (trunc ? " [only first 256 bytes shown]" : ""));
695            dStrHex((const char *)iop->dxferp,
696                    (trunc ? 256 : iop->dxfer_len) , 1);
697        }
698        else
699            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n");
700        pout("%s", buff);
701    }
702    switch (iop->dxfer_dir) {
703        case DXFER_NONE:
704            wrk.inbufsize = 0;
705            wrk.outbufsize = 0;
706            break;
707        case DXFER_FROM_DEVICE:
708            wrk.inbufsize = 0;
709            if (iop->dxfer_len > MAX_DXFER_LEN)
710                return -EINVAL;
711            wrk.outbufsize = iop->dxfer_len;
712            break;
713        case DXFER_TO_DEVICE:
714            if (iop->dxfer_len > MAX_DXFER_LEN)
715                return -EINVAL;
716            memcpy(wrk.buff + buff_offset, iop->dxferp, iop->dxfer_len);
717            wrk.inbufsize = iop->dxfer_len;
718            wrk.outbufsize = 0;
719            break;
720        default:
721            pout("do_scsi_cmnd_io: bad dxfer_dir\n");
722            return -EINVAL;
723    }
724    iop->resp_sense_len = 0;
725    iop->scsi_status = 0;
726    iop->resid = 0;
727    status = ioctl(dev_fd, SCSI_IOCTL_SEND_COMMAND, &wrk);
728    if (-1 == status) {
729        if (report)
730            pout("  SCSI_IOCTL_SEND_COMMAND ioctl failed, errno=%d [%s]\n",
731                 errno, strerror(errno));
732        return -errno;
733    }
734    if (0 == status) {
735        if (report > 0)
736            pout("  status=0\n");
737        if (DXFER_FROM_DEVICE == iop->dxfer_dir) {
738            memcpy(iop->dxferp, wrk.buff, iop->dxfer_len);
739            if (report > 1) {
740                int trunc = (iop->dxfer_len > 256) ? 1 : 0;
741
742                pout("  Incoming data, len=%d%s:\n", (int)iop->dxfer_len,
743                     (trunc ? " [only first 256 bytes shown]" : ""));
744                dStrHex((const char*)iop->dxferp,
745                        (trunc ? 256 : iop->dxfer_len) , 1);
746            }
747        }
748        return 0;
749    }
750    iop->scsi_status = status & 0x7e; /* bits 0 and 7 used to be for vendors */
751    if (LSCSI_DRIVER_SENSE == ((status >> 24) & 0xf))
752        iop->scsi_status = SCSI_STATUS_CHECK_CONDITION;
753    len = (SEND_IOCTL_RESP_SENSE_LEN < iop->max_sense_len) ?
754                SEND_IOCTL_RESP_SENSE_LEN : iop->max_sense_len;
755    if ((SCSI_STATUS_CHECK_CONDITION == iop->scsi_status) &&
756        iop->sensep && (len > 0)) {
757        memcpy(iop->sensep, wrk.buff, len);
758        iop->resp_sense_len = len;
759        if (report > 1) {
760            pout("  >>> Sense buffer, len=%d:\n", (int)len);
761            dStrHex((const char *)wrk.buff, len , 1);
762        }
763    }
764    if (report) {
765        if (SCSI_STATUS_CHECK_CONDITION == iop->scsi_status) {
766            pout("  status=%x: sense_key=%x asc=%x ascq=%x\n", status & 0xff,
767                 wrk.buff[2] & 0xf, wrk.buff[12], wrk.buff[13]);
768        }
769        else
770            pout("  status=0x%x\n", status);
771    }
772    if (iop->scsi_status > 0)
773        return 0;
774    else {
775        if (report > 0)
776            pout("  ioctl status=0x%x but scsi status=0, fail with EIO\n",
777                 status);
778        return -EIO;      /* give up, assume no device there */
779    }
780}
781
782/* SCSI command transmission interface function, linux version.
783 * Returns 0 if SCSI command successfully launched and response
784 * received. Even when 0 is returned the caller should check
785 * scsi_cmnd_io::scsi_status for SCSI defined errors and warnings
786 * (e.g. CHECK CONDITION). If the SCSI command could not be issued
787 * (e.g. device not present or timeout) or some other problem
788 * (e.g. timeout) then returns a negative errno value */
789static int do_normal_scsi_cmnd_io(int dev_fd, struct scsi_cmnd_io * iop,
790                                  int report)
791{
792    int res;
793
794    /* implementation relies on static sg_io_state variable. If not
795     * previously set tries the SG_IO ioctl. If that succeeds assume
796     * that SG_IO ioctl functional. If it fails with an errno value
797     * other than ENODEV (no device) or permission then assume
798     * SCSI_IOCTL_SEND_COMMAND is the only option. */
799    switch (sg_io_state) {
800    case SG_IO_PRESENT_UNKNOWN:
801        /* ignore report argument */
802        if (0 == (res = sg_io_cmnd_io(dev_fd, iop, report, 1))) {
803            sg_io_state = SG_IO_PRESENT_YES;
804            return 0;
805        } else if ((-ENODEV == res) || (-EACCES == res) || (-EPERM == res))
806            return res;         /* wait until we see a device */
807        sg_io_state = SG_IO_PRESENT_NO;
808        /* drop through by design */
809    case SG_IO_PRESENT_NO:
810        return sisc_cmnd_io(dev_fd, iop, report);
811    case SG_IO_PRESENT_YES:
812        return sg_io_cmnd_io(dev_fd, iop, report, 0);
813    default:
814        pout(">>>> do_scsi_cmnd_io: bad sg_io_state=%d\n", sg_io_state);
815        sg_io_state = SG_IO_PRESENT_UNKNOWN;
816        return -EIO;    /* report error and reset state */
817    }
818}
819
820// >>>>>> End of general SCSI specific linux code
821
822/////////////////////////////////////////////////////////////////////////////
823/// Standard SCSI support
824
825class linux_scsi_device
826: public /*implements*/ scsi_device,
827  public /*extends*/ linux_smart_device
828{
829public:
830  linux_scsi_device(smart_interface * intf, const char * dev_name, const char * req_type);
831
832  virtual smart_device * autodetect_open();
833
834  virtual bool scsi_pass_through(scsi_cmnd_io * iop);
835};
836
837linux_scsi_device::linux_scsi_device(smart_interface * intf,
838  const char * dev_name, const char * req_type)
839: smart_device(intf, dev_name, "scsi", req_type),
840  linux_smart_device(O_RDWR | O_NONBLOCK, O_RDONLY | O_NONBLOCK)
841{
842}
843
844
845bool linux_scsi_device::scsi_pass_through(scsi_cmnd_io * iop)
846{
847  int status = do_normal_scsi_cmnd_io(get_fd(), iop, con->reportscsiioctl);
848  if (status < 0)
849      return set_err(-status);
850  return true;
851}
852
853/////////////////////////////////////////////////////////////////////////////
854/// LSI MegaRAID support
855
856class linux_megaraid_device
857: public /* implements */ scsi_device,
858  public /* extends */ linux_smart_device
859{
860public:
861  linux_megaraid_device(smart_interface *intf, const char *name, 
862    unsigned int bus, unsigned int tgt);
863
864  virtual ~linux_megaraid_device() throw();
865
866  virtual smart_device * autodetect_open();
867
868  virtual bool open();
869  virtual bool close();
870 
871  virtual bool scsi_pass_through(scsi_cmnd_io *iop);
872
873private:
874  unsigned int m_disknum;
875  unsigned int m_busnum;
876  unsigned int m_hba;
877  int m_fd;
878
879  bool (linux_megaraid_device::*pt_cmd)(int cdblen, void *cdb, int dataLen, void *data,
880    int senseLen, void *sense, int report);
881  bool megasas_cmd(int cdbLen, void *cdb, int dataLen, void *data,
882    int senseLen, void *sense, int report);
883  bool megadev_cmd(int cdbLen, void *cdb, int dataLen, void *data,
884    int senseLen, void *sense, int report);
885};
886
887linux_megaraid_device::linux_megaraid_device(smart_interface *intf,
888  const char *dev_name, unsigned int bus, unsigned int tgt)
889 : smart_device(intf, dev_name, "megaraid", "megaraid"),
890   linux_smart_device(O_RDWR | O_NONBLOCK),
891   m_disknum(tgt), m_busnum(bus), m_hba(0),
892   m_fd(-1), pt_cmd(0)
893{
894  set_info().info_name = strprintf("%s [megaraid_disk_%02d]", dev_name, m_disknum);
895}
896
897linux_megaraid_device::~linux_megaraid_device() throw()
898{
899  if (m_fd >= 0)
900    ::close(m_fd);
901}
902
903smart_device * linux_megaraid_device::autodetect_open()
904{
905  // Open device
906  if (!open())
907    return this;
908
909  // The code below is based on smartd.cpp:SCSIFilterKnown()
910  if (strcmp(get_req_type(), "megaraid"))
911    return this;
912
913  // Get INQUIRY
914  unsigned char req_buff[64] = {0, };
915  int req_len = 36;
916  if (scsiStdInquiry(this, req_buff, req_len)) {
917      close();
918      set_err(EIO, "INQUIRY failed");
919      return this;
920  }
921
922  int avail_len = req_buff[4] + 5;
923  int len = (avail_len < req_len ? avail_len : req_len);
924  if (len < 36)
925      return this;
926
927  printf("Got MegaRAID inquiry.. %s\n", req_buff+8);
928
929  // Use INQUIRY to detect type
930  smart_device * newdev = 0;
931  try {
932    // SAT or USB ?
933    newdev = smi()->autodetect_sat_device(this, req_buff, len);
934    if (newdev)
935      // NOTE: 'this' is now owned by '*newdev'
936      return newdev;
937  }
938  catch (...) {
939    // Cleanup if exception occurs after newdev was allocated
940    delete newdev;
941    throw;
942  }
943
944  // Nothing special found
945  return this;
946}
947
948
949bool linux_megaraid_device::open()
950{
951  char line[128];
952  int   mjr, n1;
953  FILE *fp;
954
955  if (!linux_smart_device::open())
956    return false;
957
958  /* Get device HBA */
959  struct sg_scsi_id sgid;
960  if (ioctl(get_fd(), SG_GET_SCSI_ID, &sgid) == 0) {
961    m_hba = sgid.host_no;
962  }
963  else if (ioctl(get_fd(), SCSI_IOCTL_GET_BUS_NUMBER, &m_hba) != 0) {
964    int err = errno;
965    linux_smart_device::close();
966    return set_err(err, "can't get hba");
967  }
968
969  /* Perform mknod of device ioctl node */
970  fp = fopen("/proc/devices", "r");
971  while (fgets(line, sizeof(line), fp) != NULL) {
972        n1=0;
973        if (sscanf(line, "%d megaraid_sas_ioctl%n", &mjr, &n1) == 1 && n1 == 22) {
974           n1=mknod("/dev/megaraid_sas_ioctl_node", S_IFCHR, makedev(mjr, 0));
975           printf("Creating /dev/megaraid_sas_ioctl_node = %d\n", n1 >= 0 ? 0 : errno);
976           if (n1 >= 0 || errno == EEXIST)
977              break;
978        }
979        else if (sscanf(line, "%d megadev%n", &mjr, &n1) == 1 && n1 == 11) {
980           n1=mknod("/dev/megadev0", S_IFCHR, makedev(mjr, 0));
981           printf("Creating /dev/megadev0 = %d\n", n1 >= 0 ? 0 : errno);
982           if (n1 >= 0 || errno == EEXIST)
983              break;
984        }
985  }
986  fclose(fp);
987
988  /* Open Device IOCTL node */
989  if ((m_fd = ::open("/dev/megaraid_sas_ioctl_node", O_RDWR)) >= 0) {
990    pt_cmd = &linux_megaraid_device::megasas_cmd;
991  }
992  else if ((m_fd = ::open("/dev/megadev0", O_RDWR)) >= 0) {
993    pt_cmd = &linux_megaraid_device::megadev_cmd;
994  }
995  else {
996    int err = errno;
997    linux_smart_device::close();
998    return set_err(err, "cannot open /dev/megaraid_sas_ioctl_node or /dev/megadev0");
999  }
1000
1001  return true;
1002}
1003
1004bool linux_megaraid_device::close()
1005{
1006  if (m_fd >= 0)
1007    ::close(m_fd);
1008  m_fd = -1; m_hba = 0; pt_cmd = 0;
1009  return linux_smart_device::close();
1010}
1011
1012bool linux_megaraid_device::scsi_pass_through(scsi_cmnd_io *iop)
1013{
1014  int report = con->reportscsiioctl; 
1015
1016  if (report > 0) {
1017        int k, j;
1018        const unsigned char * ucp = iop->cmnd;
1019        const char * np;
1020        char buff[256];
1021        const int sz = (int)sizeof(buff);
1022
1023        np = scsi_get_opcode_name(ucp[0]);
1024        j = snprintf(buff, sz, " [%s: ", np ? np : "<unknown opcode>");
1025        for (k = 0; k < (int)iop->cmnd_len; ++k)
1026            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "%02x ", ucp[k]);
1027        if ((report > 1) &&
1028            (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
1029            int trunc = (iop->dxfer_len > 256) ? 1 : 0;
1030
1031            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n  Outgoing "
1032                          "data, len=%d%s:\n", (int)iop->dxfer_len,
1033                          (trunc ? " [only first 256 bytes shown]" : ""));
1034            dStrHex((const char *)iop->dxferp,
1035                    (trunc ? 256 : iop->dxfer_len) , 1);
1036        }
1037        else
1038            j += snprintf(&buff[j], (sz > j ? (sz - j) : 0), "]\n");
1039        pout("%s", buff);
1040  }
1041
1042  /* Controller rejects Enable SMART and Test Unit Ready */
1043  if (iop->cmnd[0] == 0x00)
1044    return true;
1045  if (iop->cmnd[0] == 0x85 && iop->cmnd[1] == 0x06) {
1046    pout("Rejecting SMART/ATA command to controller\n");
1047    // Emulate SMART STATUS CHECK drive reply
1048    // smartctl fail to work without this
1049    if(iop->cmnd[2]==0x2c) {
1050      iop->resp_sense_len=22;
1051      iop->sensep[0]=0x72; // response code
1052      iop->sensep[7]=0x0e; // no idea what it is, copied from sat device answer
1053      iop->sensep[8]=0x09; //
1054      iop->sensep[17]=0x4f; // lm
1055      iop->sensep[19]=0xc2; // lh
1056    }
1057    return true;
1058  }
1059
1060  if (pt_cmd == NULL)
1061    return false;
1062  return (this->*pt_cmd)(iop->cmnd_len, iop->cmnd, 
1063    iop->dxfer_len, iop->dxferp,
1064    iop->max_sense_len, iop->sensep, report);
1065}
1066
1067/* Issue passthrough scsi command to PERC5/6 controllers */
1068bool linux_megaraid_device::megasas_cmd(int cdbLen, void *cdb, 
1069  int dataLen, void *data,
1070  int /*senseLen*/, void * /*sense*/, int /*report*/)
1071{
1072  struct megasas_pthru_frame    *pthru;
1073  struct megasas_iocpacket      uio;
1074  int rc;
1075
1076  memset(&uio, 0, sizeof(uio));
1077  pthru = (struct megasas_pthru_frame *)uio.frame.raw;
1078  pthru->cmd = MFI_CMD_PD_SCSI_IO;
1079  pthru->cmd_status = 0xFF;
1080  pthru->scsi_status = 0x0;
1081  pthru->target_id = m_disknum;
1082  pthru->lun = 0;
1083  pthru->cdb_len = cdbLen;
1084  pthru->timeout = 0;
1085  pthru->flags = MFI_FRAME_DIR_READ;
1086  pthru->sge_count = 1;
1087  pthru->data_xfer_len = dataLen;
1088  pthru->sgl.sge32[0].phys_addr = (intptr_t)data;
1089  pthru->sgl.sge32[0].length = (uint32_t)dataLen;
1090  memcpy(pthru->cdb, cdb, cdbLen);
1091
1092  uio.host_no = m_hba;
1093  uio.sge_count = 1;
1094  uio.sgl_off = offsetof(struct megasas_pthru_frame, sgl);
1095  uio.sgl[0].iov_base = data;
1096  uio.sgl[0].iov_len = dataLen;
1097
1098  rc = 0;
1099  errno = 0;
1100  rc = ioctl(m_fd, MEGASAS_IOC_FIRMWARE, &uio);
1101  if (pthru->cmd_status || rc != 0) {
1102    if (pthru->cmd_status == 12) {
1103      return set_err(EIO, "megasas_cmd: Device %d does not exist\n", m_disknum);
1104    }
1105    return set_err((errno ? errno : EIO), "megasas_cmd result: %d.%d = %d/%d",
1106                   m_hba, m_disknum, errno,
1107                   pthru->cmd_status);
1108  }
1109  return true;
1110}
1111
1112/* Issue passthrough scsi commands to PERC2/3/4 controllers */
1113bool linux_megaraid_device::megadev_cmd(int cdbLen, void *cdb, 
1114  int dataLen, void *data,
1115  int senseLen, void *sense, int /*report*/)
1116{
1117  struct uioctl_t uio;
1118  int rc;
1119
1120  sense = NULL;
1121  senseLen = 0;
1122
1123  /* Don't issue to the controller */
1124  if (m_disknum == 7)
1125    return false;
1126
1127  memset(&uio, 0, sizeof(uio));
1128  uio.inlen  = dataLen;
1129  uio.outlen = dataLen;
1130
1131  memset(data, 0, dataLen);
1132  uio.ui.fcs.opcode = 0x80;             // M_RD_IOCTL_CMD
1133  uio.ui.fcs.adapno = MKADAP(m_hba);
1134
1135  uio.data.pointer = (uint8_t *)data;
1136
1137  uio.mbox.cmd = MEGA_MBOXCMD_PASSTHRU;
1138  uio.mbox.xferaddr = (intptr_t)&uio.pthru;
1139
1140  uio.pthru.ars     = 1;
1141  uio.pthru.timeout = 2;
1142  uio.pthru.channel = 0;
1143  uio.pthru.target  = m_disknum;
1144  uio.pthru.cdblen  = cdbLen;
1145  uio.pthru.reqsenselen  = MAX_REQ_SENSE_LEN;
1146  uio.pthru.dataxferaddr = (intptr_t)data;
1147  uio.pthru.dataxferlen  = dataLen;
1148  memcpy(uio.pthru.cdb, cdb, cdbLen);
1149
1150  rc=ioctl(m_fd, MEGAIOCCMD, &uio);
1151  if (uio.pthru.scsistatus || rc != 0) {
1152    return set_err((errno ? errno : EIO), "megadev_cmd result: %d.%d =  %d/%d",
1153                   m_hba, m_disknum, errno,
1154                   uio.pthru.scsistatus);
1155  }
1156  return true;
1157}
1158
1159/////////////////////////////////////////////////////////////////////////////
1160/// CCISS RAID support
1161
1162#ifdef HAVE_LINUX_CCISS_IOCTL_H
1163
1164class linux_cciss_device
1165: public /*implements*/ scsi_device,
1166  public /*extends*/ linux_smart_device
1167{
1168public:
1169  linux_cciss_device(smart_interface * intf, const char * name, unsigned char disknum);
1170
1171  virtual bool scsi_pass_through(scsi_cmnd_io * iop);
1172
1173private:
1174  unsigned char m_disknum; ///< Disk number.
1175};
1176
1177linux_cciss_device::linux_cciss_device(smart_interface * intf,
1178  const char * dev_name, unsigned char disknum)
1179: smart_device(intf, dev_name, "cciss", "cciss"),
1180  linux_smart_device(O_RDWR | O_NONBLOCK),
1181  m_disknum(disknum)
1182{
1183  set_info().info_name = strprintf("%s [cciss_disk_%02d]", dev_name, disknum);
1184}
1185
1186bool linux_cciss_device::scsi_pass_through(scsi_cmnd_io * iop)
1187{
1188  int status = cciss_io_interface(get_fd(), m_disknum, iop, con->reportscsiioctl);
1189  if (status < 0)
1190      return set_err(-status);
1191  return true;
1192}
1193
1194#endif // HAVE_LINUX_CCISS_IOCTL_H
1195
1196/////////////////////////////////////////////////////////////////////////////
1197/// AMCC/3ware RAID support
1198
1199class linux_escalade_device
1200: public /*implements*/ ata_device,
1201  public /*extends*/ linux_smart_device
1202{
1203public:
1204  enum escalade_type_t {
1205    AMCC_3WARE_678K,
1206    AMCC_3WARE_678K_CHAR,
1207    AMCC_3WARE_9000_CHAR
1208  };
1209
1210  linux_escalade_device(smart_interface * intf, const char * dev_name,
1211    escalade_type_t escalade_type, int disknum);
1212
1213  virtual bool open();
1214
1215  virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out);
1216
1217private:
1218  escalade_type_t m_escalade_type; ///< Controller type
1219  int m_disknum; ///< Disk number.
1220};
1221
1222linux_escalade_device::linux_escalade_device(smart_interface * intf, const char * dev_name,
1223    escalade_type_t escalade_type, int disknum)
1224: smart_device(intf, dev_name, "3ware", "3ware"),
1225  linux_smart_device(O_RDONLY | O_NONBLOCK),
1226  m_escalade_type(escalade_type), m_disknum(disknum)
1227{
1228  set_info().info_name = strprintf("%s [3ware_disk_%02d]", dev_name, disknum);
1229}
1230
1231/* This function will setup and fix device nodes for a 3ware controller. */
1232#define MAJOR_STRING_LENGTH 3
1233#define DEVICE_STRING_LENGTH 32
1234#define NODE_STRING_LENGTH 16
1235int setup_3ware_nodes(const char *nodename, const char *driver_name) {
1236  int              tw_major      = 0;
1237  int              index         = 0;
1238  char             majorstring[MAJOR_STRING_LENGTH+1];
1239  char             device_name[DEVICE_STRING_LENGTH+1];
1240  char             nodestring[NODE_STRING_LENGTH];
1241  struct stat      stat_buf;
1242  FILE             *file;
1243  int              retval = 0;
1244#ifdef WITH_SELINUX
1245  security_context_t orig_context = NULL;
1246  security_context_t node_context = NULL;
1247  int                selinux_enabled  = is_selinux_enabled();
1248  int                selinux_enforced = security_getenforce();
1249#endif
1250
1251
1252  /* First try to open up /proc/devices */
1253  if (!(file = fopen("/proc/devices", "r"))) {
1254    pout("Error opening /proc/devices to check/create 3ware device nodes\n");
1255    syserror("fopen");
1256    return 0;  // don't fail here: user might not have /proc !
1257  }
1258
1259  /* Attempt to get device major number */
1260  while (EOF != fscanf(file, "%3s %32s", majorstring, device_name)) {
1261    majorstring[MAJOR_STRING_LENGTH]='\0';
1262    device_name[DEVICE_STRING_LENGTH]='\0';
1263    if (!strncmp(device_name, nodename, DEVICE_STRING_LENGTH)) {
1264      tw_major = atoi(majorstring);
1265      break;
1266    }
1267  }
1268  fclose(file);
1269
1270  /* See if we found a major device number */
1271  if (!tw_major) {
1272    pout("No major number for /dev/%s listed in /proc/devices. Is the %s driver loaded?\n", nodename, driver_name);
1273    return 2;
1274  }
1275#ifdef WITH_SELINUX
1276  /* Prepare a database of contexts for files in /dev
1277   * and save the current context */
1278  if (selinux_enabled) {
1279    if (matchpathcon_init_prefix(NULL, "/dev") < 0)
1280      pout("Error initializing contexts database for /dev");
1281    if (getfscreatecon(&orig_context) < 0) {
1282      pout("Error retrieving original SELinux fscreate context");
1283      if (selinux_enforced)
1284        matchpathcon_fini();
1285        return 6;
1286      }
1287  }
1288#endif
1289  /* Now check if nodes are correct */
1290  for (index=0; index<16; index++) {
1291    sprintf(nodestring, "/dev/%s%d", nodename, index);
1292#ifdef WITH_SELINUX
1293    /* Get context of the node and set it as the default */
1294    if (selinux_enabled) {
1295      if (matchpathcon(nodestring, S_IRUSR | S_IWUSR, &node_context) < 0) {
1296        pout("Could not retrieve context for %s", nodestring);
1297        if (selinux_enforced) {
1298          retval = 6;
1299          break;
1300        }
1301      }
1302      if (setfscreatecon(node_context) < 0) {
1303        pout ("Error setting default fscreate context");
1304        if (selinux_enforced) {
1305          retval = 6;
1306          break;
1307        }
1308      }
1309    }
1310#endif
1311    /* Try to stat the node */
1312    if ((stat(nodestring, &stat_buf))) {
1313      pout("Node %s does not exist and must be created. Check the udev rules.\n", nodestring);
1314      /* Create a new node if it doesn't exist */
1315      if (mknod(nodestring, S_IFCHR|0600, makedev(tw_major, index))) {
1316        pout("problem creating 3ware device nodes %s", nodestring);
1317        syserror("mknod");
1318        retval = 3;
1319        break;
1320      } else {
1321#ifdef WITH_SELINUX
1322        if (selinux_enabled && node_context) {
1323          freecon(node_context);
1324          node_context = NULL;
1325        }
1326#endif
1327        continue;
1328      }
1329    }
1330
1331    /* See if nodes major and minor numbers are correct */
1332    if ((tw_major != (int)(major(stat_buf.st_rdev))) ||
1333        (index    != (int)(minor(stat_buf.st_rdev))) ||
1334        (!S_ISCHR(stat_buf.st_mode))) {
1335      pout("Node %s has wrong major/minor number and must be created anew."
1336          " Check the udev rules.\n", nodestring);
1337      /* Delete the old node */
1338      if (unlink(nodestring)) {
1339        pout("problem unlinking stale 3ware device node %s", nodestring);
1340        syserror("unlink");
1341        retval = 4;
1342        break;
1343      }
1344
1345      /* Make a new node */
1346      if (mknod(nodestring, S_IFCHR|0600, makedev(tw_major, index))) {
1347        pout("problem creating 3ware device nodes %s", nodestring);
1348        syserror("mknod");
1349        retval = 5;
1350        break;
1351      }
1352    }
1353#ifdef WITH_SELINUX
1354    if (selinux_enabled && node_context) {
1355      freecon(node_context);
1356      node_context = NULL;
1357    }
1358#endif
1359  }
1360
1361#ifdef WITH_SELINUX
1362  if (selinux_enabled) {
1363    if(setfscreatecon(orig_context) < 0) {
1364      pout("Error re-setting original fscreate context");
1365      if (selinux_enforced)
1366        retval = 6;
1367    }
1368    if(orig_context)
1369      freecon(orig_context);
1370    if(node_context)
1371      freecon(node_context);
1372    matchpathcon_fini();
1373  }
1374#endif
1375  return retval;
1376}
1377
1378bool linux_escalade_device::open()
1379{
1380  if (m_escalade_type == AMCC_3WARE_9000_CHAR || m_escalade_type == AMCC_3WARE_678K_CHAR) {
1381    // the device nodes for these controllers are dynamically assigned,
1382    // so we need to check that they exist with the correct major
1383    // numbers and if not, create them
1384    const char * node   = (m_escalade_type == AMCC_3WARE_9000_CHAR ? "twa"    : "twe"    );
1385    const char * driver = (m_escalade_type == AMCC_3WARE_9000_CHAR ? "3w-9xxx": "3w-xxxx");
1386    if (setup_3ware_nodes(node, driver))
1387      return set_err((errno ? errno : ENXIO), "setup_3ware_nodes(\"%s\", \"%s\") failed", node, driver);
1388  }
1389  // Continue with default open
1390  return linux_smart_device::open();
1391}
1392
1393// TODO: Function no longer useful
1394//void printwarning(smart_command_set command);
1395
1396// PURPOSE
1397//   This is an interface routine meant to isolate the OS dependent
1398//   parts of the code, and to provide a debugging interface.  Each
1399//   different port and OS needs to provide it's own interface.  This
1400//   is the linux interface to the 3ware 3w-xxxx driver.  It allows ATA
1401//   commands to be passed through the SCSI driver.
1402// DETAILED DESCRIPTION OF ARGUMENTS
1403//   fd: is the file descriptor provided by open()
1404//   disknum is the disk number (0 to 15) in the RAID array
1405//   escalade_type indicates the type of controller type, and if scsi or char interface is used
1406//   command: defines the different operations.
1407//   select: additional input data if needed (which log, which type of
1408//           self-test).
1409//   data:   location to write output data, if needed (512 bytes).
1410//   Note: not all commands use all arguments.
1411// RETURN VALUES
1412//  -1 if the command failed
1413//   0 if the command succeeded,
1414//   STATUS_CHECK routine:
1415//  -1 if the command failed
1416//   0 if the command succeeded and disk SMART status is "OK"
1417//   1 if the command succeeded and disk SMART status is "FAILING"
1418
1419
1420/* 512 is the max payload size: increase if needed */
1421#define BUFFER_LEN_678K      ( sizeof(TW_Ioctl)                  ) // 1044 unpacked, 1041 packed
1422#define BUFFER_LEN_678K_CHAR ( sizeof(TW_New_Ioctl)+512-1        ) // 1539 unpacked, 1536 packed
1423#define BUFFER_LEN_9000      ( sizeof(TW_Ioctl_Buf_Apache)+512-1 ) // 2051 unpacked, 2048 packed
1424#define TW_IOCTL_BUFFER_SIZE ( MAX(MAX(BUFFER_LEN_678K, BUFFER_LEN_9000), BUFFER_LEN_678K_CHAR) )
1425
1426bool linux_escalade_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out)
1427{
1428  if (!ata_cmd_is_ok(in,
1429    true, // data_out_support
1430    false, // TODO: multi_sector_support
1431    true) // ata_48bit_support
1432  )
1433    return false;
1434
1435  // Used by both the SCSI and char interfaces
1436  TW_Passthru *passthru=NULL;
1437  char ioctl_buffer[TW_IOCTL_BUFFER_SIZE];
1438
1439  // only used for SCSI device interface
1440  TW_Ioctl   *tw_ioctl=NULL;
1441  TW_Output *tw_output=NULL;
1442
1443  // only used for 6000/7000/8000 char device interface
1444  TW_New_Ioctl *tw_ioctl_char=NULL;
1445
1446  // only used for 9000 character device interface
1447  TW_Ioctl_Buf_Apache *tw_ioctl_apache=NULL;
1448
1449  memset(ioctl_buffer, 0, TW_IOCTL_BUFFER_SIZE);
1450
1451  // TODO: Handle controller differences by different classes
1452  if (m_escalade_type==AMCC_3WARE_9000_CHAR) {
1453    tw_ioctl_apache                               = (TW_Ioctl_Buf_Apache *)ioctl_buffer;
1454    tw_ioctl_apache->driver_command.control_code  = TW_IOCTL_FIRMWARE_PASS_THROUGH;
1455    tw_ioctl_apache->driver_command.buffer_length = 512; /* payload size */
1456    passthru                                      = (TW_Passthru *)&(tw_ioctl_apache->firmware_command.command.oldcommand);
1457  }
1458  else if (m_escalade_type==AMCC_3WARE_678K_CHAR) {
1459    tw_ioctl_char                                 = (TW_New_Ioctl *)ioctl_buffer;
1460    tw_ioctl_char->data_buffer_length             = 512;
1461    passthru                                      = (TW_Passthru *)&(tw_ioctl_char->firmware_command);
1462  }
1463  else if (m_escalade_type==AMCC_3WARE_678K) {
1464    tw_ioctl                                      = (TW_Ioctl *)ioctl_buffer;
1465    tw_ioctl->cdb[0]                              = TW_IOCTL;
1466    tw_ioctl->opcode                              = TW_ATA_PASSTHRU;
1467    tw_ioctl->input_length                        = 512; // correct even for non-data commands
1468    tw_ioctl->output_length                       = 512; // correct even for non-data commands
1469    tw_output                                     = (TW_Output *)tw_ioctl;
1470    passthru                                      = (TW_Passthru *)&(tw_ioctl->input_data);
1471  }
1472  else {
1473    return set_err(ENOSYS,
1474      "Unrecognized escalade_type %d in linux_3ware_command_interface(disk %d)\n"
1475      "Please contact " PACKAGE_BUGREPORT "\n", (int)m_escalade_type, m_disknum);
1476  }
1477
1478  // Same for (almost) all commands - but some reset below
1479  passthru->byte0.opcode  = TW_OP_ATA_PASSTHRU;
1480  passthru->request_id    = 0xFF;
1481  passthru->unit          = m_disknum;
1482  passthru->status        = 0;
1483  passthru->flags         = 0x1;
1484
1485  // Set registers
1486  {
1487    const ata_in_regs_48bit & r = in.in_regs;
1488    passthru->features     = r.features_16;
1489    passthru->sector_count = r.sector_count_16;
1490    passthru->sector_num   = r.lba_low_16;
1491    passthru->cylinder_lo  = r.lba_mid_16;
1492    passthru->cylinder_hi  = r.lba_high_16;
1493    passthru->drive_head   = r.device;
1494    passthru->command      = r.command;
1495  }
1496
1497  // Is this a command that reads or returns 512 bytes?
1498  // passthru->param values are:
1499  // 0x0 - non data command without TFR write check,
1500  // 0x8 - non data command with TFR write check,
1501  // 0xD - data command that returns data to host from device
1502  // 0xF - data command that writes data from host to device
1503  // passthru->size values are 0x5 for non-data and 0x07 for data
1504  bool readdata = false;
1505  if (in.direction == ata_cmd_in::data_in) {
1506    readdata=true;
1507    passthru->byte0.sgloff = 0x5;
1508    passthru->size         = 0x7; // TODO: Other value for multi-sector ?
1509    passthru->param        = 0xD;
1510    // For 64-bit to work correctly, up the size of the command packet
1511    // in dwords by 1 to account for the 64-bit single sgl 'address'
1512    // field. Note that this doesn't agree with the typedefs but it's
1513    // right (agree with kernel driver behavior/typedefs).
1514    if (m_escalade_type==AMCC_3WARE_9000_CHAR && sizeof(long)==8)
1515      passthru->size++;
1516  }
1517  else if (in.direction == ata_cmd_in::no_data) {
1518    // Non data command -- but doesn't use large sector
1519    // count register values.
1520    passthru->byte0.sgloff = 0x0;
1521    passthru->size         = 0x5;
1522    passthru->param        = 0x8;
1523    passthru->sector_count = 0x0;
1524  }
1525  else if (in.direction == ata_cmd_in::data_out) {
1526    if (m_escalade_type == AMCC_3WARE_9000_CHAR)
1527      memcpy(tw_ioctl_apache->data_buffer, in.buffer, in.size);
1528    else if (m_escalade_type == AMCC_3WARE_678K_CHAR)
1529      memcpy(tw_ioctl_char->data_buffer,   in.buffer, in.size);
1530    else {
1531      // COMMAND NOT SUPPORTED VIA SCSI IOCTL INTERFACE
1532      // memcpy(tw_output->output_data, data, 512);
1533      // printwarning(command); // TODO: Parameter no longer valid
1534      return set_err(ENOTSUP, "DATA OUT not supported for this 3ware controller type");
1535    }
1536    passthru->byte0.sgloff = 0x5;
1537    passthru->size         = 0x7;  // TODO: Other value for multi-sector ?
1538    passthru->param        = 0xF;  // PIO data write
1539    if (m_escalade_type==AMCC_3WARE_9000_CHAR && sizeof(long)==8)
1540      passthru->size++;
1541  }
1542  else
1543    set_err(EINVAL);
1544
1545  // Now send the command down through an ioctl()
1546  int ioctlreturn;
1547  if (m_escalade_type==AMCC_3WARE_9000_CHAR)
1548    ioctlreturn=ioctl(get_fd(), TW_IOCTL_FIRMWARE_PASS_THROUGH, tw_ioctl_apache);
1549  else if (m_escalade_type==AMCC_3WARE_678K_CHAR)
1550    ioctlreturn=ioctl(get_fd(), TW_CMD_PACKET_WITH_DATA, tw_ioctl_char);
1551  else
1552    ioctlreturn=ioctl(get_fd(), SCSI_IOCTL_SEND_COMMAND, tw_ioctl);
1553
1554  // Deal with the different error cases
1555  if (ioctlreturn) {
1556    if (AMCC_3WARE_678K==m_escalade_type
1557        && in.in_regs.command==ATA_SMART_CMD
1558        && (   in.in_regs.features == ATA_SMART_AUTO_OFFLINE
1559            || in.in_regs.features == ATA_SMART_AUTOSAVE    )
1560        && in.in_regs.lba_low) {
1561      // error here is probably a kernel driver whose version is too old
1562      // printwarning(command); // TODO: Parameter no longer valid
1563      return set_err(ENOTSUP, "Probably kernel driver too old");
1564    }
1565    return set_err(EIO);
1566  }
1567
1568  // The passthru structure is valid after return from an ioctl if:
1569  // - we are using the character interface OR
1570  // - we are using the SCSI interface and this is a NON-READ-DATA command
1571  // For SCSI interface, note that we set passthru to a different
1572  // value after ioctl().
1573  if (AMCC_3WARE_678K==m_escalade_type) {
1574    if (readdata)
1575      passthru=NULL;
1576    else
1577      passthru=(TW_Passthru *)&(tw_output->output_data);
1578  }
1579
1580  // See if the ATA command failed.  Now that we have returned from
1581  // the ioctl() call, if passthru is valid, then:
1582  // - passthru->status contains the 3ware controller STATUS
1583  // - passthru->command contains the ATA STATUS register
1584  // - passthru->features contains the ATA ERROR register
1585  //
1586  // Check bits 0 (error bit) and 5 (device fault) of the ATA STATUS
1587  // If bit 0 (error bit) is set, then ATA ERROR register is valid.
1588  // While we *might* decode the ATA ERROR register, at the moment it
1589  // doesn't make much sense: we don't care in detail why the error
1590  // happened.
1591
1592  if (passthru && (passthru->status || (passthru->command & 0x21))) {
1593    return set_err(EIO);
1594  }
1595
1596  // If this is a read data command, copy data to output buffer
1597  if (readdata) {
1598    if (m_escalade_type==AMCC_3WARE_9000_CHAR)
1599      memcpy(in.buffer, tw_ioctl_apache->data_buffer, in.size);
1600    else if (m_escalade_type==AMCC_3WARE_678K_CHAR)
1601      memcpy(in.buffer, tw_ioctl_char->data_buffer, in.size);
1602    else
1603      memcpy(in.buffer, tw_output->output_data, in.size);
1604  }
1605
1606  // Return register values
1607  {
1608    ata_out_regs_48bit & r = out.out_regs;
1609    r.error           = passthru->features;
1610    r.sector_count_16 = passthru->sector_count;
1611    r.lba_low_16      = passthru->sector_num;
1612    r.lba_mid_16      = passthru->cylinder_lo;
1613    r.lba_high_16     = passthru->cylinder_hi;
1614    r.device          = passthru->drive_head;
1615    r.status          = passthru->command;
1616  }
1617
1618  // look for nonexistent devices/ports
1619  if (   in.in_regs.command == ATA_IDENTIFY_DEVICE
1620      && !nonempty((unsigned char *)in.buffer, in.size)) {
1621    return set_err(ENODEV, "No drive on port %d", m_disknum);
1622  }
1623
1624  return true;
1625}
1626
1627
1628/////////////////////////////////////////////////////////////////////////////
1629/// Areca RAID support
1630
1631class linux_areca_device
1632: public /*implements*/ ata_device_with_command_set,
1633  public /*extends*/ linux_smart_device
1634{
1635public:
1636  linux_areca_device(smart_interface * intf, const char * dev_name, int disknum);
1637
1638protected:
1639  virtual int ata_command_interface(smart_command_set command, int select, char * data);
1640
1641private:
1642  int m_disknum; ///< Disk number.
1643};
1644
1645
1646// PURPOSE
1647//   This is an interface routine meant to isolate the OS dependent
1648//   parts of the code, and to provide a debugging interface.  Each
1649//   different port and OS needs to provide it's own interface.  This
1650//   is the linux interface to the Areca "arcmsr" driver.  It allows ATA
1651//   commands to be passed through the SCSI driver.
1652// DETAILED DESCRIPTION OF ARGUMENTS
1653//   fd: is the file descriptor provided by open()
1654//   disknum is the disk number (0 to 15) in the RAID array
1655//   command: defines the different operations.
1656//   select: additional input data if needed (which log, which type of
1657//           self-test).
1658//   data:   location to write output data, if needed (512 bytes).
1659//   Note: not all commands use all arguments.
1660// RETURN VALUES
1661//  -1 if the command failed
1662//   0 if the command succeeded,
1663//   STATUS_CHECK routine:
1664//  -1 if the command failed
1665//   0 if the command succeeded and disk SMART status is "OK"
1666//   1 if the command succeeded and disk SMART status is "FAILING"
1667
1668
1669/*DeviceType*/
1670#define ARECA_SATA_RAID                         0x90000000
1671/*FunctionCode*/
1672#define FUNCTION_READ_RQBUFFER                  0x0801
1673#define FUNCTION_WRITE_WQBUFFER                 0x0802
1674#define FUNCTION_CLEAR_RQBUFFER                 0x0803
1675#define FUNCTION_CLEAR_WQBUFFER                 0x0804
1676
1677/* ARECA IO CONTROL CODE*/
1678#define ARCMSR_IOCTL_READ_RQBUFFER              (ARECA_SATA_RAID | FUNCTION_READ_RQBUFFER)
1679#define ARCMSR_IOCTL_WRITE_WQBUFFER             (ARECA_SATA_RAID | FUNCTION_WRITE_WQBUFFER)
1680#define ARCMSR_IOCTL_CLEAR_RQBUFFER             (ARECA_SATA_RAID | FUNCTION_CLEAR_RQBUFFER)
1681#define ARCMSR_IOCTL_CLEAR_WQBUFFER             (ARECA_SATA_RAID | FUNCTION_CLEAR_WQBUFFER)
1682#define ARECA_SIG_STR                                                   "ARCMSR"
1683
1684// The SRB_IO_CONTROL & SRB_BUFFER structures are used to communicate(to/from) to areca driver
1685typedef struct _SRB_IO_CONTROL
1686{
1687        unsigned int HeaderLength;
1688        unsigned char Signature[8];
1689        unsigned int Timeout;
1690        unsigned int ControlCode;
1691        unsigned int ReturnCode;
1692        unsigned int Length;
1693} sSRB_IO_CONTROL;
1694
1695typedef struct _SRB_BUFFER
1696{
1697        sSRB_IO_CONTROL srbioctl;
1698        unsigned char   ioctldatabuffer[1032]; // the buffer to put the command data to/from firmware
1699} sSRB_BUFFER;
1700
1701// Looks in /proc/scsi to suggest correct areca devices
1702// If hint not NULL, return device path guess
1703int find_areca_in_proc(char *hint) {
1704 
1705    const char* proc_format_string="host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\tonline\n";
1706
1707    // check data formwat
1708    FILE *fp=fopen("/proc/scsi/sg/device_hdr", "r");
1709    if (!fp) {
1710        pout("Unable to open /proc/scsi/sg/device_hdr for reading\n");
1711        return 1;
1712     }
1713
1714     // get line, compare to format
1715     char linebuf[256];
1716     linebuf[255]='\0';
1717     char *out = fgets(linebuf, 256, fp);
1718     fclose(fp);
1719     if (!out) {
1720         pout("Unable to read contents of /proc/scsi/sg/device_hdr\n");
1721         return 2;
1722     }
1723
1724     if (strcmp(linebuf, proc_format_string)) {
1725        // wrong format!
1726        // Fix this by comparing only tokens not white space!!
1727        pout("Unexpected format %s in /proc/scsi/sg/device_hdr\n", proc_format_string);
1728        return 3;
1729     }
1730
1731    // Format is understood, now search for correct device
1732    fp=fopen("/proc/scsi/sg/devices", "r");
1733    if (!fp) return 1;
1734    int host, chan, id, lun, type, opens, qdepth, busy, online;
1735    int dev=-1;
1736    int found=0;
1737    // search all lines of /proc/scsi/sg/devices
1738    while (9 == fscanf(fp, "%d %d %d %d %d %d %d %d %d", &host, &chan, &id, &lun, &type, &opens, &qdepth, &busy, &online)) {
1739        dev++;
1740        if (id == 16 && type == 3) {
1741           // devices with id=16 and type=3 might be Areca controllers
1742           if (!found && hint) {
1743               sprintf(hint, "/dev/sg%d", dev);
1744           }
1745           pout("Device /dev/sg%d appears to be an Areca controller.\n", dev);
1746           found++;
1747        }
1748    }
1749    fclose(fp);
1750    return 0;
1751}
1752
1753
1754
1755void dumpdata( unsigned char *block, int len)
1756{
1757        int ln = (len / 16) + 1;         // total line#
1758        unsigned char c;
1759        int pos = 0;
1760
1761        printf(" Address = %p, Length = (0x%x)%d\n", block, len, len);
1762        printf("      0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F      ASCII      \n");
1763        printf("=====================================================================\n");
1764
1765        for ( int l = 0; l < ln && len; l++ )
1766        {
1767                // printf the line# and the HEX data
1768                // if a line data length < 16 then append the space to the tail of line to reach 16 chars
1769                printf("%02X | ", l);
1770                for ( pos = 0; pos < 16 && len; pos++, len-- )
1771                {
1772                        c = block[l*16+pos];   
1773                        printf("%02X ", c);
1774                }
1775
1776                if ( pos < 16 )
1777                {
1778                        for ( int loop = pos; loop < 16; loop++ )
1779                        {
1780                                printf("   ");
1781                        }
1782                }
1783
1784                // print ASCII char
1785                for ( int loop = 0; loop < pos; loop++ )
1786                {
1787                        c = block[l*16+loop];
1788                        if ( c >= 0x20 && c <= 0x7F )
1789                        {
1790                                printf("%c", c);
1791                        }
1792                        else
1793                        {
1794                                printf(".");
1795                        }
1796                }
1797                printf("\n");
1798        }   
1799        printf("=====================================================================\n");
1800}
1801
1802
1803
1804int arcmsr_command_handler(int fd, unsigned long arcmsr_cmd, unsigned char *data, int data_len, void *ext_data /* reserved for further use */)
1805{
1806        ARGUSED(ext_data);
1807
1808        int ioctlreturn = 0;
1809        sSRB_BUFFER sBuf;
1810        struct scsi_cmnd_io io_hdr; 
1811        int dir = DXFER_TO_DEVICE;
1812
1813        UINT8 cdb[10];
1814        UINT8 sense[32];
1815
1816        unsigned char *areca_return_packet;
1817        int total = 0;
1818        int expected = -1;
1819        unsigned char return_buff[2048];
1820        unsigned char *ptr = &return_buff[0];
1821        memset(return_buff, 0, sizeof(return_buff));
1822
1823        memset((unsigned char *)&sBuf, 0, sizeof(sBuf));
1824        memset(&io_hdr, 0, sizeof(io_hdr));
1825        memset(cdb, 0, sizeof(cdb));
1826        memset(sense, 0, sizeof(sense));
1827
1828
1829        sBuf.srbioctl.HeaderLength = sizeof(sSRB_IO_CONTROL);   
1830        memcpy(sBuf.srbioctl.Signature, ARECA_SIG_STR, strlen(ARECA_SIG_STR));
1831        sBuf.srbioctl.Timeout = 10000;     
1832        sBuf.srbioctl.ControlCode = ARCMSR_IOCTL_READ_RQBUFFER;
1833
1834        switch ( arcmsr_cmd )
1835        {
1836        // command for writing data to driver
1837        case ARCMSR_IOCTL_WRITE_WQBUFFER:   
1838                if ( data && data_len )
1839                {
1840                        sBuf.srbioctl.Length = data_len;   
1841                        memcpy((unsigned char *)sBuf.ioctldatabuffer, (unsigned char *)data, data_len);
1842                }
1843                // commands for clearing related buffer of driver
1844        case ARCMSR_IOCTL_CLEAR_RQBUFFER:
1845        case ARCMSR_IOCTL_CLEAR_WQBUFFER:
1846                cdb[0] = 0x3B; //SCSI_WRITE_BUF command;
1847                break;
1848                // command for reading data from driver
1849        case ARCMSR_IOCTL_READ_RQBUFFER:   
1850                cdb[0] = 0x3C; //SCSI_READ_BUF command;
1851                dir = DXFER_FROM_DEVICE;
1852                break;
1853        default:
1854                // unknown arcmsr commands
1855                return -1;
1856        }
1857
1858        cdb[1] = 0x01;
1859        cdb[2] = 0xf0;   
1860        //
1861        // cdb[5][6][7][8] areca defined command code( to/from driver )
1862        //   
1863        cdb[5] = (char)( arcmsr_cmd >> 24);
1864        cdb[6] = (char)( arcmsr_cmd >> 16);
1865        cdb[7] = (char)( arcmsr_cmd >> 8);
1866        cdb[8] = (char)( arcmsr_cmd & 0x0F );
1867
1868        io_hdr.dxfer_dir = dir;
1869        io_hdr.dxfer_len = sizeof(sBuf);
1870        io_hdr.dxferp = (unsigned char *)&sBuf; 
1871        io_hdr.cmnd = cdb;
1872        io_hdr.cmnd_len = sizeof(cdb);
1873        io_hdr.sensep = sense; 
1874        io_hdr.max_sense_len = sizeof(sense);
1875        io_hdr.timeout = SCSI_TIMEOUT_DEFAULT;
1876
1877        while ( 1 )
1878        {
1879                ioctlreturn = do_normal_scsi_cmnd_io(fd, &io_hdr, 0);
1880                if ( ioctlreturn || io_hdr.scsi_status )
1881                {
1882                        // errors found
1883                        break;
1884                }
1885
1886                if ( arcmsr_cmd != ARCMSR_IOCTL_READ_RQBUFFER )
1887                {
1888                        // if succeeded, just returns the length of outgoing data
1889                        return data_len;
1890                }
1891
1892                if ( sBuf.srbioctl.Length )
1893                {
1894                        //dumpdata(&sBuf.ioctldatabuffer[0], sBuf.srbioctl.Length);
1895                        memcpy(ptr, &sBuf.ioctldatabuffer[0], sBuf.srbioctl.Length);
1896                        ptr += sBuf.srbioctl.Length;
1897                        total += sBuf.srbioctl.Length;
1898                        // the returned bytes enough to compute payload length ?
1899                        if ( expected < 0 && total >= 5 )
1900                        {
1901                                areca_return_packet = (unsigned char *)&return_buff[0];
1902                                if ( areca_return_packet[0] == 0x5E && 
1903                                         areca_return_packet[1] == 0x01 && 
1904                                         areca_return_packet[2] == 0x61 )
1905                                {
1906                                        // valid header, let's compute the returned payload length,
1907                                        // we expected the total length is
1908                                        // payload + 3 bytes header + 2 bytes length + 1 byte checksum
1909                                        expected = areca_return_packet[4] * 256 + areca_return_packet[3] + 6;
1910                                }
1911                        }
1912
1913                        if ( total >= 7 && total >= expected )
1914                        {
1915                                //printf("total bytes received = %d, expected length = %d\n", total, expected);
1916
1917                                // ------ Okay! we received enough --------
1918                                break;
1919                        }
1920                }
1921        }
1922
1923        // Deal with the different error cases
1924        if ( ioctlreturn )
1925        {
1926                printf("do_scsi_cmnd_io with write buffer failed code = %x\n", ioctlreturn);
1927                return -2;
1928        }
1929
1930
1931        if ( io_hdr.scsi_status )
1932        {
1933                printf("io_hdr.scsi_status with write buffer failed code = %x\n", io_hdr.scsi_status);
1934                return -3;
1935        }
1936
1937
1938        if ( data )
1939        {
1940                memcpy(data, return_buff, total);
1941        }
1942
1943        return total;
1944}
1945
1946
1947linux_areca_device::linux_areca_device(smart_interface * intf, const char * dev_name, int disknum)
1948: smart_device(intf, dev_name, "areca", "areca"),
1949  linux_smart_device(O_RDWR | O_EXCL | O_NONBLOCK),
1950  m_disknum(disknum)
1951{
1952  set_info().info_name = strprintf("%s [areca_%02d]", dev_name, disknum);
1953}
1954
1955// Areca RAID Controller
1956int linux_areca_device::ata_command_interface(smart_command_set command, int select, char * data)
1957{
1958        // ATA input registers
1959        typedef struct _ATA_INPUT_REGISTERS
1960        {
1961                unsigned char features;
1962                unsigned char sector_count;
1963                unsigned char sector_number;
1964                unsigned char cylinder_low; 
1965                unsigned char cylinder_high;   
1966                unsigned char device_head; 
1967                unsigned char command;     
1968                unsigned char reserved[8];
1969                unsigned char data[512]; // [in/out] buffer for outgoing/incoming data
1970        } sATA_INPUT_REGISTERS;
1971
1972        // ATA output registers
1973        // Note: The output registers is re-sorted for areca internal use only
1974        typedef struct _ATA_OUTPUT_REGISTERS
1975        {
1976                unsigned char error;
1977                unsigned char status;
1978                unsigned char sector_count;
1979                unsigned char sector_number;
1980                unsigned char cylinder_low; 
1981                unsigned char cylinder_high;
1982        }sATA_OUTPUT_REGISTERS;
1983
1984        // Areca packet format for outgoing:
1985        // B[0~2] : 3 bytes header, fixed value 0x5E, 0x01, 0x61
1986        // B[3~4] : 2 bytes command length + variant data length, little endian
1987        // B[5]   : 1 bytes areca defined command code, ATA passthrough command code is 0x1c
1988        // B[6~last-1] : variant bytes payload data
1989        // B[last] : 1 byte checksum, simply sum(B[3] ~ B[last -1])
1990        //
1991        //
1992        //   header 3 bytes  length 2 bytes   cmd 1 byte    payload data x bytes  cs 1 byte
1993        // +--------------------------------------------------------------------------------+
1994        // + 0x5E 0x01 0x61 |   0x00 0x00   |     0x1c   | .................... |   0x00    |
1995        // +--------------------------------------------------------------------------------+
1996        //
1997
1998        //Areca packet format for incoming:
1999        // B[0~2] : 3 bytes header, fixed value 0x5E, 0x01, 0x61
2000        // B[3~4] : 2 bytes payload length, little endian
2001        // B[5~last-1] : variant bytes returned payload data
2002        // B[last] : 1 byte checksum, simply sum(B[3] ~ B[last -1])
2003        //
2004        //
2005        //   header 3 bytes  length 2 bytes   payload data x bytes  cs 1 byte
2006        // +-------------------------------------------------------------------+
2007        // + 0x5E 0x01 0x61 |   0x00 0x00   | .................... |   0x00    |
2008        // +-------------------------------------------------------------------+
2009        unsigned char    areca_packet[640];
2010        int areca_packet_len = sizeof(areca_packet);
2011        unsigned char cs = 0;   
2012
2013        sATA_INPUT_REGISTERS *ata_cmd;
2014
2015        // For debugging
2016#if 0
2017        memset(sInq, 0, sizeof(sInq));
2018        scsiStdInquiry(fd, (unsigned char *)sInq, (int)sizeof(sInq));
2019        dumpdata((unsigned char *)sInq, sizeof(sInq));
2020#endif
2021        memset(areca_packet, 0, areca_packet_len);
2022
2023        // ----- BEGIN TO SETUP HEADERS -------
2024        areca_packet[0] = 0x5E;
2025        areca_packet[1] = 0x01;
2026        areca_packet[2] = 0x61;
2027        areca_packet[3] = (unsigned char)((areca_packet_len - 6) & 0xff);
2028        areca_packet[4] = (unsigned char)(((areca_packet_len - 6) >> 8) & 0xff);
2029        areca_packet[5] = 0x1c; // areca defined code for ATA passthrough command
2030
2031
2032        // ----- BEGIN TO SETUP PAYLOAD DATA -----
2033
2034        memcpy(&areca_packet[7], "SmrT", 4);    // areca defined password
2035
2036        ata_cmd = (sATA_INPUT_REGISTERS *)&areca_packet[12];
2037        ata_cmd->cylinder_low    = 0x4F;
2038        ata_cmd->cylinder_high   = 0xC2;
2039
2040
2041        if ( command == READ_VALUES     ||
2042                 command == READ_THRESHOLDS ||
2043                 command == READ_LOG ||
2044                 command == IDENTIFY ||
2045                 command == PIDENTIFY )
2046        {
2047                // the commands will return data
2048                areca_packet[6] = 0x13;
2049                ata_cmd->sector_count = 0x1;
2050        }
2051        else if ( command == WRITE_LOG )
2052        {
2053                // the commands will write data
2054                areca_packet[6] = 0x14;
2055        }
2056        else
2057        {
2058                // the commands will return no data
2059                areca_packet[6] = 0x15;
2060        }
2061
2062
2063        ata_cmd->command = ATA_SMART_CMD;
2064        // Now set ATA registers depending upon command
2065        switch ( command )
2066        {
2067        case CHECK_POWER_MODE: 
2068                //printf("command = CHECK_POWER_MODE\n");
2069                ata_cmd->command = ATA_CHECK_POWER_MODE;       
2070                break;
2071        case READ_VALUES:
2072                //printf("command = READ_VALUES\n");
2073                ata_cmd->features = ATA_SMART_READ_VALUES;
2074                break;
2075        case READ_THRESHOLDS:   
2076                //printf("command = READ_THRESHOLDS\n");
2077                ata_cmd->features = ATA_SMART_READ_THRESHOLDS;
2078                break;
2079        case READ_LOG: 
2080                //printf("command = READ_LOG\n");
2081                ata_cmd->features = ATA_SMART_READ_LOG_SECTOR;
2082                ata_cmd->sector_number = select;       
2083                break;
2084        case WRITE_LOG:       
2085                //printf("command = WRITE_LOG\n");   
2086                ata_cmd->features = ATA_SMART_WRITE_LOG_SECTOR;
2087                memcpy(ata_cmd->data, data, 512);
2088                ata_cmd->sector_count = 1;
2089                ata_cmd->sector_number = select;
2090                break;
2091        case IDENTIFY:
2092                //printf("command = IDENTIFY\n");   
2093                ata_cmd->command = ATA_IDENTIFY_DEVICE;         
2094                break;
2095        case PIDENTIFY:
2096                //printf("command = PIDENTIFY\n");
2097                errno=ENODEV;
2098                return -1;
2099        case ENABLE:
2100                //printf("command = ENABLE\n");
2101                ata_cmd->features = ATA_SMART_ENABLE;
2102                break;
2103        case DISABLE:
2104                //printf("command = DISABLE\n");
2105                ata_cmd->features = ATA_SMART_DISABLE;
2106                break;
2107        case AUTO_OFFLINE:
2108                //printf("command = AUTO_OFFLINE\n");
2109                ata_cmd->features = ATA_SMART_AUTO_OFFLINE;
2110                // Enable or disable?
2111                ata_cmd->sector_count = select;
2112                break;
2113        case AUTOSAVE:
2114                //printf("command = AUTOSAVE\n");
2115                ata_cmd->features = ATA_SMART_AUTOSAVE;
2116                // Enable or disable?
2117                ata_cmd->sector_count = select;
2118                break;
2119        case IMMEDIATE_OFFLINE:
2120                //printf("command = IMMEDIATE_OFFLINE\n");
2121                ata_cmd->features = ATA_SMART_IMMEDIATE_OFFLINE;
2122                // What test type to run?
2123                ata_cmd->sector_number = select;
2124                break;
2125        case STATUS_CHECK:
2126                //printf("command = STATUS_CHECK\n");
2127                ata_cmd->features = ATA_SMART_STATUS;           
2128                break;
2129        case STATUS:
2130                //printf("command = STATUS\n");
2131                ata_cmd->features = ATA_SMART_STATUS;       
2132                break;
2133        default:
2134                //printf("command = UNKNOWN\n");
2135                errno=ENOSYS;
2136                return -1;
2137        };
2138
2139        areca_packet[11] = m_disknum - 1;                  // drive number
2140
2141        // ----- BEGIN TO SETUP CHECKSUM -----
2142        for ( int loop = 3; loop < areca_packet_len - 1; loop++ )
2143        {
2144                cs += areca_packet[loop]; 
2145        }
2146        areca_packet[areca_packet_len-1] = cs;
2147
2148        // ----- BEGIN TO SEND TO ARECA DRIVER ------
2149        int expected = 0;       
2150        unsigned char return_buff[2048];
2151        memset(return_buff, 0, sizeof(return_buff));
2152
2153        expected = arcmsr_command_handler(get_fd(), ARCMSR_IOCTL_CLEAR_RQBUFFER, NULL, 0, NULL);
2154        if (expected==-3) {
2155            find_areca_in_proc(NULL);
2156            return -1;
2157        }
2158
2159        expected = arcmsr_command_handler(get_fd(), ARCMSR_IOCTL_CLEAR_WQBUFFER, NULL, 0, NULL);
2160        expected = arcmsr_command_handler(get_fd(), ARCMSR_IOCTL_WRITE_WQBUFFER, areca_packet, areca_packet_len, NULL);
2161        if ( expected > 0 )
2162        {
2163                expected = arcmsr_command_handler(get_fd(), ARCMSR_IOCTL_READ_RQBUFFER, return_buff, sizeof(return_buff), NULL);
2164        }
2165        if ( expected < 0 )
2166        {
2167                return -1;
2168        }
2169
2170        // ----- VERIFY THE CHECKSUM -----
2171        cs = 0;
2172        for ( int loop = 3; loop < expected - 1; loop++ )
2173        {
2174                cs += return_buff[loop]; 
2175        }
2176
2177        if ( return_buff[expected - 1] != cs )
2178        {
2179                errno = EIO;
2180                return -1;
2181        }
2182
2183        sATA_OUTPUT_REGISTERS *ata_out = (sATA_OUTPUT_REGISTERS *)&return_buff[5] ;
2184        if ( ata_out->status )
2185        {
2186                if ( command == IDENTIFY )
2187                {
2188                        pout("The firmware of your Areca RAID controller appears to be outdated!\n" \
2189                                 "Please update your controller to firmware version 1.46 or later.\n" \
2190                                 "You may download it here: ftp://ftp.areca.com.tw/RaidCards/BIOS_Firmware\n\n");
2191                }
2192                errno = EIO;
2193                return -1;
2194        }
2195
2196        // returns with data
2197        if ( command == READ_VALUES     ||
2198                 command == READ_THRESHOLDS ||
2199                 command == READ_LOG ||
2200                 command == IDENTIFY ||
2201                 command == PIDENTIFY )
2202        {
2203                memcpy(data, &return_buff[7], 512); 
2204        }
2205
2206        if ( command == CHECK_POWER_MODE )
2207        {
2208                data[0] = ata_out->sector_count;
2209        }
2210
2211        if ( command == STATUS_CHECK &&
2212                 ( ata_out->cylinder_low == 0xF4 && ata_out->cylinder_high == 0x2C ) )
2213        {
2214                return 1;
2215        }
2216
2217        return 0;
2218}
2219
2220
2221/////////////////////////////////////////////////////////////////////////////
2222/// Marvell support
2223
2224class linux_marvell_device
2225: public /*implements*/ ata_device_with_command_set,
2226  public /*extends*/ linux_smart_device
2227{
2228public:
2229  linux_marvell_device(smart_interface * intf, const char * dev_name, const char * req_type);
2230
2231protected:
2232  virtual int ata_command_interface(smart_command_set command, int select, char * data);
2233};
2234
2235linux_marvell_device::linux_marvell_device(smart_interface * intf,
2236  const char * dev_name, const char * req_type)
2237: smart_device(intf, dev_name, "marvell", req_type),
2238  linux_smart_device(O_RDONLY | O_NONBLOCK)
2239{
2240}
2241
2242int linux_marvell_device::ata_command_interface(smart_command_set command, int select, char * data)
2243{
2244  typedef struct {
2245    int  inlen;
2246    int  outlen;
2247    char cmd[540];
2248  } mvsata_scsi_cmd;
2249
2250  int copydata = 0;
2251  mvsata_scsi_cmd  smart_command;
2252  unsigned char *buff = (unsigned char *)&smart_command.cmd[6];
2253  // See struct hd_drive_cmd_hdr in hdreg.h
2254  // buff[0]: ATA COMMAND CODE REGISTER
2255  // buff[1]: ATA SECTOR NUMBER REGISTER
2256  // buff[2]: ATA FEATURES REGISTER
2257  // buff[3]: ATA SECTOR COUNT REGISTER
2258
2259  // clear out buff.  Large enough for HDIO_DRIVE_CMD (4+512 bytes)
2260  memset(&smart_command, 0, sizeof(smart_command));
2261  smart_command.inlen = 540;
2262  smart_command.outlen = 540;
2263  smart_command.cmd[0] = 0xC;  //Vendor-specific code
2264  smart_command.cmd[4] = 6;     //command length
2265
2266  buff[0] = ATA_SMART_CMD;
2267  switch (command){
2268  case CHECK_POWER_MODE:
2269    buff[0]=ATA_CHECK_POWER_MODE;
2270    break;
2271  case READ_VALUES:
2272    buff[2]=ATA_SMART_READ_VALUES;
2273    copydata=buff[3]=1;
2274    break;
2275  case READ_THRESHOLDS:
2276    buff[2]=ATA_SMART_READ_THRESHOLDS;
2277    copydata=buff[1]=buff[3]=1;
2278    break;
2279  case READ_LOG:
2280    buff[2]=ATA_SMART_READ_LOG_SECTOR;
2281    buff[1]=select;
2282    copydata=buff[3]=1;
2283    break;
2284  case IDENTIFY:
2285    buff[0]=ATA_IDENTIFY_DEVICE;
2286    copydata=buff[3]=1;
2287    break;
2288  case PIDENTIFY:
2289    buff[0]=ATA_IDENTIFY_PACKET_DEVICE;
2290    copydata=buff[3]=1;
2291    break;
2292  case ENABLE:
2293    buff[2]=ATA_SMART_ENABLE;
2294    buff[1]=1;
2295    break;
2296  case DISABLE:
2297    buff[2]=ATA_SMART_DISABLE;
2298    buff[1]=1;
2299    break;
2300  case STATUS:
2301  case STATUS_CHECK:
2302    // this command only says if SMART is working.  It could be
2303    // replaced with STATUS_CHECK below.
2304    buff[2] = ATA_SMART_STATUS;
2305    break;
2306  case AUTO_OFFLINE:
2307    buff[2]=ATA_SMART_AUTO_OFFLINE;
2308    buff[3]=select;   // YET NOTE - THIS IS A NON-DATA COMMAND!!
2309    break;
2310  case AUTOSAVE:
2311    buff[2]=ATA_SMART_AUTOSAVE;
2312    buff[3]=select;   // YET NOTE - THIS IS A NON-DATA COMMAND!!
2313    break;
2314  case IMMEDIATE_OFFLINE:
2315    buff[2]=ATA_SMART_IMMEDIATE_OFFLINE;
2316    buff[1]=select;
2317    break;
2318  default:
2319    pout("Unrecognized command %d in mvsata_os_specific_handler()\n", command);
2320    EXIT(1);
2321    break;
2322  }
2323  // There are two different types of ioctls().  The HDIO_DRIVE_TASK
2324  // one is this:
2325  // We are now doing the HDIO_DRIVE_CMD type ioctl.
2326  if (ioctl(get_fd(), SCSI_IOCTL_SEND_COMMAND, (void *)&smart_command))
2327      return -1;
2328
2329  if (command==CHECK_POWER_MODE) {
2330    // LEON -- CHECK THIS PLEASE.  THIS SHOULD BE THE SECTOR COUNT
2331    // REGISTER, AND IT MIGHT BE buff[2] NOT buff[3].  Bruce
2332    data[0]=buff[3];
2333    return 0;
2334  }
2335
2336  // Always succeed on a SMART status, as a disk that failed returned
2337  // buff[4]=0xF4, buff[5]=0x2C, i.e. "Bad SMART status" (see below).
2338  if (command == STATUS)
2339    return 0;
2340  //Data returned is starting from 0 offset
2341  if (command == STATUS_CHECK)
2342  {
2343    // Cyl low and Cyl high unchanged means "Good SMART status"
2344    if (buff[4] == 0x4F && buff[5] == 0xC2)
2345      return 0;
2346    // These values mean "Bad SMART status"
2347    if (buff[4] == 0xF4 && buff[5] == 0x2C)
2348      return 1;
2349    // We haven't gotten output that makes sense; print out some debugging info
2350    syserror("Error SMART Status command failed");
2351    pout("Please get assistance from %s\n",PACKAGE_BUGREPORT);
2352    pout("Register values returned from SMART Status command are:\n");
2353    pout("CMD =0x%02x\n",(int)buff[0]);
2354    pout("FR =0x%02x\n",(int)buff[1]);
2355    pout("NS =0x%02x\n",(int)buff[2]);
2356    pout("SC =0x%02x\n",(int)buff[3]);
2357    pout("CL =0x%02x\n",(int)buff[4]);
2358    pout("CH =0x%02x\n",(int)buff[5]);
2359    pout("SEL=0x%02x\n",(int)buff[6]);
2360    return -1;
2361  }
2362
2363  if (copydata)
2364    memcpy(data, buff, 512);
2365  return 0;
2366}
2367
2368
2369/////////////////////////////////////////////////////////////////////////////
2370/// Highpoint RAID support
2371
2372class linux_highpoint_device
2373: public /*implements*/ ata_device_with_command_set,
2374  public /*extends*/ linux_smart_device
2375{
2376public:
2377  linux_highpoint_device(smart_interface * intf, const char * dev_name,
2378    unsigned char controller, unsigned char channel, unsigned char port);
2379
2380protected:
2381  virtual int ata_command_interface(smart_command_set command, int select, char * data);
2382
2383private:
2384  unsigned char m_hpt_data[3]; ///< controller/channel/port
2385};
2386
2387linux_highpoint_device::linux_highpoint_device(smart_interface * intf, const char * dev_name,
2388  unsigned char controller, unsigned char channel, unsigned char port)
2389: smart_device(intf, dev_name, "hpt", "hpt"),
2390  linux_smart_device(O_RDONLY | O_NONBLOCK)
2391{
2392  m_hpt_data[0] = controller; m_hpt_data[1] = channel; m_hpt_data[2] = port;
2393  set_info().info_name = strprintf("%s [hpt_disk_%u/%u/%u]", dev_name, m_hpt_data[0], m_hpt_data[1], m_hpt_data[2]);
2394}
2395
2396// this implementation is derived from ata_command_interface with a header
2397// packing for highpoint linux driver ioctl interface
2398//
2399// ioctl(fd,HPTIO_CTL,buff)
2400//          ^^^^^^^^^
2401//
2402// structure of hpt_buff
2403// +----+----+----+----+--------------------.....---------------------+
2404// | 1  | 2  | 3  | 4  | 5                                            |
2405// +----+----+----+----+--------------------.....---------------------+
2406//
2407// 1: The target controller                     [ int    ( 4 Bytes ) ]
2408// 2: The channel of the target controllee      [ int    ( 4 Bytes ) ]
2409// 3: HDIO_ ioctl call                          [ int    ( 4 Bytes ) ]
2410//    available from ${LINUX_KERNEL_SOURCE}/Documentation/ioctl/hdio
2411// 4: the pmport that disk attached,            [ int    ( 4 Bytes ) ]
2412//    if no pmport device, set to 1 or leave blank
2413// 5: data                                      [ void * ( var leangth ) ]
2414//
2415#define STRANGE_BUFFER_LENGTH (4+512*0xf8)
2416
2417int linux_highpoint_device::ata_command_interface(smart_command_set command, int select, char * data)
2418{
2419  unsigned char hpt_buff[4*sizeof(int) + STRANGE_BUFFER_LENGTH];
2420  unsigned int *hpt = (unsigned int *)hpt_buff;
2421  unsigned char *buff = &hpt_buff[4*sizeof(int)];
2422  int copydata = 0;
2423  const int HDIO_DRIVE_CMD_OFFSET = 4;
2424
2425  memset(hpt_buff, 0, 4*sizeof(int) + STRANGE_BUFFER_LENGTH);
2426  hpt[0] = m_hpt_data[0]; // controller id
2427  hpt[1] = m_hpt_data[1]; // channel number
2428  hpt[3] = m_hpt_data[2]; // pmport number
2429
2430  buff[0]=ATA_SMART_CMD;
2431  switch (command){
2432  case CHECK_POWER_MODE:
2433    buff[0]=ATA_CHECK_POWER_MODE;
2434    copydata=1;
2435    break;
2436  case READ_VALUES:
2437    buff[2]=ATA_SMART_READ_VALUES;
2438    buff[3]=1;
2439    copydata=512;
2440    break;
2441  case READ_THRESHOLDS:
2442    buff[2]=ATA_SMART_READ_THRESHOLDS;
2443    buff[1]=buff[3]=1;
2444    copydata=512;
2445    break;
2446  case READ_LOG:
2447    buff[2]=ATA_SMART_READ_LOG_SECTOR;
2448    buff[1]=select;
2449    buff[3]=1;
2450    copydata=512;
2451    break;
2452  case WRITE_LOG:
2453    break;
2454  case IDENTIFY:
2455    buff[0]=ATA_IDENTIFY_DEVICE;
2456    buff[3]=1;
2457    copydata=512;
2458    break;
2459  case PIDENTIFY:
2460    buff[0]=ATA_IDENTIFY_PACKET_DEVICE;
2461    buff[3]=1;
2462    copydata=512;
2463    break;
2464  case ENABLE:
2465    buff[2]=ATA_SMART_ENABLE;
2466    buff[1]=1;
2467    break;
2468  case DISABLE:
2469    buff[2]=ATA_SMART_DISABLE;
2470    buff[1]=1;
2471    break;
2472  case STATUS:
2473    buff[2]=ATA_SMART_STATUS;
2474    break;
2475  case AUTO_OFFLINE:
2476    buff[2]=ATA_SMART_AUTO_OFFLINE;
2477    buff[3]=select;
2478    break;
2479  case AUTOSAVE:
2480    buff[2]=ATA_SMART_AUTOSAVE;
2481    buff[3]=select;
2482    break;
2483  case IMMEDIATE_OFFLINE:
2484    buff[2]=ATA_SMART_IMMEDIATE_OFFLINE;
2485    buff[1]=select;
2486    break;
2487  case STATUS_CHECK:
2488    buff[1]=ATA_SMART_STATUS;
2489    break;
2490  default:
2491    pout("Unrecognized command %d in linux_highpoint_command_interface()\n"
2492         "Please contact " PACKAGE_BUGREPORT "\n", command);
2493    errno=ENOSYS;
2494    return -1;
2495  }
2496
2497  if (command==WRITE_LOG) {
2498    unsigned char task[4*sizeof(int)+sizeof(ide_task_request_t)+512];
2499    unsigned int *hpt = (unsigned int *)task;
2500    ide_task_request_t *reqtask = (ide_task_request_t *)(&task[4*sizeof(int)]);
2501    task_struct_t *taskfile = (task_struct_t *)reqtask->io_ports;
2502    int retval;
2503
2504    memset(task, 0, sizeof(task));
2505
2506    hpt[0] = m_hpt_data[0]; // controller id
2507    hpt[1] = m_hpt_data[1]; // channel number
2508    hpt[3] = m_hpt_data[2]; // pmport number
2509    hpt[2] = HDIO_DRIVE_TASKFILE; // real hd ioctl
2510
2511    taskfile->data           = 0;
2512    taskfile->feature        = ATA_SMART_WRITE_LOG_SECTOR;
2513    taskfile->sector_count   = 1;
2514    taskfile->sector_number  = select;
2515    taskfile->low_cylinder   = 0x4f;
2516    taskfile->high_cylinder  = 0xc2;
2517    taskfile->device_head    = 0;
2518    taskfile->command        = ATA_SMART_CMD;
2519
2520    reqtask->data_phase      = TASKFILE_OUT;
2521    reqtask->req_cmd         = IDE_DRIVE_TASK_OUT;
2522    reqtask->out_size        = 512;
2523    reqtask->in_size         = 0;
2524
2525    memcpy(task+sizeof(ide_task_request_t)+4*sizeof(int), data, 512);
2526
2527    if ((retval=ioctl(get_fd(), HPTIO_CTL, task))) {
2528      if (retval==-EINVAL)
2529        pout("Kernel lacks HDIO_DRIVE_TASKFILE support; compile kernel with CONFIG_IDE_TASKFILE_IO set\n");
2530      return -1;
2531    }
2532    return 0;
2533  }
2534
2535  if (command==STATUS_CHECK){
2536    int retval;
2537    unsigned const char normal_lo=0x4f, normal_hi=0xc2;
2538    unsigned const char failed_lo=0xf4, failed_hi=0x2c;
2539    buff[4]=normal_lo;
2540    buff[5]=normal_hi;
2541
2542    hpt[2] = HDIO_DRIVE_TASK;
2543
2544    if ((retval=ioctl(get_fd(), HPTIO_CTL, hpt_buff))) {
2545      if (retval==-EINVAL) {
2546        pout("Error SMART Status command via HDIO_DRIVE_TASK failed");
2547        pout("Rebuild older linux 2.2 kernels with HDIO_DRIVE_TASK support added\n");
2548      }
2549      else
2550        syserror("Error SMART Status command failed");
2551      return -1;
2552    }
2553
2554    if (buff[4]==normal_lo && buff[5]==normal_hi)
2555      return 0;
2556
2557    if (buff[4]==failed_lo && buff[5]==failed_hi)
2558      return 1;
2559
2560    syserror("Error SMART Status command failed");
2561    pout("Please get assistance from " PACKAGE_HOMEPAGE "\n");
2562    pout("Register values returned from SMART Status command are:\n");
2563    pout("CMD=0x%02x\n",(int)buff[0]);
2564    pout("FR =0x%02x\n",(int)buff[1]);
2565    pout("NS =0x%02x\n",(int)buff[2]);
2566    pout("SC =0x%02x\n",(int)buff[3]);
2567    pout("CL =0x%02x\n",(int)buff[4]);
2568    pout("CH =0x%02x\n",(int)buff[5]);
2569    pout("SEL=0x%02x\n",(int)buff[6]);
2570    return -1;
2571  }
2572
2573#if 1
2574  if (command==IDENTIFY || command==PIDENTIFY) {
2575    unsigned char deviceid[4*sizeof(int)+512*sizeof(char)];
2576    unsigned int *hpt = (unsigned int *)deviceid;
2577
2578    hpt[0] = m_hpt_data[0]; // controller id
2579    hpt[1] = m_hpt_data[1]; // channel number
2580    hpt[3] = m_hpt_data[2]; // pmport number
2581
2582    hpt[2] = HDIO_GET_IDENTITY;
2583    if (!ioctl(get_fd(), HPTIO_CTL, deviceid) && (deviceid[4*sizeof(int)] & 0x8000))
2584      buff[0]=(command==IDENTIFY)?ATA_IDENTIFY_PACKET_DEVICE:ATA_IDENTIFY_DEVICE;
2585  }
2586#endif
2587
2588  hpt[2] = HDIO_DRIVE_CMD;
2589  if ((ioctl(get_fd(), HPTIO_CTL, hpt_buff)))
2590    return -1;
2591
2592  if (command==CHECK_POWER_MODE)
2593    buff[HDIO_DRIVE_CMD_OFFSET]=buff[2];
2594
2595  if (copydata)
2596    memcpy(data, buff+HDIO_DRIVE_CMD_OFFSET, copydata);
2597
2598  return 0;
2599}
2600
2601
2602#if 0 // TODO: Migrate from 'smart_command_set' to 'ata_in_regs' OR remove the function
2603// Utility function for printing warnings
2604void printwarning(smart_command_set command){
2605  static int printed[4]={0,0,0,0};
2606  const char* message=
2607    "can not be passed through the 3ware 3w-xxxx driver.  This can be fixed by\n"
2608    "applying a simple 3w-xxxx driver patch that can be found here:\n"
2609    PACKAGE_HOMEPAGE "\n"
2610    "Alternatively, upgrade your 3w-xxxx driver to version 1.02.00.037 or greater.\n\n";
2611
2612  if (command==AUTO_OFFLINE && !printed[0]) {
2613    printed[0]=1;
2614    pout("The SMART AUTO-OFFLINE ENABLE command (smartmontools -o on option/Directive)\n%s", message);
2615  }
2616  else if (command==AUTOSAVE && !printed[1]) {
2617    printed[1]=1;
2618    pout("The SMART AUTOSAVE ENABLE command (smartmontools -S on option/Directive)\n%s", message);
2619  }
2620  else if (command==STATUS_CHECK && !printed[2]) {
2621    printed[2]=1;
2622    pout("The SMART RETURN STATUS return value (smartmontools -H option/Directive)\n%s", message);
2623  }
2624  else if (command==WRITE_LOG && !printed[3])  {
2625    printed[3]=1;
2626    pout("The SMART WRITE LOG command (smartmontools -t selective) only supported via char /dev/tw[ae] interface\n");
2627  }
2628
2629  return;
2630}
2631#endif
2632
2633
2634/////////////////////////////////////////////////////////////////////////////
2635/// SCSI open with autodetection support
2636
2637smart_device * linux_scsi_device::autodetect_open()
2638{
2639  // Open device
2640  if (!open())
2641    return this;
2642
2643  // No Autodetection if device type was specified by user
2644  if (*get_req_type())
2645    return this;
2646
2647  // The code below is based on smartd.cpp:SCSIFilterKnown()
2648
2649  // Get INQUIRY
2650  unsigned char req_buff[64] = {0, };
2651  int req_len = 36;
2652  if (scsiStdInquiry(this, req_buff, req_len)) {
2653    // Marvell controllers fail on a 36 bytes StdInquiry, but 64 suffices
2654    // watch this spot ... other devices could lock up here
2655    req_len = 64;
2656    if (scsiStdInquiry(this, req_buff, req_len)) {
2657      // device doesn't like INQUIRY commands
2658      close();
2659      set_err(EIO, "INQUIRY failed");
2660      return this;
2661    }
2662  }
2663
2664  int avail_len = req_buff[4] + 5;
2665  int len = (avail_len < req_len ? avail_len : req_len);
2666  if (len < 36)
2667      return this;
2668
2669  // Use INQUIRY to detect type
2670  smart_device * newdev = 0;
2671  try {
2672    // 3ware ?
2673    if (!memcmp(req_buff + 8, "3ware", 5) || !memcmp(req_buff + 8, "AMCC", 4)) {
2674      close();
2675      set_err(EINVAL, "AMCC/3ware controller, please try adding '-d 3ware,N',\n"
2676                      "you may need to replace %s with /dev/twaN or /dev/tweN", get_dev_name());
2677      return this;
2678    }
2679
2680    // Marvell ?
2681    if (len >= 42 && !memcmp(req_buff + 36, "MVSATA", 6)) {
2682      //pout("Device %s: using '-d marvell' for ATA disk with Marvell driver\n", get_dev_name());
2683      close();
2684      newdev = new linux_marvell_device(smi(), get_dev_name(), get_req_type());
2685      newdev->open(); // TODO: Can possibly pass open fd
2686      delete this;
2687      return newdev;
2688    }
2689
2690    // SAT or USB ?
2691    newdev = smi()->autodetect_sat_device(this, req_buff, len);
2692    if (newdev)
2693      // NOTE: 'this' is now owned by '*newdev'
2694      return newdev;
2695  }
2696  catch (...) {
2697    // Cleanup if exception occurs after newdev was allocated
2698    delete newdev;
2699    throw;
2700  }
2701
2702  // Nothing special found
2703  return this;
2704}
2705
2706
2707//////////////////////////////////////////////////////////////////////
2708// USB bridge ID detection
2709
2710// Read USB ID from /sys file
2711static bool read_id(const std::string & path, unsigned short & id)
2712{
2713  FILE * f = fopen(path.c_str(), "r");
2714  if (!f)
2715    return false;
2716  int n = -1;
2717  bool ok = (fscanf(f, "%hx%n", &id, &n) == 1 && n == 4);
2718  fclose(f);
2719  return ok;
2720}
2721
2722// Get USB bridge ID for "sdX"
2723static bool get_usb_id(const char * name, unsigned short & vendor_id,
2724                       unsigned short & product_id, unsigned short & version)
2725{
2726  // Only "sdX" supported
2727  if (!(!strncmp(name, "sd", 2) && !strchr(name, '/')))
2728    return false;
2729
2730  // Start search at dir referenced by symlink "/sys/block/sdX/device"
2731  // -> "/sys/devices/.../usb*/.../host*/target*/..."
2732  std::string dir = strprintf("/sys/block/%s/device", name);
2733
2734  // Stop search at "/sys/devices"
2735  struct stat st;
2736  if (stat("/sys/devices", &st))
2737    return false;
2738  ino_t stop_ino = st.st_ino;
2739
2740  // Search in parent directories until "idVendor" is found,
2741  // fail if "/sys/devices" reached or too many iterations
2742  int cnt = 0;
2743  do {
2744    dir += "/..";
2745    if (!(++cnt < 10 && !stat(dir.c_str(), &st) && st.st_ino != stop_ino))
2746      return false;
2747  } while (access((dir + "/idVendor").c_str(), 0));
2748
2749  // Read IDs
2750  if (!(   read_id(dir + "/idVendor", vendor_id)
2751        && read_id(dir + "/idProduct", product_id)
2752        && read_id(dir + "/bcdDevice", version)   ))
2753    return false;
2754
2755  if (con->reportscsiioctl > 1)
2756    pout("USB ID = 0x%04x:0x%04x (0x%03x)\n", vendor_id, product_id, version);
2757  return true;
2758}
2759
2760
2761//////////////////////////////////////////////////////////////////////
2762/// Linux interface
2763
2764class linux_smart_interface
2765: public /*implements*/ smart_interface
2766{
2767public:
2768  virtual std::string get_app_examples(const char * appname);
2769
2770  virtual bool scan_smart_devices(smart_device_list & devlist, const char * type,
2771    const char * pattern = 0);
2772
2773protected:
2774  virtual ata_device * get_ata_device(const char * name, const char * type);
2775
2776  virtual scsi_device * get_scsi_device(const char * name, const char * type);
2777
2778  virtual smart_device * autodetect_smart_device(const char * name);
2779
2780  virtual smart_device * get_custom_smart_device(const char * name, const char * type);
2781
2782  virtual std::string get_valid_custom_dev_types_str();
2783
2784private:
2785  bool get_dev_list(smart_device_list & devlist, const char * pattern,
2786    bool scan_ata, bool scan_scsi, const char * req_type, bool autodetect);
2787
2788  smart_device * missing_option(const char * opt);
2789};
2790
2791std::string linux_smart_interface::get_app_examples(const char * appname)
2792{
2793  if (!strcmp(appname, "smartctl"))
2794    return smartctl_examples;
2795  return "";
2796}
2797
2798
2799// we are going to take advantage of the fact that Linux's devfs will only
2800// have device entries for devices that exist.  So if we get the equivalent of
2801// ls /dev/hd[a-t], we have all the ATA devices on the system
2802bool linux_smart_interface::get_dev_list(smart_device_list & devlist,
2803  const char * pattern, bool scan_ata, bool scan_scsi,
2804  const char * req_type, bool autodetect)
2805{
2806  // Use glob to look for any directory entries matching the pattern
2807  glob_t globbuf;
2808  memset(&globbuf, 0, sizeof(globbuf));
2809  int retglob = glob(pattern, GLOB_ERR, NULL, &globbuf);
2810  if (retglob) {
2811    //  glob failed: free memory and return
2812    globfree(&globbuf);
2813
2814    if (retglob==GLOB_NOMATCH){
2815      pout("glob(3) found no matches for pattern %s\n", pattern);
2816      return true;
2817    }
2818
2819    if (retglob==GLOB_NOSPACE)
2820      set_err(ENOMEM, "glob(3) ran out of memory matching pattern %s", pattern);
2821#ifdef GLOB_ABORTED // missing in old versions of glob.h
2822    else if (retglob==GLOB_ABORTED)
2823      set_err(EINVAL, "glob(3) aborted matching pattern %s", pattern);
2824#endif
2825    else
2826      set_err(EINVAL, "Unexplained error in glob(3) of pattern %s", pattern);
2827
2828    return false;
2829  }
2830
2831  // did we find too many paths?
2832  const int max_pathc = 32;
2833  int n = (int)globbuf.gl_pathc;
2834  if (n > max_pathc) {
2835    pout("glob(3) found %d > MAX=%d devices matching pattern %s: ignoring %d paths\n",
2836         n, max_pathc, pattern, n - max_pathc);
2837    n = max_pathc;
2838  }
2839
2840  // now step through the list returned by glob.  If not a link, copy
2841  // to list.  If it is a link, evaluate it and see if the path ends
2842  // in "disc".
2843  for (int i = 0; i < n; i++){
2844    // see if path is a link
2845    char linkbuf[1024];
2846    int retlink = readlink(globbuf.gl_pathv[i], linkbuf, sizeof(linkbuf)-1);
2847
2848    char tmpname[1024]={0};
2849    const char * name = 0;
2850    bool is_scsi = scan_scsi;
2851    // if not a link (or a strange link), keep it
2852    if (retlink<=0 || retlink>1023)
2853      name = globbuf.gl_pathv[i];
2854    else {
2855      // or if it's a link that points to a disc, follow it
2856      linkbuf[retlink] = 0;
2857      const char *p;
2858      if ((p=strrchr(linkbuf, '/')) && !strcmp(p+1, "disc"))
2859        // This is the branch of the code that gets followed if we are
2860        // using devfs WITH traditional compatibility links. In this
2861        // case, we add the traditional device name to the list that
2862        // is returned.
2863        name = globbuf.gl_pathv[i];
2864      else {
2865        // This is the branch of the code that gets followed if we are
2866        // using devfs WITHOUT traditional compatibility links.  In
2867        // this case, we check that the link to the directory is of
2868        // the correct type, and then append "disc" to it.
2869        bool match_ata  = strstr(linkbuf, "ide");
2870        bool match_scsi = strstr(linkbuf, "scsi");
2871        if (((match_ata && scan_ata) || (match_scsi && scan_scsi)) && !(match_ata && match_scsi)) {
2872          is_scsi = match_scsi;
2873          snprintf(tmpname, sizeof(tmpname), "%s/disc", globbuf.gl_pathv[i]);
2874          name = tmpname;
2875        }
2876      }
2877    }
2878
2879    if (name) {
2880      // Found a name, add device to list.
2881      smart_device * dev;
2882      if (autodetect)
2883        dev = autodetect_smart_device(name);
2884      else if (is_scsi)
2885        dev = new linux_scsi_device(this, name, req_type);
2886      else
2887        dev = new linux_ata_device(this, name, req_type);
2888      if (dev) // autodetect_smart_device() may return nullptr.
2889        devlist.add(dev);
2890    }
2891  }
2892
2893  // free memory
2894  globfree(&globbuf);
2895
2896  return true;
2897}
2898
2899bool linux_smart_interface::scan_smart_devices(smart_device_list & devlist,
2900  const char * type, const char * pattern /*= 0*/)
2901{
2902  if (pattern) {
2903    set_err(EINVAL, "DEVICESCAN with pattern not implemented yet");
2904    return false;
2905  }
2906
2907  if (!type)
2908    type = "";
2909
2910  bool scan_ata  = (!*type || !strcmp(type, "ata" ));
2911  bool scan_scsi = (!*type || !strcmp(type, "scsi"));
2912  if (!(scan_ata || scan_scsi))
2913    return true;
2914
2915  if (scan_ata)
2916    get_dev_list(devlist, "/dev/hd[a-t]", true, false, type, false);
2917  if (scan_scsi) // Try USB autodetection if no type specifed
2918    get_dev_list(devlist, "/dev/sd[a-z]", false, true, type, !*type);
2919
2920  // if we found traditional links, we are done
2921  if (devlist.size() > 0)
2922    return true;
2923
2924  // else look for devfs entries without traditional links
2925  // TODO: Add udev support
2926  return get_dev_list(devlist, "/dev/discs/disc*", scan_ata, scan_scsi, type, false);
2927}
2928
2929ata_device * linux_smart_interface::get_ata_device(const char * name, const char * type)
2930{
2931  return new linux_ata_device(this, name, type);
2932}
2933
2934scsi_device * linux_smart_interface::get_scsi_device(const char * name, const char * type)
2935{
2936  return new linux_scsi_device(this, name, type);
2937}
2938
2939smart_device * linux_smart_interface::missing_option(const char * opt)
2940{
2941  set_err(EINVAL, "requires option '%s'", opt);
2942  return 0;
2943}
2944
2945// Return true if STR starts with PREFIX.
2946static bool str_starts_with(const char * str, const char * prefix)
2947{
2948  return !strncmp(str, prefix, strlen(prefix));
2949}
2950
2951// Guess device type (ata or scsi) based on device name (Linux
2952// specific) SCSI device name in linux can be sd, sr, scd, st, nst,
2953// osst, nosst and sg.
2954static const char * lin_dev_prefix = "/dev/";
2955static const char * lin_dev_ata_disk_plus = "h";
2956static const char * lin_dev_ata_devfs_disk_plus = "ide/";
2957static const char * lin_dev_scsi_devfs_disk_plus = "scsi/";
2958static const char * lin_dev_scsi_disk_plus = "s";
2959static const char * lin_dev_scsi_tape1 = "ns";
2960static const char * lin_dev_scsi_tape2 = "os";
2961static const char * lin_dev_scsi_tape3 = "nos";
2962static const char * lin_dev_3ware_9000_char = "twa";
2963static const char * lin_dev_3ware_678k_char = "twe";
2964static const char * lin_dev_cciss_dir = "cciss/";
2965static const char * lin_dev_areca = "sg";
2966
2967smart_device * linux_smart_interface::autodetect_smart_device(const char * name)
2968{
2969  const char * dev_name = name; // TODO: Remove this hack
2970  int dev_prefix_len = strlen(lin_dev_prefix);
2971
2972  // if dev_name null, or string length zero
2973  int len;
2974  if (!dev_name || !(len = strlen(dev_name)))
2975    return 0;
2976
2977  // Dereference if /dev/disk/by-*/* symlink
2978  char linkbuf[100];
2979  if (   str_starts_with(dev_name, "/dev/disk/by-")
2980      && readlink(dev_name, linkbuf, sizeof(linkbuf)) > 0
2981      && str_starts_with(linkbuf, "../../")) {
2982    dev_name = linkbuf + sizeof("../../")-1;
2983  }
2984  // Remove the leading /dev/... if it's there
2985  else if (!strncmp(lin_dev_prefix, dev_name, dev_prefix_len)) {
2986    if (len <= dev_prefix_len)
2987      // if nothing else in the string, unrecognized
2988      return 0;
2989    // else advance pointer to following characters
2990    dev_name += dev_prefix_len;
2991  }
2992
2993  // form /dev/h* or h*
2994  if (!strncmp(lin_dev_ata_disk_plus, dev_name,
2995               strlen(lin_dev_ata_disk_plus)))
2996    return new linux_ata_device(this, name, "");
2997
2998  // form /dev/ide/* or ide/*
2999  if (!strncmp(lin_dev_ata_devfs_disk_plus, dev_name,
3000               strlen(lin_dev_ata_devfs_disk_plus)))
3001    return new linux_ata_device(this, name, "");
3002
3003  // form /dev/s* or s*
3004  if (!strncmp(lin_dev_scsi_disk_plus, dev_name,
3005               strlen(lin_dev_scsi_disk_plus))) {
3006
3007    // Try to detect possible USB->(S)ATA bridge
3008    unsigned short vendor_id = 0, product_id = 0, version = 0;
3009    if (get_usb_id(dev_name, vendor_id, product_id, version)) {
3010      const char * usbtype = get_usb_dev_type_by_id(vendor_id, product_id, version);
3011      if (!usbtype)
3012        return 0;
3013      // Linux USB layer does not support 16 byte SAT pass through command
3014      if (!strcmp(usbtype, "sat"))
3015        usbtype = "sat,12";
3016      // Return SAT/USB device for this type
3017      // (Note: linux_scsi_device::autodetect_open() will not be called in this case)
3018      return get_sat_device(usbtype, new linux_scsi_device(this, name, ""));
3019    }
3020
3021    // No USB bridge found, assume regular SCSI device
3022    return new linux_scsi_device(this, name, "");
3023  }
3024
3025  // form /dev/scsi/* or scsi/*
3026  if (!strncmp(lin_dev_scsi_devfs_disk_plus, dev_name,
3027               strlen(lin_dev_scsi_devfs_disk_plus)))
3028    return new linux_scsi_device(this, name, "");
3029
3030  // form /dev/ns* or ns*
3031  if (!strncmp(lin_dev_scsi_tape1, dev_name,
3032               strlen(lin_dev_scsi_tape1)))
3033    return new linux_scsi_device(this, name, "");
3034
3035  // form /dev/os* or os*
3036  if (!strncmp(lin_dev_scsi_tape2, dev_name,
3037               strlen(lin_dev_scsi_tape2)))
3038    return new linux_scsi_device(this, name, "");
3039
3040  // form /dev/nos* or nos*
3041  if (!strncmp(lin_dev_scsi_tape3, dev_name,
3042               strlen(lin_dev_scsi_tape3)))
3043    return new linux_scsi_device(this, name, "");
3044
3045  // form /dev/twa*
3046  if (!strncmp(lin_dev_3ware_9000_char, dev_name,
3047               strlen(lin_dev_3ware_9000_char)))
3048    return missing_option("-d 3ware,N");
3049
3050  // form /dev/twe*
3051  if (!strncmp(lin_dev_3ware_678k_char, dev_name,
3052               strlen(lin_dev_3ware_678k_char)))
3053    return missing_option("-d 3ware,N");
3054
3055  // form /dev/cciss*
3056  if (!strncmp(lin_dev_cciss_dir, dev_name,
3057               strlen(lin_dev_cciss_dir)))
3058    return missing_option("-d cciss,N");
3059
3060  // form /dev/sg*
3061  if ( !strncmp(lin_dev_areca, dev_name,
3062                strlen(lin_dev_areca)) )
3063    return missing_option("-d areca,N");
3064
3065  // we failed to recognize any of the forms
3066  return 0;
3067}
3068
3069smart_device * linux_smart_interface::get_custom_smart_device(const char * name, const char * type)
3070{
3071  // Marvell ?
3072  if (!strcmp(type, "marvell"))
3073    return new linux_marvell_device(this, name, type);
3074
3075  // 3Ware ?
3076  int disknum = -1, n1 = -1, n2 = -1;
3077  if (sscanf(type, "3ware,%n%d%n", &n1, &disknum, &n2) == 1 || n1 == 6) {
3078    if (n2 != (int)strlen(type)) {
3079      set_err(EINVAL, "Option -d 3ware,N requires N to be a non-negative integer");
3080      return 0;
3081    }
3082    if (!(0 <= disknum && disknum <= 127)) {
3083      set_err(EINVAL, "Option -d 3ware,N (N=%d) must have 0 <= N <= 127", disknum);
3084      return 0;
3085    }
3086
3087    if (!strncmp(name, "/dev/twa", 8))
3088      return new linux_escalade_device(this, name, linux_escalade_device::AMCC_3WARE_9000_CHAR, disknum);
3089    else if (!strncmp(name, "/dev/twe", 8))
3090      return new linux_escalade_device(this, name, linux_escalade_device::AMCC_3WARE_678K_CHAR, disknum);
3091    else
3092      return new linux_escalade_device(this, name, linux_escalade_device::AMCC_3WARE_678K, disknum);
3093  }
3094
3095  // Areca?
3096  disknum = n1 = n2 = -1;
3097  if (sscanf(type, "areca,%n%d%n", &n1, &disknum, &n2) == 1 || n1 == 6) {
3098    if (n2 != (int)strlen(type)) {
3099      set_err(EINVAL, "Option -d areca,N requires N to be a non-negative integer");
3100      return 0;
3101    }
3102    if (!(1 <= disknum && disknum <= 24)) {
3103      set_err(EINVAL, "Option -d areca,N (N=%d) must have 1 <= N <= 24", disknum);
3104      return 0;
3105    }
3106    return new linux_areca_device(this, name, disknum);
3107  }
3108
3109  // Highpoint ?
3110  int controller = -1, channel = -1; disknum = 1;
3111  n1 = n2 = -1; int n3 = -1;
3112  if (sscanf(type, "hpt,%n%d/%d%n/%d%n", &n1, &controller, &channel, &n2, &disknum, &n3) >= 2 || n1 == 4) {
3113    int len = strlen(type);
3114    if (!(n2 == len || n3 == len)) {
3115      set_err(EINVAL, "Option '-d hpt,L/M/N' supports 2-3 items");
3116      return 0;
3117    }
3118    if (!(1 <= controller && controller <= 8)) {
3119      set_err(EINVAL, "Option '-d hpt,L/M/N' invalid controller id L supplied");
3120      return 0;
3121    }
3122    if (!(1 <= channel && channel <= 8)) {
3123      set_err(EINVAL, "Option '-d hpt,L/M/N' invalid channel number M supplied");
3124      return 0;
3125    }
3126    if (!(1 <= disknum && disknum <= 15)) {
3127      set_err(EINVAL, "Option '-d hpt,L/M/N' invalid pmport number N supplied");
3128      return 0;
3129    }
3130    return new linux_highpoint_device(this, name, controller, channel, disknum);
3131  }
3132
3133#ifdef HAVE_LINUX_CCISS_IOCTL_H
3134  // CCISS ?
3135  disknum = n1 = n2 = -1;
3136  if (sscanf(type, "cciss,%n%d%n", &n1, &disknum, &n2) == 1 || n1 == 6) {
3137    if (n2 != (int)strlen(type)) {
3138      set_err(EINVAL, "Option -d cciss,N requires N to be a non-negative integer");
3139      return 0;
3140    }
3141    if (!(0 <= disknum && disknum <= 15)) {
3142      set_err(EINVAL, "Option -d cciss,N (N=%d) must have 0 <= N <= 15", disknum);
3143      return 0;
3144    }
3145    return new linux_cciss_device(this, name, disknum);
3146  }
3147#endif // HAVE_LINUX_CCISS_IOCTL_H
3148
3149  // MegaRAID ?
3150  if (sscanf(type, "megaraid,%d", &disknum) == 1) {
3151    return new linux_megaraid_device(this, name, 0, disknum);
3152  }
3153  return 0;
3154}
3155
3156std::string linux_smart_interface::get_valid_custom_dev_types_str()
3157{
3158  return "marvell, areca,N, 3ware,N, hpt,L/M/N, megaraid,N"
3159#ifdef HAVE_LINUX_CCISS_IOCTL_H
3160                                              ", cciss,N"
3161#endif
3162    ;
3163}
3164
3165} // namespace
3166
3167
3168/////////////////////////////////////////////////////////////////////////////
3169/// Initialize platform interface and register with smi()
3170
3171void smart_interface::init()
3172{
3173  static os_linux::linux_smart_interface the_interface;
3174  smart_interface::set(&the_interface);
3175}
Note: See TracBrowser for help on using the browser.