os_openbsd.cpp 16.7 KB
Newer Older
1
/*
2
 * os_openbsd.cpp
3
 *
4
 * Home page of code is: https://www.smartmontools.org
5
 *
6
 * Copyright (C) 2004-10 David Snyder
7
 *
8
 * Derived from os_netbsd.cpp by Sergey Svishchev, Copyright (C) 2003-8
9
 *
10
 * SPDX-License-Identifier: GPL-2.0-or-later
11
12
 */

13
#include "config.h"
14

15
16
17
18
19
#include "atacmds.h"
#include "scsicmds.h"
#include "utility.h"
#include "os_openbsd.h"

20
#include <sys/utsname.h>
21
#include <errno.h>
22
23
#include <sys/stat.h>
#include <util.h>
24

25
26
const char * os_openbsd_cpp_cvsid = "$Id$"
  OS_OPENBSD_H_CVSID;
27

28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#define ARGUSED(x) ((void)(x))

/////////////////////////////////////////////////////////////////////////////

namespace os_openbsd { // No need to publish anything, name provided for Doxygen

static const char *net_dev_prefix = "/dev/";
static const char *net_dev_ata_disk = "wd";
static const char *net_dev_scsi_disk = "sd";
static const char *net_dev_scsi_tape = "st";

/////////////////////////////////////////////////////////////////////////////
/// Implement shared open/close routines with old functions.

class openbsd_smart_device
: virtual public /*implements*/ smart_device
{
public:
  explicit openbsd_smart_device()
    : smart_device(never_called),
      m_fd(-1) { }

50
  virtual ~openbsd_smart_device();
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

  virtual bool is_open() const;

  virtual bool open();

  virtual bool close();

protected:
  /// Return filedesc for derived classes.
  int get_fd() const
    { return m_fd; }

  void set_fd(int fd)
    { m_fd = fd; }

private:
  int m_fd; ///< filedesc, -1 if not open.
68
69
};

70
openbsd_smart_device::~openbsd_smart_device()
71
72
73
74
75
76
77
78
79
80
81
82
{
  if (m_fd >= 0)
    os_openbsd::openbsd_smart_device::close();
}

bool openbsd_smart_device::is_open() const
{
  return (m_fd >= 0);
}


bool openbsd_smart_device::open()
83
{
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
  const char *dev = get_dev_name();
  int fd;

  if (is_scsi()) {
    fd = ::open(dev,O_RDWR|O_NONBLOCK);

    if (fd < 0 && errno == EROFS)
      fd = ::open(dev,O_RDONLY|O_NONBLOCK);
    if (fd < 0) {
      set_err(errno);
      return false;
    }
  } else if (is_ata()) {
    if ((fd = ::open(dev,O_RDWR|O_NONBLOCK))<0) {
      set_err(errno);
      return false;
100
    }
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
  } else
    return false;

  set_fd(fd);
  return true;
}

bool openbsd_smart_device::close()
{
  int failed = 0;
  // close device, if open
  if (is_open())
    failed=::close(get_fd());

  set_fd(-1);

  if(failed) return false;
    else return true;
}

/////////////////////////////////////////////////////////////////////////////
/// Implement standard ATA support

class openbsd_ata_device
: public /*implements*/ ata_device,
  public /*extends*/ openbsd_smart_device
{
public:
  openbsd_ata_device(smart_interface * intf, const char * dev_name, const char * req_type);
130
  virtual bool ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out) override;
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

protected:
  virtual int do_cmd(struct atareq* request, bool is_48bit_cmd);
};

openbsd_ata_device::openbsd_ata_device(smart_interface * intf, const char * dev_name, const char * req_type)
: smart_device(intf, dev_name, "ata", req_type),
  openbsd_smart_device()
{
}

int openbsd_ata_device::do_cmd( struct atareq* request, bool is_48bit_cmd)
{
  int fd = get_fd(), ret;
  ARGUSED(is_48bit_cmd); // no support for 48 bit commands in the ATAIOCCOMMAND
  ret = ioctl(fd, ATAIOCCOMMAND, request);
  if (ret) set_err(errno);
  return ret;
}

bool openbsd_ata_device::ata_pass_through(const ata_cmd_in & in, ata_cmd_out & out)
{
  bool ata_48bit = false; // no ata_48bit_support via ATAIOCCOMMAND

  if (!ata_cmd_is_ok(in,
    true,  // data_out_support
    true,  // multi_sector_support
    ata_48bit)
    ) {
      set_err(ENOSYS, "48-bit ATA commands not implemented");
      return false;
    }

  struct atareq req;

  memset(&req, 0, sizeof(req));
  req.command = in.in_regs.command;
  req.features = in.in_regs.features;
  req.sec_count = in.in_regs.sector_count;
  req.sec_num = in.in_regs.lba_low;
  req.head = in.in_regs.device;
  req.cylinder = in.in_regs.lba_mid | (in.in_regs.lba_high << 8);
  req.timeout = SCSI_TIMEOUT_DEFAULT * 1000;

  switch (in.direction) {
    case ata_cmd_in::no_data:
      req.flags = ATACMD_READREG;
      break;
    case ata_cmd_in::data_in:
      req.flags = ATACMD_READ | ATACMD_READREG;
      req.databuf = (char *)in.buffer;
      req.datalen = in.size;
      break;
    case ata_cmd_in::data_out:
      req.flags = ATACMD_WRITE | ATACMD_READREG;
      req.databuf = (char *)in.buffer;
      req.datalen = in.size;
      break;
    default:
      return set_err(ENOSYS);
191
  }
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

  clear_err();
  errno = 0;
  if (do_cmd(&req, in.in_regs.is_48bit_cmd()))
      return false;
  if (req.retsts != ATACMD_OK)
      return set_err(EIO, "request failed, error code 0x%02x", req.retsts);

  out.out_regs.error = req.error;
  out.out_regs.sector_count = req.sec_count;
  out.out_regs.lba_low = req.sec_num;
  out.out_regs.device = req.head;
  out.out_regs.lba_mid = req.cylinder;
  out.out_regs.lba_high = req.cylinder >> 8;
  out.out_regs.status = req.command;

  return true;
209
210
}

211
212
213
214
215
216
217
218
219
220
/////////////////////////////////////////////////////////////////////////////
/// Standard SCSI support

class openbsd_scsi_device
: public /*implements*/ scsi_device,
  public /*extends*/ openbsd_smart_device
{
public:
  openbsd_scsi_device(smart_interface * intf, const char * dev_name, const char * req_type, bool scanning = false);

221
  virtual smart_device * autodetect_open() override;
222

223
  virtual bool scsi_pass_through(scsi_cmnd_io * iop) override;
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246

private:
  bool m_scanning; ///< true if created within scan_smart_devices
};

openbsd_scsi_device::openbsd_scsi_device(smart_interface * intf,
  const char * dev_name, const char * req_type, bool scanning /* = false */)
: smart_device(intf, dev_name, "scsi", req_type),
  openbsd_smart_device(),
  m_scanning(scanning)
{
}

bool openbsd_scsi_device::scsi_pass_through(scsi_cmnd_io * iop)
{
  struct scsireq sc;
  int fd = get_fd();

  if (scsi_debugmode) {
    unsigned int k;
    const unsigned char * ucp = iop->cmnd;
    const char * np;

247
    np = scsi_get_opcode_name(ucp[0], false, 0);
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
    pout(" [%s: ", np ? np : "<unknown opcode>");
    for (k = 0; k < iop->cmnd_len; ++k)
      pout("%02x ", ucp[k]);
    if ((scsi_debugmode > 1) &&
      (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
    int trunc = (iop->dxfer_len > 256) ? 1 : 0;

    pout("]\n  Outgoing data, len=%d%s:\n", (int)iop->dxfer_len,
      (trunc ? " [only first 256 bytes shown]" : ""));
    dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len) , 1);
      }
      else
        pout("]\n");
  }

  memset(&sc, 0, sizeof(sc));
  memcpy(sc.cmd, iop->cmnd, iop->cmnd_len);
  sc.cmdlen = iop->cmnd_len;
  sc.databuf = (char *)iop->dxferp;
  sc.datalen = iop->dxfer_len;
  sc.senselen = iop->max_sense_len;
269
  sc.timeout = (iop->timeout == 0 ? 60 : iop->timeout) * 1000;
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
  sc.flags =
    (iop->dxfer_dir == DXFER_NONE ? SCCMD_READ :
    (iop->dxfer_dir == DXFER_FROM_DEVICE ? SCCMD_READ : SCCMD_WRITE));

  if (ioctl(fd, SCIOCCOMMAND, &sc) < 0) {
    if (scsi_debugmode) {
      pout("  error sending SCSI ccb\n");
    }
    return set_err(EIO);
  }
  iop->resid = sc.datalen - sc.datalen_used;
  iop->scsi_status = sc.status;
  if (iop->sensep) {
    memcpy(iop->sensep, sc.sense, sc.senselen_used);
    iop->resp_sense_len = sc.senselen_used;
  }
  if (scsi_debugmode) {
    int trunc;

    pout("  status=0\n");
    trunc = (iop->dxfer_len > 256) ? 1 : 0;

    pout("  Incoming data, len=%d%s:\n", (int) iop->dxfer_len,
      (trunc ? " [only first 256 bytes shown]" : ""));
    dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
  }
  // XXX we probably need error handling here
  return true;
}
299

300
301
302
303
/////////////////////////////////////////////////////////////////////////////
///// SCSI open with autodetection support

smart_device * openbsd_scsi_device::autodetect_open()
304
{
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
  // Open device
  if (!open())
    return this;

  // No Autodetection if device type was specified by user
  bool sat_only = false;
  if (*get_req_type()) {
    // Detect SAT if device object was created by scan_smart_devices().
    if (!(m_scanning && !strcmp(get_req_type(), "sat")))
      return this;
    sat_only = true;
  }

  // The code below is based on smartd.cpp:SCSIFilterKnown()

  // Get INQUIRY
  unsigned char req_buff[64] = {0, };
  int req_len = 36;
  if (scsiStdInquiry(this, req_buff, req_len)) {
    // Marvell controllers fail on a 36 bytes StdInquiry, but 64 suffices
    // watch this spot ... other devices could lock up here
    req_len = 64;
    if (scsiStdInquiry(this, req_buff, req_len)) {
      // device doesn't like INQUIRY commands
      close();
      set_err(EIO, "INQUIRY failed");
      return this;
    }
  }

  int avail_len = req_buff[4] + 5;
  int len = (avail_len < req_len ? avail_len : req_len);
  if (len < 36) {
    if (sat_only) {
      close();
      set_err(EIO, "INQUIRY too short for SAT");
    }
    return this;
  }

  // Use INQUIRY to detect type

  // SAT or USB, skip MFI controllers because of bugs
  {
    smart_device * newdev = smi()->autodetect_sat_device(this, req_buff, len);
    if (newdev) {
      // NOTE: 'this' is now owned by '*newdev'
      return newdev;
    }
  }
355

356
  // Nothing special found
357

358
359
360
  if (sat_only) {
    close();
    set_err(EIO, "Not a SAT device");
361
  }
362
363
364
365
366
367
368
369
370
371
  return this;
}

/////////////////////////////////////////////////////////////////////////////
/// Implement platform interface with old functions.

class openbsd_smart_interface
: public /*implements*/ smart_interface
{
public:
372
  virtual std::string get_os_version_str() override;
373

374
  virtual std::string get_app_examples(const char * appname) override;
375
376

  virtual bool scan_smart_devices(smart_device_list & devlist, const char * type,
377
    const char * pattern = 0) override;
378
379

protected:
380
  virtual ata_device * get_ata_device(const char * name, const char * type) override;
381

382
  virtual scsi_device * get_scsi_device(const char * name, const char * type) override;
383

384
  virtual smart_device * autodetect_smart_device(const char * name) override;
385

386
  virtual smart_device * get_custom_smart_device(const char * name, const char * type) override;
387

388
  virtual std::string get_valid_custom_dev_types_str() override;
389
390
391
392
393
394
395
396
397
398
399
400
401

private:
  int get_dev_names(char ***, const char *);
};


//////////////////////////////////////////////////////////////////////

std::string openbsd_smart_interface::get_os_version_str()
{
  struct utsname osname;
  uname(&osname);
  return strprintf("%s %s %s", osname.sysname, osname.release, osname.machine);
402
403
}

404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
std::string openbsd_smart_interface::get_app_examples(const char * appname)
{
  if (!strcmp(appname, "smartctl")) {
    char p;

    p = 'a' + getrawpartition();
    return strprintf(
      "=================================================== SMARTCTL EXAMPLES =====\n\n"
      "  smartctl -a /dev/wd0%c                      (Prints all SMART information)\n\n"
      "  smartctl --smart=on --offlineauto=on --saveauto=on /dev/wd0%c\n"
      "                                              (Enables SMART on first disk)\n\n"
      "  smartctl -t long /dev/wd0%c             (Executes extended disk self-test)\n\n"
      "  smartctl --attributes --log=selftest --quietmode=errorsonly /dev/wd0%c\n"
      "                                      (Prints Self-Test & Attribute errors)\n"
      "  smartctl -a /dev/wd0%c                     (Prints all SMART information)\n"
      "  smartctl -s on -o on -S on /dev/wd0%c        (Enables SMART on first disk)\n"
      "  smartctl -t long /dev/wd0%c            (Executes extended disk self-test)\n"
      "  smartctl -A -l selftest -q errorsonly /dev/wd0%c"
      "                                      (Prints Self-Test & Attribute errors)\n",
      p, p, p, p, p, p, p, p);
    }
    return "";
}
ata_device * openbsd_smart_interface::get_ata_device(const char * name, const char * type)
{
  return new openbsd_ata_device(this, name, type);
}

scsi_device * openbsd_smart_interface::get_scsi_device(const char * name, const char * type)
{
  return new openbsd_scsi_device(this, name, type);
}

int openbsd_smart_interface::get_dev_names(char ***names, const char *prefix)
438
439
440
441
442
443
444
445
446
447
448
449
450
451
{
  char *disknames, *p, **mp;
  int n = 0;
  int sysctl_mib[2];
  size_t sysctl_len;

  *names = NULL;

  sysctl_mib[0] = CTL_HW;
  sysctl_mib[1] = HW_DISKNAMES;
  if (-1 == sysctl(sysctl_mib, 2, NULL, &sysctl_len, NULL, 0)) {
    pout("Failed to get value of sysctl `hw.disknames'\n");
    return -1;
  }
452
  if (!(disknames = (char *)malloc(sysctl_len))) {
453
454
455
456
457
458
459
460
461
462
463
    pout("Out of memory constructing scan device list\n");
    return -1;
  }
  if (-1 == sysctl(sysctl_mib, 2, disknames, &sysctl_len, NULL, 0)) {
    pout("Failed to get value of sysctl `hw.disknames'\n");
    return -1;
  }
  if (!(mp = (char **) calloc(strlen(disknames) / 2, sizeof(char *)))) {
    pout("Out of memory constructing scan device list\n");
    return -1;
  }
464

465
  for (p = strtok(disknames, ","); p; p = strtok(NULL, ",")) {
466
467
468
    if (strncmp(p, prefix, strlen(prefix))) {
      continue;
    }
469
470
471
    char * u = strchr(p, ':');
    if (u)
      *u = 0;
472
    mp[n] = (char *)malloc(strlen(net_dev_prefix) + strlen(p) + 2);
473
474
475
476
477
478
479
480
    if (!mp[n]) {
      pout("Out of memory constructing scan device list\n");
      return -1;
    }
    sprintf(mp[n], "%s%s%c", net_dev_prefix, p, 'a' + getrawpartition());
    n++;
  }

481
  char ** tmp = (char **)realloc(mp, n * (sizeof(char *)));
482
483
484
485
486
487
488
  if (NULL == tmp) {
    pout("Out of memory constructing scan device list\n");
    free(mp);
    return -1;
  }
  else
    mp = tmp;
489
490
491
492
493
  *names = mp;
  return n;
}


494
495
496
497
498
499
500
bool openbsd_smart_interface::scan_smart_devices(smart_device_list & devlist,
  const char * type, const char * pattern /*= 0*/)
  {
    if (pattern) {
      set_err(EINVAL, "DEVICESCAN with pattern not implemented yet");
      return false;
    }
501

502
503
    if (type == NULL)
      type = "";
504

505
506
    bool scan_ata = !*type || !strcmp(type, "ata");
    bool scan_scsi = !*type || !strcmp(type, "scsi") || !strcmp(type, "sat");
507

508
509
510
511
512
513
514
515
516
    // Make namelists
    char * * atanames = 0; int numata = 0;
    if (scan_ata) {
      numata = get_dev_names(&atanames, net_dev_ata_disk);
      if (numata < 0) {
        set_err(ENOMEM);
        return false;
      }
    }
517

518
519
520
521
522
523
524
525
526
527
528
529
530
531
    char * * scsinames = 0; int numscsi = 0;
    char * * scsitapenames = 0; int numscsitape = 0;
    if (scan_scsi) {
      numscsi = get_dev_names(&scsinames, net_dev_scsi_disk);
      if (numscsi < 0) {
        set_err(ENOMEM);
        return false;
      }
      numscsitape = get_dev_names(&scsitapenames, net_dev_scsi_tape);
      if (numscsitape < 0) {
        set_err(ENOMEM);
        return false;
      }
    }
532

533
534
535
536
537
538
539
540
541
    // Add to devlist
    int i;
    for (i = 0; i < numata; i++) {
      ata_device * atadev = get_ata_device(atanames[i], type);
      if (atadev)
        devlist.push_back(atadev);
      free(atanames[i]);
    }
    if(numata) free(atanames);
542

543
544
545
546
547
    for (i = 0; i < numscsi; i++) {
      scsi_device * scsidev = new openbsd_scsi_device(this, scsinames[i], type, true /*scanning*/);
      if (scsidev)
        devlist.push_back(scsidev);
      free(scsinames[i]);
548
    }
549
    if(numscsi) free(scsinames);
550

551
552
553
554
555
556
557
    for (i = 0; i < numscsitape; i++) {
      scsi_device * scsidev = get_scsi_device(scsitapenames[i], type);
      if (scsidev)
        devlist.push_back(scsidev);
      free(scsitapenames[i]);
    }
    if(numscsitape) free(scsitapenames);
558

559
    return true;
560
561
}

562
smart_device * openbsd_smart_interface::autodetect_smart_device(const char * name)
563
{
564
  const char * test_name = name;
565

566
567
568
  // if dev_name null, or string length zero
  if (!name || !*name)
    return 0;
569

570
571
572
573
574
575
576
577
578
579
  // Dereference symlinks
  struct stat st;
  std::string pathbuf;
  if (!lstat(name, &st) && S_ISLNK(st.st_mode)) {
    char * p = realpath(name, (char *)0);
    if (p) {
      pathbuf = p;
      free(p);
      test_name = pathbuf.c_str();
    }
580
581
  }

582
583
584
  if (str_starts_with(test_name, net_dev_prefix)) {
    test_name += strlen(net_dev_prefix);
    if (!strncmp(net_dev_ata_disk, test_name, strlen(net_dev_ata_disk)))
585
      return get_ata_device(name, "ata");
586
587
588
589
590
    if (!strncmp(net_dev_scsi_disk, test_name, strlen(net_dev_scsi_disk))) {
      // XXX Try to detect possible USB->(S)ATA bridge
      // XXX get USB vendor ID, product ID and version from sd(4)/umass(4).
      // XXX check sat device via get_usb_dev_type_by_id().

591
592
      // No USB bridge found, assume regular SCSI or SAT device
      return get_scsi_device(name, "");
593
594
    }
    if (!strncmp(net_dev_scsi_tape, test_name, strlen(net_dev_scsi_tape)))
595
      return get_scsi_device(name, "scsi");
596
  }
597
598
599
  // device type unknown
  return 0;
}
600
601


602
603
604
605
smart_device * openbsd_smart_interface::get_custom_smart_device(const char * name, const char * type)
{
  ARGUSED(name);
  ARGUSED(type);
606
607
608
  return 0;
}

609
610
611
612
613
614
615
616
617
618
619
std::string openbsd_smart_interface::get_valid_custom_dev_types_str()
{
  return "";
}

} // namespace

/////////////////////////////////////////////////////////////////////////////
/// Initialize platform interface and register with smi()

void smart_interface::init()
620
{
621
622
  static os_openbsd::openbsd_smart_interface the_interface;
  smart_interface::set(&the_interface);
623
}