Annotation of embedaddon/smartmontools/dev_legacy.cpp, revision 1.1
1.1 ! misho 1: /*
! 2: * dev_legacy.cpp
! 3: *
! 4: * Home page of code is: http://smartmontools.sourceforge.net
! 5: *
! 6: * Copyright (C) 2008-11 Christian Franke <smartmontools-support@lists.sourceforge.net>
! 7: *
! 8: * This program is free software; you can redistribute it and/or modify
! 9: * it under the terms of the GNU General Public License as published by
! 10: * the Free Software Foundation; either version 2, or (at your option)
! 11: * any later version.
! 12: *
! 13: * You should have received a copy of the GNU General Public License
! 14: * (for example COPYING); If not, see <http://www.gnu.org/licenses/>.
! 15: *
! 16: */
! 17:
! 18: #include "config.h"
! 19: #include "int64.h"
! 20: #include "utility.h"
! 21: #include "atacmds.h"
! 22: #include "scsicmds.h"
! 23: #include "dev_interface.h"
! 24: #include "dev_ata_cmd_set.h"
! 25:
! 26: #include <errno.h>
! 27:
! 28: const char * dev_legacy_cpp_cvsid = "$Id: dev_legacy.cpp 3263 2011-02-20 18:32:56Z chrfranke $"
! 29: DEV_INTERFACE_H_CVSID;
! 30:
! 31: /////////////////////////////////////////////////////////////////////////////
! 32:
! 33: // Legacy interface declarations (now commented out globally):
! 34:
! 35: // from utility.h:
! 36: int guess_device_type(const char * dev_name);
! 37: int make_device_names (char ***devlist, const char* name);
! 38: int deviceopen(const char *pathname, char *type);
! 39: int deviceclose(int fd);
! 40:
! 41: // from atacmds.h:
! 42: int ata_command_interface(int device, smart_command_set command, int select, char *data);
! 43:
! 44: // from scsicmds.h:
! 45: int do_scsi_cmnd_io(int dev_fd, struct scsi_cmnd_io * iop, int report);
! 46:
! 47: // from smartctl.h:
! 48: void print_smartctl_examples();
! 49:
! 50: /////////////////////////////////////////////////////////////////////////////
! 51:
! 52: namespace os { // No need to publish anything, name provided for Doxygen
! 53:
! 54: /////////////////////////////////////////////////////////////////////////////
! 55: /// Implement shared open/close routines with old functions.
! 56:
! 57: class legacy_smart_device
! 58: : virtual public /*implements*/ smart_device
! 59: {
! 60: public:
! 61: explicit legacy_smart_device(const char * mode)
! 62: : smart_device(never_called),
! 63: m_fd(-1), m_mode(mode) { }
! 64:
! 65: virtual ~legacy_smart_device() throw();
! 66:
! 67: virtual bool is_open() const;
! 68:
! 69: virtual bool open();
! 70:
! 71: virtual bool close();
! 72:
! 73: protected:
! 74: /// Return filedesc for derived classes.
! 75: int get_fd() const
! 76: { return m_fd; }
! 77:
! 78: private:
! 79: int m_fd; ///< filedesc, -1 if not open.
! 80: const char * m_mode; ///< Mode string for deviceopen().
! 81: };
! 82:
! 83:
! 84: legacy_smart_device::~legacy_smart_device() throw()
! 85: {
! 86: if (m_fd >= 0)
! 87: ::deviceclose(m_fd);
! 88: }
! 89:
! 90: bool legacy_smart_device::is_open() const
! 91: {
! 92: return (m_fd >= 0);
! 93: }
! 94:
! 95: bool legacy_smart_device::open()
! 96: {
! 97: m_fd = ::deviceopen(get_dev_name(), const_cast<char*>(m_mode));
! 98: if (m_fd < 0) {
! 99: set_err((errno==ENOENT || errno==ENOTDIR) ? ENODEV : errno);
! 100: return false;
! 101: }
! 102: return true;
! 103: }
! 104:
! 105: bool legacy_smart_device::close()
! 106: {
! 107: int fd = m_fd; m_fd = -1;
! 108: if (::deviceclose(fd) < 0) {
! 109: set_err(errno);
! 110: return false;
! 111: }
! 112: return true;
! 113: }
! 114:
! 115: /////////////////////////////////////////////////////////////////////////////
! 116: /// Implement standard ATA support with old functions
! 117:
! 118: class legacy_ata_device
! 119: : public /*implements*/ ata_device_with_command_set,
! 120: public /*extends*/ legacy_smart_device
! 121: {
! 122: public:
! 123: legacy_ata_device(smart_interface * intf, const char * dev_name, const char * req_type);
! 124:
! 125: protected:
! 126: virtual int ata_command_interface(smart_command_set command, int select, char * data);
! 127: };
! 128:
! 129: legacy_ata_device::legacy_ata_device(smart_interface * intf, const char * dev_name, const char * req_type)
! 130: : smart_device(intf, dev_name, "ata", req_type),
! 131: legacy_smart_device("ATA")
! 132: {
! 133: }
! 134:
! 135: int legacy_ata_device::ata_command_interface(smart_command_set command, int select, char * data)
! 136: {
! 137: return ::ata_command_interface(get_fd(), command, select, data);
! 138: }
! 139:
! 140:
! 141: /////////////////////////////////////////////////////////////////////////////
! 142: /// Implement standard SCSI support with old functions
! 143:
! 144: class legacy_scsi_device
! 145: : public /*implements*/ scsi_device,
! 146: public /*extends*/ legacy_smart_device
! 147: {
! 148: public:
! 149: legacy_scsi_device(smart_interface * intf, const char * dev_name, const char * req_type);
! 150:
! 151: virtual smart_device * autodetect_open();
! 152:
! 153: virtual bool scsi_pass_through(scsi_cmnd_io * iop);
! 154: };
! 155:
! 156: legacy_scsi_device::legacy_scsi_device(smart_interface * intf,
! 157: const char * dev_name, const char * req_type)
! 158: : smart_device(intf, dev_name, "scsi", req_type),
! 159: legacy_smart_device("SCSI")
! 160: {
! 161: }
! 162:
! 163: bool legacy_scsi_device::scsi_pass_through(scsi_cmnd_io * iop)
! 164: {
! 165: int status = ::do_scsi_cmnd_io(get_fd(), iop, scsi_debugmode);
! 166: if (status < 0) {
! 167: set_err(-status);
! 168: return false;
! 169: }
! 170: return true;
! 171: }
! 172:
! 173:
! 174: /////////////////////////////////////////////////////////////////////////////
! 175: /// SCSI open with autodetection support
! 176:
! 177: smart_device * legacy_scsi_device::autodetect_open()
! 178: {
! 179: // Open device
! 180: if (!open())
! 181: return this;
! 182:
! 183: // No Autodetection if device type was specified by user
! 184: if (*get_req_type())
! 185: return this;
! 186:
! 187: // The code below is based on smartd.cpp:SCSIFilterKnown()
! 188:
! 189: // Get INQUIRY
! 190: unsigned char req_buff[64] = {0, };
! 191: int req_len = 36;
! 192: if (scsiStdInquiry(this, req_buff, req_len)) {
! 193: // Marvell controllers fail on a 36 bytes StdInquiry, but 64 suffices
! 194: // watch this spot ... other devices could lock up here
! 195: req_len = 64;
! 196: if (scsiStdInquiry(this, req_buff, req_len)) {
! 197: // device doesn't like INQUIRY commands
! 198: close();
! 199: set_err(EIO, "INQUIRY failed");
! 200: return this;
! 201: }
! 202: }
! 203:
! 204: int avail_len = req_buff[4] + 5;
! 205: int len = (avail_len < req_len ? avail_len : req_len);
! 206: if (len < 36)
! 207: return this;
! 208:
! 209: // Use INQUIRY to detect type
! 210:
! 211: // SAT or USB ?
! 212: {
! 213: smart_device * newdev = smi()->autodetect_sat_device(this, req_buff, len);
! 214: if (newdev)
! 215: // NOTE: 'this' is now owned by '*newdev'
! 216: return newdev;
! 217: }
! 218:
! 219: // Nothing special found
! 220: return this;
! 221: }
! 222:
! 223:
! 224: /////////////////////////////////////////////////////////////////////////////
! 225: /// Implement platform interface with old functions.
! 226:
! 227: class legacy_smart_interface
! 228: : public /*implements*/ smart_interface
! 229: {
! 230: public:
! 231: virtual std::string get_app_examples(const char * appname);
! 232:
! 233: virtual bool scan_smart_devices(smart_device_list & devlist, const char * type,
! 234: const char * pattern = 0);
! 235:
! 236: protected:
! 237: virtual ata_device * get_ata_device(const char * name, const char * type);
! 238:
! 239: virtual scsi_device * get_scsi_device(const char * name, const char * type);
! 240:
! 241: virtual smart_device * autodetect_smart_device(const char * name);
! 242: };
! 243:
! 244:
! 245: //////////////////////////////////////////////////////////////////////
! 246:
! 247: std::string legacy_smart_interface::get_app_examples(const char * appname)
! 248: {
! 249: if (!strcmp(appname, "smartctl"))
! 250: ::print_smartctl_examples(); // this prints to stdout ...
! 251: return ""; // ... so don't print again.
! 252: }
! 253:
! 254: ata_device * legacy_smart_interface::get_ata_device(const char * name, const char * type)
! 255: {
! 256: return new legacy_ata_device(this, name, type);
! 257: }
! 258:
! 259: scsi_device * legacy_smart_interface::get_scsi_device(const char * name, const char * type)
! 260: {
! 261: return new legacy_scsi_device(this, name, type);
! 262: }
! 263:
! 264:
! 265: smart_device * legacy_smart_interface::autodetect_smart_device(const char * name)
! 266: {
! 267: switch (::guess_device_type(name)) {
! 268: case CONTROLLER_ATA : return new legacy_ata_device(this, name, "");
! 269: case CONTROLLER_SCSI: return new legacy_scsi_device(this, name, "");
! 270: }
! 271: // TODO: Test autodetect device here
! 272: return 0;
! 273: }
! 274:
! 275:
! 276: static void free_devnames(char * * devnames, int numdevs)
! 277: {
! 278: static const char version[] = "$Id: dev_legacy.cpp 3263 2011-02-20 18:32:56Z chrfranke $";
! 279: for (int i = 0; i < numdevs; i++)
! 280: FreeNonZero(devnames[i], -1,__LINE__, version);
! 281: FreeNonZero(devnames, (sizeof (char*) * numdevs),__LINE__, version);
! 282: }
! 283:
! 284: bool legacy_smart_interface::scan_smart_devices(smart_device_list & devlist,
! 285: const char * type, const char * pattern /*= 0*/)
! 286: {
! 287: if (pattern) {
! 288: set_err(EINVAL, "DEVICESCAN with pattern not implemented yet");
! 289: return false;
! 290: }
! 291:
! 292: // Make namelists
! 293: char * * atanames = 0; int numata = 0;
! 294: if (!type || !strcmp(type, "ata")) {
! 295: numata = ::make_device_names(&atanames, "ATA");
! 296: if (numata < 0) {
! 297: set_err(ENOMEM);
! 298: return false;
! 299: }
! 300: }
! 301:
! 302: char * * scsinames = 0; int numscsi = 0;
! 303: if (!type || !strcmp(type, "scsi")) {
! 304: numscsi = ::make_device_names(&scsinames, "SCSI");
! 305: if (numscsi < 0) {
! 306: free_devnames(atanames, numata);
! 307: set_err(ENOMEM);
! 308: return false;
! 309: }
! 310: }
! 311:
! 312: // Add to devlist
! 313: int i;
! 314: if (!type)
! 315: type="";
! 316: for (i = 0; i < numata; i++) {
! 317: ata_device * atadev = get_ata_device(atanames[i], type);
! 318: if (atadev)
! 319: devlist.push_back(atadev);
! 320: }
! 321: free_devnames(atanames, numata);
! 322:
! 323: for (i = 0; i < numscsi; i++) {
! 324: scsi_device * scsidev = get_scsi_device(scsinames[i], type);
! 325: if (scsidev)
! 326: devlist.push_back(scsidev);
! 327: }
! 328: free_devnames(scsinames, numscsi);
! 329: return true;
! 330: }
! 331:
! 332: } // namespace
! 333:
! 334:
! 335: /////////////////////////////////////////////////////////////////////////////
! 336: /// Initialize platform interface and register with smi()
! 337:
! 338: void smart_interface::init()
! 339: {
! 340: static os::legacy_smart_interface the_interface;
! 341: smart_interface::set(&the_interface);
! 342: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dev_legacy.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / smartmontools