Annotation of embedaddon/smartmontools/os_openbsd.cpp, revision 1.1.1.1
1.1 misho 1: /*
2: * os_openbsd.c
3: *
4: * Home page of code is: http://smartmontools.sourceforge.net
5: *
6: * Copyright (C) 2004-10 David Snyder <smartmontools-support@lists.sourceforge.net>
7: *
8: * Derived from os_netbsd.cpp by Sergey Svishchev <smartmontools-support@lists.sourceforge.net>, Copyright (C) 2003-8
9: *
10: * This program is free software; you can redistribute it and/or modify
11: * it under the terms of the GNU General Public License as published by
12: * the Free Software Foundation; either version 2, or (at your option)
13: * any later version.
14: *
15: * You should have received a copy of the GNU General Public License
16: * (for example COPYING); if not, write to the Free
17: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18: *
19: */
20:
21: #include "config.h"
22: #include "int64.h"
23: #include "atacmds.h"
24: #include "scsicmds.h"
25: #include "utility.h"
26: #include "os_openbsd.h"
27:
28: #include <errno.h>
29:
30: const char * os_openbsd_cpp_cvsid = "$Id: os_openbsd.cpp 3265 2011-02-21 16:21:14Z chrfranke $"
31: OS_OPENBSD_H_CVSID;
32:
33: /* global variable holding byte count of allocated memory */
34: extern long long bytes;
35:
36: enum warnings {
37: BAD_SMART, NO_3WARE, NO_ARECA, MAX_MSG
38: };
39:
40: /* Utility function for printing warnings */
41: void
42: printwarning(int msgNo, const char *extra)
43: {
44: static int printed[] = {0, 0};
45: static const char *message[] = {
46: "Error: SMART Status command failed.\nPlease get assistance from \n" PACKAGE_HOMEPAGE "\nRegister values returned from SMART Status command are:\n",
47: PACKAGE_STRING " does not currentlly support twe(4) devices (3ware Escalade)\n",
48: };
49:
50: if (msgNo >= 0 && msgNo <= MAX_MSG) {
51: if (!printed[msgNo]) {
52: printed[msgNo] = 1;
53: pout("%s", message[msgNo]);
54: if (extra)
55: pout("%s", extra);
56: }
57: }
58: return;
59: }
60:
61: static const char *net_dev_prefix = "/dev/";
62: static const char *net_dev_ata_disk = "wd";
63: static const char *net_dev_scsi_disk = "sd";
64: static const char *net_dev_scsi_tape = "st";
65:
66: /* Guess device type(ata or scsi) based on device name */
67: int
68: guess_device_type(const char *dev_name)
69: {
70: int len;
71: int dev_prefix_len = strlen(net_dev_prefix);
72:
73: if (!dev_name || !(len = strlen(dev_name)))
74: return CONTROLLER_UNKNOWN;
75:
76: if (!strncmp(net_dev_prefix, dev_name, dev_prefix_len)) {
77: if (len <= dev_prefix_len)
78: return CONTROLLER_UNKNOWN;
79: else
80: dev_name += dev_prefix_len;
81: }
82: if (!strncmp(net_dev_ata_disk, dev_name, strlen(net_dev_ata_disk)))
83: return CONTROLLER_ATA;
84:
85: if (!strncmp(net_dev_scsi_disk, dev_name, strlen(net_dev_scsi_disk)))
86: return CONTROLLER_SCSI;
87:
88: if (!strncmp(net_dev_scsi_tape, dev_name, strlen(net_dev_scsi_tape)))
89: return CONTROLLER_SCSI;
90:
91: return CONTROLLER_UNKNOWN;
92: }
93:
94: int
95: get_dev_names(char ***names, const char *prefix)
96: {
97: char *disknames, *p, **mp;
98: int n = 0;
99: int sysctl_mib[2];
100: size_t sysctl_len;
101:
102: *names = NULL;
103:
104: sysctl_mib[0] = CTL_HW;
105: sysctl_mib[1] = HW_DISKNAMES;
106: if (-1 == sysctl(sysctl_mib, 2, NULL, &sysctl_len, NULL, 0)) {
107: pout("Failed to get value of sysctl `hw.disknames'\n");
108: return -1;
109: }
110: if (!(disknames = (char *)malloc(sysctl_len))) {
111: pout("Out of memory constructing scan device list\n");
112: return -1;
113: }
114: if (-1 == sysctl(sysctl_mib, 2, disknames, &sysctl_len, NULL, 0)) {
115: pout("Failed to get value of sysctl `hw.disknames'\n");
116: return -1;
117: }
118: if (!(mp = (char **) calloc(strlen(disknames) / 2, sizeof(char *)))) {
119: pout("Out of memory constructing scan device list\n");
120: return -1;
121: }
122: for (p = strtok(disknames, ","); p; p = strtok(NULL, ",")) {
123: if (strncmp(p, prefix, strlen(prefix))) {
124: continue;
125: }
126: char * u = strchr(p, ':');
127: if (u)
128: *u = 0;
129: mp[n] = (char *)malloc(strlen(net_dev_prefix) + strlen(p) + 2);
130: if (!mp[n]) {
131: pout("Out of memory constructing scan device list\n");
132: return -1;
133: }
134: sprintf(mp[n], "%s%s%c", net_dev_prefix, p, 'a' + getrawpartition());
135: bytes += strlen(mp[n]) + 1;
136: n++;
137: }
138:
139: mp = (char **)realloc(mp, n * (sizeof(char *)));
140: bytes += (n) * (sizeof(char *));
141: *names = mp;
142: return n;
143: }
144:
145: int
146: make_device_names(char ***devlist, const char *name)
147: {
148: if (!strcmp(name, "SCSI"))
149: return get_dev_names(devlist, net_dev_scsi_disk);
150: else if (!strcmp(name, "ATA"))
151: return get_dev_names(devlist, net_dev_ata_disk);
152: else
153: return 0;
154: }
155:
156: int
157: deviceopen(const char *pathname, char *type)
158: {
159: if (!strcmp(type, "SCSI")) {
160: int fd = open(pathname, O_RDWR | O_NONBLOCK);
161: if (fd < 0 && errno == EROFS)
162: fd = open(pathname, O_RDONLY | O_NONBLOCK);
163: return fd;
164: } else if (!strcmp(type, "ATA"))
165: return open(pathname, O_RDWR | O_NONBLOCK);
166: else
167: return -1;
168: }
169:
170: int
171: deviceclose(int fd)
172: {
173: return close(fd);
174: }
175:
176: int
177: marvell_command_interface(int fd, smart_command_set command, int select, char *data)
178: { return -1; }
179:
180: int
181: highpoint_command_interface(int fd, smart_command_set command, int select, char *data)
182: { return -1; }
183:
184: int
185: ata_command_interface(int fd, smart_command_set command, int select, char *data)
186: {
187: struct atareq req;
188: unsigned char inbuf[DEV_BSIZE];
189: int retval, copydata = 0;
190:
191: memset(&req, 0, sizeof(req));
192: memset(&inbuf, 0, sizeof(inbuf));
193:
194: switch (command) {
195: case READ_VALUES:
196: req.flags = ATACMD_READ;
197: req.features = ATA_SMART_READ_VALUES;
198: req.command = ATAPI_SMART;
199: req.databuf = (caddr_t) inbuf;
200: req.datalen = sizeof(inbuf);
201: req.cylinder = htole16(WDSMART_CYL);
202: req.timeout = 1000;
203: copydata = 1;
204: break;
205: case READ_THRESHOLDS:
206: req.flags = ATACMD_READ;
207: req.features = ATA_SMART_READ_THRESHOLDS;
208: req.command = ATAPI_SMART;
209: req.databuf = (caddr_t) inbuf;
210: req.datalen = sizeof(inbuf);
211: req.cylinder = htole16(WDSMART_CYL);
212: req.timeout = 1000;
213: copydata = 1;
214: break;
215: case READ_LOG:
216: req.flags = ATACMD_READ;
217: req.features = ATA_SMART_READ_LOG_SECTOR; /* XXX missing from wdcreg.h */
218: req.command = ATAPI_SMART;
219: req.databuf = (caddr_t) inbuf;
220: req.datalen = sizeof(inbuf);
221: req.cylinder = htole16(WDSMART_CYL);
222: req.sec_num = select;
223: req.sec_count = 1;
224: req.timeout = 1000;
225: copydata = 1;
226: break;
227: case WRITE_LOG:
228: memcpy(inbuf, data, 512);
229: req.flags = ATACMD_WRITE;
230: req.features = ATA_SMART_WRITE_LOG_SECTOR; /* XXX missing from wdcreg.h */
231: req.command = ATAPI_SMART;
232: req.databuf = (caddr_t) inbuf;
233: req.datalen = sizeof(inbuf);
234: req.cylinder = htole16(WDSMART_CYL);
235: req.sec_num = select;
236: req.sec_count = 1;
237: req.timeout = 1000;
238: break;
239: case IDENTIFY:
240: req.flags = ATACMD_READ;
241: req.command = WDCC_IDENTIFY;
242: req.databuf = (caddr_t) inbuf;
243: req.datalen = sizeof(inbuf);
244: req.timeout = 1000;
245: copydata = 1;
246: break;
247: case PIDENTIFY:
248: req.flags = ATACMD_READ;
249: req.command = ATAPI_IDENTIFY_DEVICE;
250: req.databuf = (caddr_t) inbuf;
251: req.datalen = sizeof(inbuf);
252: req.timeout = 1000;
253: copydata = 1;
254: break;
255: case ENABLE:
256: req.flags = ATACMD_READ;
257: req.features = ATA_SMART_ENABLE;
258: req.command = ATAPI_SMART;
259: req.cylinder = htole16(WDSMART_CYL);
260: req.timeout = 1000;
261: break;
262: case DISABLE:
263: req.flags = ATACMD_READ;
264: req.features = ATA_SMART_DISABLE;
265: req.command = ATAPI_SMART;
266: req.cylinder = htole16(WDSMART_CYL);
267: req.timeout = 1000;
268: break;
269: case AUTO_OFFLINE:
270: /* NOTE: According to ATAPI 4 and UP, this command is obsolete */
271: req.flags = ATACMD_READ;
272: req.features = ATA_SMART_AUTO_OFFLINE; /* XXX missing from wdcreg.h */
273: req.command = ATAPI_SMART;
274: req.databuf = (caddr_t) inbuf;
275: req.datalen = sizeof(inbuf);
276: req.cylinder = htole16(WDSMART_CYL);
277: req.sec_num = select;
278: req.sec_count = 1;
279: req.timeout = 1000;
280: break;
281: case AUTOSAVE:
282: req.flags = ATACMD_READ;
283: req.features = ATA_SMART_AUTOSAVE; /* XXX missing from wdcreg.h */
284: req.command = ATAPI_SMART;
285: req.cylinder = htole16(WDSMART_CYL);
286: req.sec_count = 0xf1;
287: /* to enable autosave */
288: req.timeout = 1000;
289: break;
290: case IMMEDIATE_OFFLINE:
291: /* NOTE: According to ATAPI 4 and UP, this command is obsolete */
292: req.flags = ATACMD_READ;
293: req.features = ATA_SMART_IMMEDIATE_OFFLINE; /* XXX missing from wdcreg.h */
294: req.command = ATAPI_SMART;
295: req.databuf = (caddr_t) inbuf;
296: req.datalen = sizeof(inbuf);
297: req.cylinder = htole16(WDSMART_CYL);
298: req.sec_num = select;
299: req.sec_count = 1;
300: req.timeout = 1000;
301: break;
302: case STATUS_CHECK:
303: /* same command, no HDIO in NetBSD */
304: case STATUS:
305: req.flags = ATACMD_READ;
306: req.features = ATA_SMART_STATUS;
307: req.command = ATAPI_SMART;
308: req.cylinder = htole16(WDSMART_CYL);
309: req.timeout = 1000;
310: break;
311: case CHECK_POWER_MODE:
312: req.flags = ATACMD_READREG;
313: req.command = WDCC_CHECK_PWR;
314: req.timeout = 1000;
315: break;
316: default:
317: pout("Unrecognized command %d in ata_command_interface()\n", command);
318: errno = ENOSYS;
319: return -1;
320: }
321:
322: if (command == STATUS_CHECK) {
323: char buf[512];
324:
325: unsigned const short normal = WDSMART_CYL, failed = 0x2cf4;
326:
327: if ((retval = ioctl(fd, ATAIOCCOMMAND, &req))) {
328: perror("Failed command");
329: return -1;
330: }
331: /* Cyl low and Cyl high unchanged means "Good SMART status" */
332: if (letoh16(req.cylinder) == normal)
333: return 0;
334:
335: /* These values mean "Bad SMART status" */
336: if (letoh16(req.cylinder) == failed)
337: return 1;
338:
339: /* We haven't gotten output that makes sense;
340: * print out some debugging info */
341: snprintf(buf, sizeof(buf),
342: "CMD=0x%02x\nFR =0x%02x\nNS =0x%02x\nSC =0x%02x\nCL =0x%02x\nCH =0x%02x\nRETURN =0x%04x\n",
343: (int) req.command, (int) req.features, (int) req.sec_count, (int) req.sec_num,
344: (int) (letoh16(req.cylinder) & 0xff), (int) ((letoh16(req.cylinder) >> 8) & 0xff),
345: (int) req.error);
346: printwarning(BAD_SMART, buf);
347: return 0;
348: }
349: if ((retval = ioctl(fd, ATAIOCCOMMAND, &req))) {
350: perror("Failed command");
351: return -1;
352: }
353: if (command == CHECK_POWER_MODE)
354: data[0] = req.sec_count;
355:
356: if (copydata)
357: memcpy(data, inbuf, 512);
358:
359: return 0;
360: }
361:
362: int
363: escalade_command_interface(int fd, int disknum, int escalade_type, smart_command_set command, int select, char *data)
364: {
365: printwarning(NO_3WARE, NULL);
366: return -1;
367: }
368:
369: int
370: areca_command_interface(int fd, int disknum, smart_command_set command, int select, char *data)
371: {
372: printwarning(NO_ARECA, NULL);
373: return -1;
374: }
375:
376: int
377: do_scsi_cmnd_io(int fd, struct scsi_cmnd_io * iop, int report)
378: {
379: struct scsireq sc;
380:
381: if (report > 0) {
382: size_t k;
383:
384: const unsigned char *ucp = iop->cmnd;
385: const char *np;
386:
387: np = scsi_get_opcode_name(ucp[0]);
388: pout(" [%s: ", np ? np : "<unknown opcode>");
389: for (k = 0; k < iop->cmnd_len; ++k)
390: pout("%02x ", ucp[k]);
391: if ((report > 1) &&
392: (DXFER_TO_DEVICE == iop->dxfer_dir) && (iop->dxferp)) {
393: int trunc = (iop->dxfer_len > 256) ? 1 : 0;
394:
395: pout("]\n Outgoing data, len=%d%s:\n", (int) iop->dxfer_len,
396: (trunc ? " [only first 256 bytes shown]" : ""));
397: dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
398: } else
399: pout("]");
400: }
401: memset(&sc, 0, sizeof(sc));
402: memcpy(sc.cmd, iop->cmnd, iop->cmnd_len);
403: sc.cmdlen = iop->cmnd_len;
404: sc.databuf = (char *)iop->dxferp;
405: sc.datalen = iop->dxfer_len;
406: sc.senselen = iop->max_sense_len;
407: sc.timeout = iop->timeout == 0 ? 60000 : iop->timeout; /* XXX */
408: sc.flags =
409: (iop->dxfer_dir == DXFER_NONE ? SCCMD_READ :
410: (iop->dxfer_dir == DXFER_FROM_DEVICE ? SCCMD_READ : SCCMD_WRITE));
411:
412: if (ioctl(fd, SCIOCCOMMAND, &sc) < 0) {
413: warn("error sending SCSI ccb");
414: return -1;
415: }
416: iop->resid = sc.datalen - sc.datalen_used;
417: iop->scsi_status = sc.status;
418: if (iop->sensep) {
419: memcpy(iop->sensep, sc.sense, sc.senselen_used);
420: iop->resp_sense_len = sc.senselen_used;
421: }
422: if (report > 0) {
423: int trunc;
424:
425: pout(" status=0\n");
426: trunc = (iop->dxfer_len > 256) ? 1 : 0;
427:
428: pout(" Incoming data, len=%d%s:\n", (int) iop->dxfer_len,
429: (trunc ? " [only first 256 bytes shown]" : ""));
430: dStrHex(iop->dxferp, (trunc ? 256 : iop->dxfer_len), 1);
431: }
432: return 0;
433: }
434:
435: /* print examples for smartctl */
436: void
437: print_smartctl_examples()
438: {
439: char p;
440:
441: p = 'a' + getrawpartition();
442: printf("=================================================== SMARTCTL EXAMPLES =====\n\n");
443: #ifdef HAVE_GETOPT_LONG
444: printf(
445: " smartctl -a /dev/wd0%c (Prints all SMART information)\n\n"
446: " smartctl --smart=on --offlineauto=on --saveauto=on /dev/wd0%c\n"
447: " (Enables SMART on first disk)\n\n"
448: " smartctl -t long /dev/wd0%c (Executes extended disk self-test)\n\n"
449: " smartctl --attributes --log=selftest --quietmode=errorsonly /dev/wd0%c\n"
450: " (Prints Self-Test & Attribute errors)\n",
451: p, p, p, p
452: );
453: #else
454: printf(
455: " smartctl -a /dev/wd0%c (Prints all SMART information)\n"
456: " smartctl -s on -o on -S on /dev/wd0%c (Enables SMART on first disk)\n"
457: " smartctl -t long /dev/wd0%c (Executes extended disk self-test)\n"
458: " smartctl -A -l selftest -q errorsonly /dev/wd0%c"
459: " (Prints Self-Test & Attribute errors)\n",
460: p, p, p, p
461: );
462: #endif
463: return;
464: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to os_openbsd.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