smartmontools  SVN Rev 4111
Utility to control and monitor storage systems with "S.M.A.R.T."
os_qnxnto.cpp
Go to the documentation of this file.
1 
2 
3 // This is needed for the various HAVE_* macros and PROJECT_* macros.
4 #include "config.h"
5 
6 // These are needed to define prototypes and structures for the
7 // functions defined below
8 #include "int64.h"
9 #include "atacmds.h"
10 #include "scsicmds.h"
11 #include "utility.h"
12 
13 // This is to include whatever structures and prototypes you define in
14 // os_generic.h
15 #include "os_qnxnto.h"
16 #include <errno.h>
17 
18 // Needed by '-V' option (CVS versioning) of smartd/smartctl. You
19 // should have one *_H_CVSID macro appearing below for each file
20 // appearing with #include "*.h" above. Please list these (below) in
21 // alphabetic/dictionary order.
22 const char *os_XXXX_c_cvsid="$Id: os_qnxnto.cpp 3806 2013-03-29 20:17:03Z chrfranke $" \
24 
25 
26 // This is here to prevent compiler warnings for unused arguments of
27 // functions.
28 #define ARGUSED(x) ((void)(x))
29 
30 // Please eliminate the following block: both the #include and
31 // the 'unsupported()' function. They are only here to warn
32 // unsuspecting users that their Operating System is not supported! If
33 // you wish, you can use a similar warning mechanism for any of the
34 // functions in this file that you can not (or choose not to)
35 // implement.
36 
37 
38 #ifdef HAVE_UNAME
39 #include <sys/utsname.h>
40 #endif
41 //----------------------------------------------------------------------------------------------
42 // private Functions
43 static int ata_sense_data(void *sdata,int *error,int *key,int *asc,int *ascq);
44 static int ata_interpret_sense(struct cam_pass_thru *cpt,void *sense,int *status,int rcount);
45 static int ata_pass_thru(int fd,struct cam_pass_thru *pcpt);
46 //----------------------------------------------------------------------------------------------
47 static void unsupported(){
48  static int warninggiven;
49 
50  if (!warninggiven) {
51  char *osname;
52 
53 #ifdef HAVE_UNAME
54  struct utsname ostype;
55  uname(&ostype);
56  osname=ostype.sysname;
57 #else
58  osname="host's";
59 #endif
60 
61  pout("\n"
62  "############################################################################\n"
63  "WARNING: smartmontools has not been ported to the %s Operating System.\n"
64  "Please see the files os_generic.cpp and os_generic.h for porting instructions.\n"
65  "############################################################################\n\n",
66  osname);
67  warninggiven=1;
68  }
69 
70  return;
71 }
72 // End of the 'unsupported()' block that you should eliminate.
73 
74 
75 // print examples for smartctl. You should modify this function so
76 // that the device paths are sensible for your OS, and to eliminate
77 // unsupported commands (eg, 3ware controllers).
79  printf("=================================================== SMARTCTL EXAMPLES =====\n\n");
80 #ifdef HAVE_GETOPT_LONG
81  printf(
82  " smartctl -a /dev/hd0 (Prints all SMART information)\n\n"
83  " smartctl --smart=on --offlineauto=on --saveauto=on /dev/hd0\n"
84  " (Enables SMART on first disk)\n\n"
85  " smartctl -t long /dev/hd0 (Executes extended disk self-test)\n\n"
86  " smartctl --attributes --log=selftest --quietmode=errorsonly /dev/hd0\n"
87  " (Prints Self-Test & Attribute errors)\n"
88  " smartctl -a --device=3ware,2 /dev/sda\n"
89  " (Prints all SMART info for 3rd ATA disk on 3ware RAID controller)\n"
90  );
91 #else
92  printf(
93  " smartctl -a /dev/hd0 (Prints all SMART information)\n"
94  " smartctl -s on -o on -S on /dev/hd0 (Enables SMART on first disk)\n"
95  " smartctl -t long /dev/hd0 (Executes extended disk self-test)\n"
96  " smartctl -A -l selftest -q errorsonly /dev/hd0\n"
97  " (Prints Self-Test & Attribute errors)\n"
98  " smartctl -a -d 3ware,2 /dev/sda\n"
99  " (Prints all SMART info for 3rd ATA disk on 3ware RAID controller)\n"
100  );
101 #endif
102  return;
103 }
104 
105 // tries to guess device type given the name (a path). See utility.h
106 // for return values.
107 static const char *net_dev_prefix = "/dev/";
108 static const char *net_dev_ata_disk = "hd";
109 
110 int guess_device_type (const char* dev_name)
111 {
112 int len,dev_prefix_len;
113  dev_prefix_len=strlen(net_dev_prefix);
114  if(!dev_name||!(len=strlen(dev_name)))
115  return(CONTROLLER_UNKNOWN);
116  if (!strncmp(net_dev_prefix,dev_name,dev_prefix_len))
117  {
118  if(len<=dev_prefix_len)
119  return(CONTROLLER_UNKNOWN);
120  else
121  dev_name += dev_prefix_len;
122  }
123  if(!strncmp(net_dev_ata_disk,dev_name,strlen(net_dev_ata_disk)))
124  return(CONTROLLER_ATA);
125  return(CONTROLLER_UNKNOWN);
126 }
127 
128 // makes a list of ATA or SCSI devices for the DEVICESCAN directive of
129 // smartd. Returns number N of devices, or -1 if out of
130 // memory. Allocates N+1 arrays: one of N pointers (devlist); the
131 // other N arrays each contain null-terminated character strings. In
132 // the case N==0, no arrays are allocated because the array of 0
133 // pointers has zero length, equivalent to calling malloc(0).
134 int make_device_names (char*** devlist, const char* name) {
135  ARGUSED(devlist);
136  ARGUSED(name);
137  unsupported();
138  return 0;
139 }
140 
141 // Like open(). Return non-negative integer handle, only used by the
142 // functions below. type=="ATA" or "SCSI". If you need to store
143 // extra information about your devices, create a private internal
144 // array within this file (see os_freebsd.cpp for an example). If you
145 // can not open the device (permission denied, does not exist, etc)
146 // set errno as open() does and return <0.
147 int deviceopen(const char *pathname, char *type)
148 {
149  if(!strcmp(type, "ATA"))
150  return(open(pathname,O_RDWR|O_NONBLOCK));
151  else
152  return(-1);
153 }
154 
155 // Like close(). Acts only on integer handles returned by
156 // deviceopen() above.
157 int deviceclose(int fd)
158 {
159  return(close(fd));
160 }
161 //----------------------------------------------------------------------------------------------
162 // Interface to ATA devices. See os_linux.cpp for the cannonical example.
163 // DETAILED DESCRIPTION OF ARGUMENTS
164 // device: is the integer handle provided by deviceopen()
165 // command: defines the different operations, see atacmds.h
166 // select: additional input data IF NEEDED (which log, which type of
167 // self-test).
168 // data: location to write output data, IF NEEDED (1 or 512 bytes).
169 // Note: not all commands use all arguments.
170 // RETURN VALUES (for all commands BUT command==STATUS_CHECK)
171 // -1 if the command failed
172 // 0 if the command succeeded,
173 // RETURN VALUES if command==STATUS_CHECK
174 // -1 if the command failed OR the disk SMART status can't be determined
175 // 0 if the command succeeded and disk SMART status is "OK"
176 // 1 if the command succeeded and disk SMART status is "FAILING"
177 int ata_command_interface(int fd,smart_command_set command,int select,char *data)
178 {
179 struct cam_pass_thru cpt;
180 ATA_SENSE sense;
181 CDB *cdb;
182 int status,rc;
183  memset(&cpt,0x00,sizeof(struct cam_pass_thru));
184  cdb=(CDB *)cpt.cam_cdb;
185  rc=-1;
186  switch(command)
187  {
188  case READ_VALUES:
189  cpt.cam_flags = CAM_DIR_IN;
190  cpt.cam_cdb_len = 16;
191  cpt.cam_dxfer_len = 512;
192  cpt.cam_data_ptr = (uint32_t)data;
193  cpt.cam_sense_len = sizeof(sense);
194  cpt.cam_sense_ptr = (uint32_t)&sense;
202  break;
203  case READ_THRESHOLDS:
204  cpt.cam_flags = CAM_DIR_IN;
205  cpt.cam_cdb_len = 16;
206  cpt.cam_dxfer_len = 512;
207  cpt.cam_data_ptr = (uint32_t)data;
208  cpt.cam_sense_len = sizeof(sense);
209  cpt.cam_sense_ptr = (uint32_t)&sense;
217  break;
218  case READ_LOG:
219  cpt.cam_flags = CAM_DIR_IN;
220  cpt.cam_cdb_len = 16;
221  cpt.cam_dxfer_len = 512;
222  cpt.cam_data_ptr = (uint32_t)data;
223  cpt.cam_sense_len = sizeof(sense);
224  cpt.cam_sense_ptr = (uint32_t)&sense;
230  cdb->ata_pass_thru.sector_count= 1;
231  cdb->ata_pass_thru.lba_low = select;
234  break;
235  case WRITE_LOG:
236  return(-1);
237  break;
238  case IDENTIFY:
239  cpt.cam_flags = CAM_DIR_IN;
240  cpt.cam_cdb_len = 16;
241  cpt.cam_dxfer_len = 512;
242  cpt.cam_data_ptr = (uint32_t)data;
243  cpt.cam_sense_len = sizeof(sense);
244  cpt.cam_sense_ptr = (uint32_t)&sense;
249  break;
250  case PIDENTIFY:
251  cpt.cam_flags = CAM_DIR_IN;
252  cpt.cam_cdb_len = 16;
253  cpt.cam_dxfer_len = 512;
254  cpt.cam_data_ptr = (uint32_t)data;
255  cpt.cam_sense_len = sizeof(sense);
256  cpt.cam_sense_ptr = (uint32_t)&sense;
261  break;
262  case ENABLE:
263  cpt.cam_flags = CAM_DIR_NONE;
264  cpt.cam_cdb_len = 16;
265  cpt.cam_sense_len = sizeof(sense);
266  cpt.cam_sense_ptr = (uint32_t)&sense;
273  break;
274  case DISABLE:
275  cpt.cam_flags = CAM_DIR_NONE;
276  cpt.cam_cdb_len = 16;
277  cpt.cam_sense_len = sizeof(sense);
278  cpt.cam_sense_ptr = (uint32_t)&sense;
285  break;
286  case AUTO_OFFLINE:
287  // NOTE: According to ATAPI 4 and UP, this command is obsolete
288  cpt.cam_flags = CAM_DIR_NONE;
289  cpt.cam_cdb_len = 16;
290  cpt.cam_sense_len = sizeof(sense);
291  cpt.cam_sense_ptr = (uint32_t)&sense;
296  cdb->ata_pass_thru.lba_low = select;
299  break;
300  case AUTOSAVE:
301  cpt.cam_flags = CAM_DIR_NONE;
302  cpt.cam_cdb_len = 16;
303  cpt.cam_sense_len = sizeof(sense);
304  cpt.cam_sense_ptr = (uint32_t)&sense;
309  cdb->ata_pass_thru.sector_count= select;
312  break;
313  case IMMEDIATE_OFFLINE:
314  // NOTE: According to ATAPI 4 and UP, this command is obsolete
315  cpt.cam_flags = CAM_DIR_NONE;
316  cpt.cam_cdb_len = 16;
317  cpt.cam_sense_len = sizeof(sense);
318  cpt.cam_sense_ptr = (uint32_t)&sense;
323  cdb->ata_pass_thru.lba_low = select;
326  break;
327  case STATUS_CHECK:
328  // same command, no HDIO in NetBSD
329  case STATUS:
330  cpt.cam_flags = CAM_DIR_NONE;
331  cpt.cam_cdb_len = 16;
332  cpt.cam_sense_len = sizeof(sense);
333  cpt.cam_sense_ptr = (uint32_t)&sense;
341  break;
342  case CHECK_POWER_MODE:
343  cpt.cam_flags = CAM_DIR_NONE;
344  cpt.cam_cdb_len = 16;
345  cpt.cam_sense_len = sizeof(sense);
346  cpt.cam_sense_ptr = (uint32_t)&sense;
351  break;
352  default:
353  pout("Unrecognized command %d in ata_command_interface()\n", command);
354  errno=ENOSYS;
355  return(-1);
356  }
357 // execute now
358  if((status=ata_pass_thru(fd,&cpt))==EOK)
359  {
360  rc=status==EOK?0:-1;
361  if(cpt.cam_status!=CAM_REQ_CMP)
362  {
363  ata_interpret_sense(&cpt,&sense,&status,0);
364  if(command==STATUS||command==STATUS_CHECK)
365  rc=((sense.desc.lba_high<<8)|sense.desc.lba_mid)==ATA_SMART_SIG?0:1;
366  }
367  }
368  if(command==CHECK_POWER_MODE)
369  data[0]=cdb->ata_pass_thru.sector_count;
370 // finish
371  return(rc);
372 }
373 //----------------------------------------------------------------------------------------------
374 // Interface to SCSI devices. See os_linux.c
375 int do_scsi_cmnd_io(int fd,struct scsi_cmnd_io * iop,int report)
376 {
377  ARGUSED(fd);
378  ARGUSED(iop);
379  ARGUSED(report);
380  unsupported();
381  return -ENOSYS;
382 }
383 //----------------------------------------------------------------------------------------------
384 //----------------------------------------------------------------------------------------------
385 static int ata_sense_data(void *sdata,int *error,int *key,int *asc,int *ascq)
386 {
387 SCSI_SENSE *sf;
389  sf=(SCSI_SENSE *)sdata;
390  sd=(SCSI_SENSE_DESCRIPTOR *)sdata;
391  *error=sf->error;
392  if(*error & SENSE_DATA_FMT_DESCRIPTOR)
393  {
394  *key=sd->sense & SK_MSK;
395  *asc=sd->asc;
396  *ascq=sd->ascq;
397  }
398  else
399  {
400  *key=sf->sense & SK_MSK;
401  *asc=sf->asc;
402  *ascq=sf->ascq;
403  }
404  return(CAM_SUCCESS);
405 }
406 //----------------------------------------------------------------------------------------------
407 static int ata_interpret_sense(struct cam_pass_thru *cpt,void *sense,int *status,int rcount)
408 {
409 int retry;
410 int key;
411 int asc;
412 int ascq;
413 int error;
414  *status=EIO;
415  retry=CAM_TRUE;
416  if(cpt->cam_status&CAM_AUTOSNS_VALID)
417  {
418  ata_sense_data(sense,&error,&key,&asc,&ascq);
419  switch(key)
420  {
421  case SK_NO_SENSE: // No sense data (no error)
422  retry=CAM_FALSE;
423  *status=EOK;
424  break;
425  case SK_RECOVERED: // Recovered error
426  switch(asc)
427  {
428  case ASC_ATA_PASS_THRU:
429  switch(ascq)
430  {
432  break;
433  default:
434  break;
435  }
436  break;
437  default:
438  break;
439  }
440  retry=CAM_FALSE;
441  *status=EOK;
442  break;
443  case SK_NOT_RDY: // Device not ready
444  *status=EAGAIN;
445  switch(asc)
446  {
447  case ASC_NOT_READY:
448  switch(ascq)
449  {
450  case ASCQ_BECOMING_READY:
452  default:
453  retry=CAM_FALSE;
454  break;
455  }
456  break;
458  *status=ENXIO;
459  retry=CAM_FALSE;
460  break;
461  }
462  break;
463  case SK_MEDIUM: // Medium error
464  case SK_HARDWARE: // Hardware error
465  retry=CAM_FALSE;
466  *status=EIO;
467  break;
468  case SK_ILLEGAL: // Illegal Request (bad command)
469  retry=CAM_FALSE;
470  *status=EINVAL;
471  break;
472  case SK_UNIT_ATN: // Unit Attention
473  switch(asc)
474  {
475  case ASC_MEDIUM_CHANGED:
476  *status=ESTALE;
477  retry=CAM_FALSE;
478  break;
479  case ASC_BUS_RESET:
480  break;
481  }
482  break;
483  case SK_DATA_PROT: // Data Protect
484  retry=CAM_FALSE;
485  *status=EROFS;
486  break;
487  case SK_VENDOR: // Vendor Specific
488  case SK_CPY_ABORT: // Copy Aborted
489  retry=CAM_FALSE;
490  *status=EIO;
491  break;
492  case SK_CMD_ABORT: // Aborted Command
493  retry=CAM_FALSE;
494  *status=ECANCELED;
495  break;
496  case SK_EQUAL: // Equal
497  case SK_VOL_OFL: // Volume Overflow
498  case SK_MISCMP: // Miscompare
499  case SK_RESERVED: // Reserved
500  break;
501  }
502  if(*status==EOK)
503  {
504  switch(cpt->cam_status&CAM_STATUS_MASK)
505  {
506  case CAM_REQ_CMP_ERR: // CCB request completed with an err
507  retry=CAM_FALSE;
508  *status=EIO;
509  break;
510  case CAM_BUSY: // CAM subsystem is busy
511  *status=EAGAIN;
512  break;
513  case CAM_REQ_INVALID: // CCB request is invalid
514  case CAM_PATH_INVALID: // Path ID supplied is invalid
515  case CAM_DEV_NOT_THERE: // SCSI device not installed/there
516  case CAM_SEL_TIMEOUT: // Target selection timeout
517  case CAM_LUN_INVALID: // LUN supplied is invalid
518  case CAM_TID_INVALID: // Target ID supplied is invalid
519  retry=CAM_FALSE;
520  *status=ENXIO;
521  break;
522  case CAM_CMD_TIMEOUT: // Command timeout
523  *status=rcount?EAGAIN:EIO;
524  break;
525  case CAM_MSG_REJECT_REC: // Message reject received
526  case CAM_SCSI_BUS_RESET: // SCSI bus reset sent/received
527  case CAM_UNCOR_PARITY: // Uncorrectable parity err occurred
528  case CAM_AUTOSENSE_FAIL: // Autosense: Request sense cmd fail
529  case CAM_NO_HBA: // No HBA detected Error
530  case CAM_DATA_RUN_ERR: // Data overrun/underrun error
531  retry=CAM_FALSE;
532  *status=EIO;
533  break;
534  case CAM_UNEXP_BUSFREE: // Unexpected BUS free
535  case CAM_SEQUENCE_FAIL: // Target bus phase sequence failure
536  *status=EIO;
537  break;
538  case CAM_PROVIDE_FAIL: // Unable to provide requ. capability
539  retry=CAM_FALSE;
540  *status=ENOTTY;
541  break;
542  case CAM_CCB_LEN_ERR: // CCB length supplied is inadequate
543  case CAM_BDR_SENT: // A SCSI BDR msg was sent to target
544  case CAM_REQ_TERMIO: // CCB request terminated by the host
545  case CAM_FUNC_NOTAVAIL: // The requ. func is not available
546  case CAM_NO_NEXUS: // Nexus is not established
547  case CAM_IID_INVALID: // The initiator ID is invalid
548  case CAM_CDB_RECVD: // The SCSI CDB has been received
549  retry=CAM_FALSE;
550  *status=EIO;
551  break;
552  case CAM_SCSI_BUSY: // SCSI bus busy
553  *status=EAGAIN;
554  break;
555  }
556  }
557  }
558  return(retry);
559 }
560 //----------------------------------------------------------------------------------------------
561 static int ata_pass_thru(int fd,struct cam_pass_thru *pcpt)
562 {
563 int icnt;
564 int status;
565 iov_t iov[3];
566 struct cam_pass_thru cpt;
567  cpt=*pcpt;
568  icnt=1;
569  SETIOV(&iov[0],&cpt,sizeof(cpt));
570  cpt.cam_timeout=cpt.cam_timeout?cpt.cam_timeout:CAM_TIME_DEFAULT;
571  if(cpt.cam_sense_len)
572  {
573  SETIOV(&iov[1],(void *)cpt.cam_sense_ptr,cpt.cam_sense_len);
574  cpt.cam_sense_ptr=sizeof(cpt);
575  icnt++;
576  }
577  if(cpt.cam_dxfer_len)
578  {
579  SETIOV(&iov[2],(void *)cpt.cam_data_ptr,cpt.cam_dxfer_len);
580  cpt.cam_data_ptr=(paddr_t)sizeof(cpt)+cpt.cam_sense_len;
581  icnt++;
582  }
583  if((status=devctlv(fd,DCMD_CAM_PASS_THRU,icnt,icnt,iov,iov,NULL)))
584  pout("ata_pass_thru devctl: %s\n",strerror(status));
585  pcpt->cam_status=cpt.cam_status;
586  pcpt->cam_scsi_status=cpt.cam_scsi_status;
587  return(status);
588 }
589 //----------------------------------------------------------------------------------------------
#define ASCQ_CAUSE_NOT_REPORTABLE
Definition: os_qnxnto.h:227
#define ATA_SMART_READ_LOG_SECTOR
Definition: atacmds.h:100
#define CAM_TRUE
Definition: os_qnxnto.h:72
#define ATACMDS_H_CVSID
Definition: atacmds.h:28
static int ata_sense_data(void *sdata, int *error, int *key, int *asc, int *ascq)
Definition: os_qnxnto.cpp:385
#define ATA_SMART_CMD
Definition: atacmds.h:75
uchar_t sense
Definition: os_qnxnto.h:151
static int ata_interpret_sense(struct cam_pass_thru *cpt, void *sense, int *status, int rcount)
Definition: os_qnxnto.cpp:407
uchar_t asc
Definition: os_qnxnto.h:155
#define ASC_MEDIA_NOT_PRESENT
Definition: os_qnxnto.h:234
#define ATA_SMART_DISABLE
Definition: atacmds.h:104
#define ASC_MEDIUM_CHANGED
Definition: os_qnxnto.h:259
#define ASC_NOT_READY
Definition: os_qnxnto.h:226
#define ATA_SMART_AUTOSAVE
Definition: atacmds.h:97
#define SK_MISCMP
Definition: os_qnxnto.h:274
#define SK_MEDIUM
Definition: os_qnxnto.h:237
#define ATA_FLG_TLEN_STPSIU
Definition: os_qnxnto.h:768
#define ATA_IDENTIFY_DEVICE
Definition: atacmds.h:72
const char * os_XXXX_c_cvsid
Definition: os_qnxnto.cpp:22
#define INT64_H_CVSID
Definition: int64.h:23
#define ATA_IDENTIFY_PACKET_DEVICE
Definition: atacmds.h:73
#define SCSICMDS_H_CVSID
Definition: scsicmds.h:35
ptr_t data
Definition: megaraid.h:94
uchar_t error
Definition: os_qnxnto.h:149
#define SC_ATA_PT16
Definition: os_qnxnto.h:76
#define SK_NO_SENSE
Definition: os_qnxnto.h:214
#define ATA_PROTO_PIO_DATA_IN
Definition: os_qnxnto.h:757
#define ATA_SMART_LBA_HI_SIG
Definition: os_qnxnto.h:79
int ata_command_interface(int fd, smart_command_set command, int select, char *data)
Definition: os_qnxnto.cpp:177
static int ata_pass_thru(int fd, struct cam_pass_thru *pcpt)
Definition: os_qnxnto.cpp:561
#define ATA_CHECK_POWER_MODE
Definition: atacmds.h:71
static const char * net_dev_ata_disk
Definition: os_qnxnto.cpp:108
u8 cdb[16]
Definition: megaraid.h:100
#define ATA_FLG_T_DIR
Definition: os_qnxnto.h:766
#define SK_NOT_RDY
Definition: os_qnxnto.h:224
uchar_t ascq
Definition: os_qnxnto.h:156
int do_scsi_cmnd_io(int fd, struct scsi_cmnd_io *iop, int report)
Definition: os_qnxnto.cpp:375
#define SK_RECOVERED
Definition: os_qnxnto.h:220
struct _cdb::_ata_pass_thru ata_pass_thru
#define SENSE_DATA_FMT_DESCRIPTOR
Definition: os_qnxnto.h:125
int deviceclose(int fd)
Definition: os_qnxnto.cpp:157
void pout(const char *fmt,...)
Definition: smartctl.cpp:1095
#define ATA_SMART_READ_VALUES
Definition: atacmds.h:95
#define SK_DATA_PROT
Definition: os_qnxnto.h:265
int guess_device_type(const char *dev_name)
Definition: os_qnxnto.cpp:110
#define CAM_SUCCESS
Definition: os_qnxnto.h:68
#define ASCQ_ATA_PASS_THRU_INFO_AVAIL
Definition: os_qnxnto.h:222
Definition: atacmds.h:55
static const char * net_dev_prefix
Definition: os_qnxnto.cpp:107
#define ATA_SMART_SIG
Definition: os_qnxnto.h:80
#define ATA_SMART_AUTO_OFFLINE
Definition: atacmds.h:108
smart_command_set
Definition: atacmds.h:48
#define ATA_SMART_READ_THRESHOLDS
Definition: atacmds.h:96
#define SK_VOL_OFL
Definition: os_qnxnto.h:273
#define ASCQ_BECOMING_READY
Definition: os_qnxnto.h:228
#define SK_CPY_ABORT
Definition: os_qnxnto.h:270
#define SK_UNIT_ATN
Definition: os_qnxnto.h:258
#define ATA_SMART_LBA_MID_SIG
Definition: os_qnxnto.h:78
#define ASC_BUS_RESET
Definition: os_qnxnto.h:260
#define CAM_FALSE
Definition: os_qnxnto.h:71
#define ATA_SMART_IMMEDIATE_OFFLINE
Definition: atacmds.h:99
#define SK_RESERVED
Definition: os_qnxnto.h:275
#define SK_CMD_ABORT
Definition: os_qnxnto.h:271
#define SK_HARDWARE
Definition: os_qnxnto.h:244
#define OS_QNXNTO_H_CVSID
Definition: os_qnxnto.h:26
#define SK_EQUAL
Definition: os_qnxnto.h:272
int deviceopen(const char *pathname, char *type)
Definition: os_qnxnto.cpp:147
#define SK_VENDOR
Definition: os_qnxnto.h:269
#define ATA_SMART_ENABLE
Definition: atacmds.h:103
static void unsupported()
Definition: os_qnxnto.cpp:47
#define ARGUSED(x)
Definition: os_qnxnto.cpp:28
Definition: atacmds.h:50
int make_device_names(char ***devlist, const char *name)
Definition: os_qnxnto.cpp:134
#define SK_MSK
Definition: os_qnxnto.h:212
#define ATA_PROTO_DATA_NONE
Definition: os_qnxnto.h:758
#define ATA_FLG_CK_COND
Definition: os_qnxnto.h:765
void print_smartctl_examples()
Definition: os_qnxnto.cpp:78
#define UTILITY_H_CVSID
Definition: utility.h:28
#define ASC_ATA_PASS_THRU
Definition: os_qnxnto.h:221
#define SK_ILLEGAL
Definition: os_qnxnto.h:249
#define ATA_SMART_STATUS
Definition: atacmds.h:105