?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dhcpcd: update README.DRAGONFLY
[dragonfly.git] / sbin / natacontrol / natacontrol.c
blobafadbb070d54ca53ef5dadb26a585e8d66be4caf
1 /*-
2 * Copyright (c) 2000 - 2006 Søren Schmidt <sos@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * without modification, immediately at the beginning of the file.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * $FreeBSD: src/sbin/atacontrol/atacontrol.c,v 1.42 2006/03/15 19:32:43 sos Exp $
27 */
28
29 #include <sys/nata.h>
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <fcntl.h>
35 #include <errno.h>
36 #include <err.h>
37
38 #include <sysexits.h>
39 #include <unistd.h>
40
41 static const char *
42 mode2str(int mode)
43 {
44 switch (mode & 0xff) {
45 case ATA_PIO: return "BIOSPIO";
46 case ATA_PIO0: return "PIO0";
47 case ATA_PIO1: return "PIO1";
48 case ATA_PIO2: return "PIO2";
49 case ATA_PIO3: return "PIO3";
50 case ATA_PIO4: return "PIO4";
51 case ATA_WDMA0: return "WDMA0";
52 case ATA_WDMA1: return "WDMA1";
53 case ATA_WDMA2: return "WDMA2";
54 case ATA_UDMA0: return "UDMA0";
55 case ATA_UDMA1: return "UDMA1";
56 case ATA_UDMA2: return "UDMA33";
57 case ATA_UDMA3: return "UDMA44";
58 case ATA_UDMA4: return "UDMA66";
59 case ATA_UDMA5: return "UDMA100";
60 case ATA_UDMA6: return "UDMA133";
61 case ATA_SA150: return "SATA150";
62 case ATA_SA300: return "SATA300";
63 case ATA_USB: return "USB";
64 case ATA_USB1: return "USB1";
65 case ATA_USB2: return "USB2";
66 case ATA_DMA: return "BIOSDMA";
67 default: return "???";
68 }
69 }
70
71 static const char *
72 satarev2str(int mode)
73 {
74 switch ((mode & 0xff00) >> 8) {
75 case 0: return "";
76 case 1: return "SATA 1.5Gb/s";
77 case 2: return "SATA 3Gb/s";
78 case 3: return "SATA 6Gb/s";
79 case 0xff: return "SATA";
80 default: return "???";
81 }
82 }
83
84 static int
85 str2mode(char *str)
86 {
87 if (!strcasecmp(str, "BIOSPIO")) return ATA_PIO;
88 if (!strcasecmp(str, "PIO0")) return ATA_PIO0;
89 if (!strcasecmp(str, "PIO1")) return ATA_PIO1;
90 if (!strcasecmp(str, "PIO2")) return ATA_PIO2;
91 if (!strcasecmp(str, "PIO3")) return ATA_PIO3;
92 if (!strcasecmp(str, "PIO4")) return ATA_PIO4;
93 if (!strcasecmp(str, "WDMA0")) return ATA_WDMA0;
94 if (!strcasecmp(str, "WDMA1")) return ATA_WDMA1;
95 if (!strcasecmp(str, "WDMA2")) return ATA_WDMA2;
96 if (!strcasecmp(str, "UDMA0")) return ATA_UDMA0;
97 if (!strcasecmp(str, "UDMA16")) return ATA_UDMA0;
98 if (!strcasecmp(str, "UDMA1")) return ATA_UDMA1;
99 if (!strcasecmp(str, "UDMA25")) return ATA_UDMA1;
100 if (!strcasecmp(str, "UDMA2")) return ATA_UDMA2;
101 if (!strcasecmp(str, "UDMA33")) return ATA_UDMA2;
102 if (!strcasecmp(str, "UDMA3")) return ATA_UDMA3;
103 if (!strcasecmp(str, "UDMA44")) return ATA_UDMA3;
104 if (!strcasecmp(str, "UDMA4")) return ATA_UDMA4;
105 if (!strcasecmp(str, "UDMA66")) return ATA_UDMA4;
106 if (!strcasecmp(str, "UDMA5")) return ATA_UDMA5;
107 if (!strcasecmp(str, "UDMA100")) return ATA_UDMA5;
108 if (!strcasecmp(str, "UDMA6")) return ATA_UDMA6;
109 if (!strcasecmp(str, "UDMA133")) return ATA_UDMA6;
110 if (!strcasecmp(str, "BIOSDMA")) return ATA_DMA;
111 return -1;
112 }
113
114 static void
115 usage(void)
116 {
117 fprintf(stderr,
118 "usage: natacontrol <command> args:\n"
119 " natacontrol list\n"
120 " natacontrol info channel\n"
121 " natacontrol attach channel\n"
122 " natacontrol detach channel\n"
123 " natacontrol reinit channel\n"
124 " natacontrol create type [interleave] disk0 ... diskN\n"
125 " natacontrol delete array\n"
126 " natacontrol addspare array disk\n"
127 " natacontrol rebuild array\n"
128 " natacontrol status array\n"
129 " natacontrol mode device [mode]\n"
130 " natacontrol feature device apm apmlevel\n"
131 " natacontrol feature device acoustic soundsupplevel\n"
132 " natacontrol cap device\n"
133 " natacontrol spindown device [seconds]\n"
134 );
135 exit(EX_USAGE);
136 }
137
138 static int
139 version(int ver)
140 {
141 int bit;
142
143 if (ver == 0xffff)
144 return 0;
145 for (bit = 15; bit >= 0; bit--)
146 if (ver & (1<<bit))
147 return bit;
148 return 0;
149 }
150
151 static void
152 param_print(struct ata_params *parm)
153 {
154 printf("<%.40s/%.8s> ", parm->model, parm->revision);
155 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
156 if (parm->satacapabilities & ATA_SATA_GEN2)
157 printf("SATA revision 2.x\n");
158 else if (parm->satacapabilities & ATA_SATA_GEN1)
159 printf("SATA revision 1.x\n");
160 else
161 printf("Unknown SATA revision\n");
162 }
163 else
164 printf("ATA/ATAPI revision %d\n", version(parm->version_major));
165 }
166
167 static void
168 cap_print(struct ata_params *parm)
169 {
170 u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
171 ((u_int32_t)parm->lba_size_2 << 16);
172
173 u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
174 ((u_int64_t)parm->lba_size48_2 << 16) |
175 ((u_int64_t)parm->lba_size48_3 << 32) |
176 ((u_int64_t)parm->lba_size48_4 << 48);
177
178 printf("\n");
179 printf("Protocol ");
180 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
181 if (parm->satacapabilities & ATA_SATA_GEN2)
182 printf("SATA revision 2.x\n");
183 else if (parm->satacapabilities & ATA_SATA_GEN1)
184 printf("SATA revision 1.x\n");
185 else
186 printf("Unknown SATA revision\n");
187 }
188 else
189 printf("ATA/ATAPI revision %d\n", version(parm->version_major));
190 printf("device model %.40s\n", parm->model);
191 printf("serial number %.20s\n", parm->serial);
192 printf("firmware revision %.8s\n", parm->revision);
193
194 printf("cylinders %d\n", parm->cylinders);
195 printf("heads %d\n", parm->heads);
196 printf("sectors/track %d\n", parm->sectors);
197
198 printf("lba%ssupported ",
199 parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not ");
200 if (lbasize)
201 printf("%d sectors\n", lbasize);
202 else
203 printf("\n");
204
205 printf("lba48%ssupported ",
206 parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not ");
207 if (lbasize48)
208 printf("%ju sectors\n", (uintmax_t)lbasize48);
209 else
210 printf("\n");
211
212 printf("dma%ssupported\n",
213 parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not ");
214
215 printf("overlap%ssupported\n",
216 parm->capabilities1 & ATA_SUPPORT_OVERLAP ? " " : " not ");
217
218 printf("\nFeature "
219 "Support Enable Value Vendor\n");
220
221 printf("write cache %s %s\n",
222 parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no",
223 parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no");
224
225 printf("read ahead %s %s\n",
226 parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no",
227 parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no");
228
229 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
230 printf("Native Command Queuing (NCQ) %s %s"
231 " %d/0x%02X\n",
232 parm->satacapabilities & ATA_SUPPORT_NCQ ?
233 "yes" : "no", " -",
234 (parm->satacapabilities & ATA_SUPPORT_NCQ) ?
235 ATA_QUEUE_LEN(parm->queue) : 0,
236 (parm->satacapabilities & ATA_SUPPORT_NCQ) ?
237 ATA_QUEUE_LEN(parm->queue) : 0);
238 }
239 printf("Tagged Command Queuing (TCQ) %s %s %d/0x%02X\n",
240 parm->support.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
241 parm->enabled.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
242 ATA_QUEUE_LEN(parm->queue), ATA_QUEUE_LEN(parm->queue));
243
244 printf("SMART %s %s\n",
245 parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no",
246 parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no");
247
248 printf("microcode download %s %s\n",
249 parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no",
250 parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no");
251
252 printf("security %s %s\n",
253 parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no",
254 parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no");
255
256 printf("power management %s %s\n",
257 parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no",
258 parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no");
259
260 printf("advanced power management %s %s %d/0x%02X\n",
261 parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no",
262 parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no",
263 parm->apm_value, parm->apm_value);
264
265 printf("automatic acoustic management %s %s "
266 "%d/0x%02X %d/0x%02X\n",
267 parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
268 parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
269 ATA_ACOUSTIC_CURRENT(parm->acoustic),
270 ATA_ACOUSTIC_CURRENT(parm->acoustic),
271 ATA_ACOUSTIC_VENDOR(parm->acoustic),
272 ATA_ACOUSTIC_VENDOR(parm->acoustic));
273 }
274
275 static void
276 ata_cap_print(int fd)
277 {
278 struct ata_params params;
279
280 if (ioctl(fd, IOCATAGPARM, &params) < 0)
281 err(1, "ioctl(IOCATAGPARM)");
282 cap_print(&params);
283 }
284
285 static void
286 info_print(int fd, int channel, int prchan)
287 {
288 struct ata_ioc_devices devices;
289
290 devices.channel = channel;
291
292 if (ioctl(fd, IOCATADEVICES, &devices) < 0) {
293 if (!prchan)
294 err(1, "ioctl(IOCATADEVICES)");
295 return;
296 }
297 if (prchan)
298 printf("ATA channel %d:\n", channel);
299 printf("%sMaster: ", prchan ? " " : "");
300 if (*devices.name[0]) {
301 printf("%4.4s ", devices.name[0]);
302 param_print(&devices.params[0]);
303 }
304 else
305 printf(" no device present\n");
306 printf("%sSlave: ", prchan ? " " : "");
307 if (*devices.name[1]) {
308 printf("%4.4s ", devices.name[1]);
309 param_print(&devices.params[1]);
310 }
311 else
312 printf(" no device present\n");
313 }
314
315 static void
316 ata_spindown(int fd, const char *dev, const char *arg)
317 {
318 int tmo;
319
320 if (arg != NULL) {
321 tmo = strtoul(arg, NULL, 0);
322 if (ioctl(fd, IOCATASSPINDOWN, &tmo) < 0)
323 err(1, "ioctl(IOCATASSPINDOWN)");
324 } else {
325 if (ioctl(fd, IOCATAGSPINDOWN, &tmo) < 0)
326 err(1, "ioctl(IOCATAGSPINDOWN)");
327 if (tmo == 0)
328 printf("%s: idle spin down disabled\n", dev);
329 else
330 printf("%s: spin down after %d seconds idle\n",
331 dev, tmo);
332 }
333 }
334
335 static int
336 open_dev(const char *arg, int mode)
337 {
338 int disk, fd;
339 char device[64];
340
341 if (!(sscanf(arg, "ad%d", &disk) == 1 ||
342 sscanf(arg, "acd%d", &disk) == 1 ||
343 sscanf(arg, "afd%d", &disk) == 1 ||
344 sscanf(arg, "ast%d", &disk) == 1)) {
345 fprintf(stderr, "natacontrol: Invalid device %s\n", arg);
346 exit(EX_USAGE);
347 }
348 sprintf(device, "/dev/%s", arg);
349 if ((fd = open(device, mode)) < 0)
350 err(1, "device not found");
351 return (fd);
352 }
353
354 static int
355 ar_arg(const char *arg)
356 {
357 int array;
358
359 if (!(sscanf(arg, "ar%d", &array) == 1)) {
360 fprintf(stderr, "natacontrol: Invalid array %s\n", arg);
361 exit(EX_USAGE);
362 }
363 return (array);
364 }
365
366 static int
367 ata_arg(const char *arg)
368 {
369 int channel;
370
371 if (!(sscanf(arg, "ata%d", &channel) == 1)) {
372 fprintf(stderr, "natacontrol: Invalid channel %s\n", arg);
373 exit(EX_USAGE);
374 }
375 return (channel);
376 }
377
378 int
379 main(int argc, char **argv)
380 {
381 int fd, mode, channel, array;
382
383 if (argc < 2)
384 usage();
385
386 if (!strcmp(argv[1], "mode") && (argc == 3 || argc == 4)) {
387 fd = open_dev(argv[2], O_RDONLY);
388 if (argc == 4) {
389 mode = str2mode(argv[3]);
390 if (mode == -1)
391 errx(1, "unknown mode");
392 if (ioctl(fd, IOCATASMODE, &mode) < 0)
393 warn("ioctl(IOCATASMODE)");
394 }
395 if (argc == 3 || argc == 4) {
396 if (ioctl(fd, IOCATAGMODE, &mode) < 0)
397 err(1, "ioctl(IOCATAGMODE)");
398 printf("current mode = %s %s\n",
399 mode2str(mode), satarev2str(mode));
400 }
401 exit(EX_OK);
402 }
403 if (!strcmp(argv[1], "feature") && argc == 5) {
404 struct ata_ioc_request request;
405
406 fd = open_dev(argv[2], O_RDONLY);
407
408 bzero(&request, sizeof(struct ata_ioc_request));
409 request.u.ata.command = ATA_SETFEATURES;
410 request.flags = ATA_CMD_CONTROL;
411 request.timeout = 500;
412 if (!strcmp(argv[3], "apm")) {
413 if (!strcmp(argv[4], "off")) {
414 request.u.ata.feature = ATA_SF_DIS_APM;
415 } else if (!strcmp(argv[4], "maxperf")) {
416 request.u.ata.feature = ATA_SF_ENAB_APM;
417 request.u.ata.count = 0xfe;
418 } else if (!strcmp(argv[4], "minpower")) {
419 request.u.ata.feature = ATA_SF_ENAB_APM;
420 request.u.ata.count = 0x01;
421 } else {
422 int offset = 0;
423
424 request.u.ata.feature = ATA_SF_ENAB_APM;
425 if (argv[4][0] == 's') {
426 offset = atoi(&argv[4][1]);
427 request.u.ata.count = 0x01;
428 } else {
429 offset = atoi(&argv[4][1]);
430 request.u.ata.count = 0x80;
431 }
432 if (offset >= 0 && offset <= 127)
433 request.u.ata.count += offset;
434 }
435 } else if (!strcmp(argv[3], "acoustic")) {
436 if (!strcmp(argv[4], "off")) {
437 request.u.ata.feature = ATA_SF_DIS_ACCOUS;
438 } else if (!strcmp(argv[4], "maxperf")) {
439 request.u.ata.feature = ATA_SF_ENAB_ACCOUS;
440 request.u.ata.count = 0xfe;
441 } else if (!strcmp(argv[4], "maxquiet")) {
442 request.u.ata.feature = ATA_SF_ENAB_ACCOUS;
443 request.u.ata.count = 0x80;
444 } else {
445 request.u.ata.feature = ATA_SF_ENAB_ACCOUS;
446 request.u.ata.count = atoi(argv[4]);
447 if (request.u.ata.count > 124)
448 request.u.ata.count = 124;
449 }
450 } else {
451 usage();
452 }
453
454 if (ioctl(fd, IOCATAREQUEST, &request) < 0)
455 err(1, "ioctl(IOCATAREQUEST)");
456
457 if (request.error != 0) {
458 fprintf(stderr,
459 "IOCATAREQUEST returned err status %d",
460 request.error);
461 exit(EX_IOERR);
462 }
463 exit(EX_OK);
464 }
465 if (!strcmp(argv[1], "cap") && argc == 3) {
466 fd = open_dev(argv[2], O_RDONLY);
467 ata_cap_print(fd);
468 exit(EX_OK);
469 }
470
471 if (!strcmp(argv[1], "spindown") && (argc == 3 || argc == 4)) {
472 fd = open_dev(argv[2], O_RDONLY);
473 ata_spindown(fd, argv[2], argv[3]);
474 exit(EX_OK);
475 }
476
477 if ((fd = open("/dev/ata", O_RDWR)) < 0)
478 err(1, "control device not found");
479
480 if (!strcmp(argv[1], "list") && argc == 2) {
481 int maxchannel;
482
483 if (ioctl(fd, IOCATAGMAXCHANNEL, &maxchannel) < 0)
484 err(1, "ioctl(IOCATAGMAXCHANNEL)");
485 for (channel = 0; channel < maxchannel; channel++)
486 info_print(fd, channel, 1);
487 exit(EX_OK);
488 }
489 if (!strcmp(argv[1], "info") && argc == 3) {
490 channel = ata_arg(argv[2]);
491 info_print(fd, channel, 0);
492 exit(EX_OK);
493 }
494 if (!strcmp(argv[1], "detach") && argc == 3) {
495 channel = ata_arg(argv[2]);
496 if (ioctl(fd, IOCATADETACH, &channel) < 0)
497 err(1, "ioctl(IOCATADETACH)");
498 exit(EX_OK);
499 }
500 if (!strcmp(argv[1], "attach") && argc == 3) {
501 channel = ata_arg(argv[2]);
502 if (ioctl(fd, IOCATAATTACH, &channel) < 0)
503 err(1, "ioctl(IOCATAATTACH)");
504 info_print(fd, channel, 0);
505 exit(EX_OK);
506 }
507 if (!strcmp(argv[1], "reinit") && argc == 3) {
508 channel = ata_arg(argv[2]);
509 if (ioctl(fd, IOCATAREINIT, &channel) < 0)
510 warn("ioctl(IOCATAREINIT)");
511 info_print(fd, channel, 0);
512 exit(EX_OK);
513 }
514 if (!strcmp(argv[1], "create")) {
515 int disk, dev, offset;
516 struct ata_ioc_raid_config config;
517
518 bzero(&config, sizeof(config));
519 if (argc > 2) {
520 if (!strcasecmp(argv[2], "RAID0") ||
521 !strcasecmp(argv[2], "stripe"))
522 config.type = AR_RAID0;
523 if (!strcasecmp(argv[2], "RAID1") ||
524 !strcasecmp(argv[2],"mirror"))
525 config.type = AR_RAID1;
526 if (!strcasecmp(argv[2], "RAID0+1") ||
527 !strcasecmp(argv[2],"RAID10"))
528 config.type = AR_RAID01;
529 if (!strcasecmp(argv[2], "RAID5"))
530 config.type = AR_RAID5;
531 if (!strcasecmp(argv[2], "SPAN"))
532 config.type = AR_SPAN;
533 if (!strcasecmp(argv[2], "JBOD"))
534 config.type = AR_JBOD;
535 }
536 if (!config.type) {
537 fprintf(stderr, "natacontrol: Invalid RAID type %s\n",
538 argv[2]);
539 fprintf(stderr, "natacontrol: Valid RAID types: \n");
540 fprintf(stderr, " stripe | mirror | "
541 "RAID0 | RAID1 | RAID0+1 | RAID5 | "
542 "SPAN | JBOD\n");
543 exit(EX_USAGE);
544 }
545
546 if (config.type == AR_RAID0 ||
547 config.type == AR_RAID01 ||
548 config.type == AR_RAID5) {
549 if (argc < 4 ||
550 sscanf(argv[3], "%d", &config.interleave) != 1) {
551 fprintf(stderr,
552 "natacontrol: Invalid interleave %s\n",
553 argv[3]);
554 exit(EX_USAGE);
555 }
556 offset = 4;
557 }
558 else
559 offset = 3;
560
561 for (disk = 0; disk < 16 && (offset + disk) < argc; disk++) {
562 if (!(sscanf(argv[offset + disk], "ad%d", &dev) == 1)) {
563 fprintf(stderr,
564 "natacontrol: Invalid disk %s\n",
565 argv[offset + disk]);
566 exit(EX_USAGE);
567 }
568 config.disks[disk] = dev;
569 }
570
571 if ((config.type == AR_RAID1 || config.type == AR_RAID01) &&
572 disk < 2) {
573 fprintf(stderr, "natacontrol: At least 2 disks must be "
574 "specified\n");
575 exit(EX_USAGE);
576 }
577
578 config.total_disks = disk;
579 if (ioctl(fd, IOCATARAIDCREATE, &config) < 0)
580 err(1, "ioctl(IOCATARAIDCREATE)");
581 else
582 printf("ar%d created\n", config.lun);
583 exit(EX_OK);
584 }
585 if (!strcmp(argv[1], "delete") && argc == 3) {
586 array = ar_arg(argv[2]);
587 if (ioctl(fd, IOCATARAIDDELETE, &array) < 0)
588 warn("ioctl(IOCATARAIDDELETE)");
589 exit(EX_OK);
590 }
591 if (!strcmp(argv[1], "addspare") && argc == 4) {
592 struct ata_ioc_raid_config config;
593
594 config.lun = ar_arg(argv[2]);
595 if (!(sscanf(argv[3], "ad%d", &config.disks[0]) == 1)) {
596 fprintf(stderr,
597 "natacontrol: Invalid disk %s\n", argv[3]);
598 usage();
599 }
600 if (ioctl(fd, IOCATARAIDADDSPARE, &config) < 0)
601 warn("ioctl(IOCATARAIDADDSPARE)");
602 exit(EX_OK);
603 }
604 if (!strcmp(argv[1], "rebuild") && argc == 3) {
605 array = ar_arg(argv[2]);
606 if (ioctl(fd, IOCATARAIDREBUILD, &array) < 0)
607 warn("ioctl(IOCATARAIDREBUILD)");
608 else {
609 char device[64];
610 char *buffer;
611 ssize_t len;
612 int arfd;
613
614 if (daemon(0, 1) == -1)
615 err(1, "daemon");
616 nice(20);
617 snprintf(device, sizeof(device), "/dev/ar%d",
618 array);
619 if ((arfd = open(device, O_RDONLY)) == -1)
620 err(1, "open %s", device);
621 if ((buffer = malloc(1024 * 1024)) == NULL)
622 err(1, "malloc");
623 while ((len = read(arfd, buffer, 1024 * 1024)) > 0)
624 ;
625 if (len == -1)
626 err(1, "read");
627 else
628 fprintf(stderr,
629 "natacontrol: ar%d rebuild completed\n",
630 array);
631 free(buffer);
632 close(arfd);
633 }
634 exit(EX_OK);
635 }
636 if (!strcmp(argv[1], "status") && argc == 3) {
637 struct ata_ioc_raid_status status;
638 int i, lun, state;
639
640 status.lun = ar_arg(argv[2]);
641 if (ioctl(fd, IOCATARAIDSTATUS, &status) < 0)
642 err(1, "ioctl(IOCATARAIDSTATUS)");
643
644 printf("ar%d: ATA ", status.lun);
645 switch (status.type) {
646 case AR_RAID0:
647 printf("RAID0 stripesize=%d", status.interleave);
648 break;
649 case AR_RAID1:
650 printf("RAID1");
651 break;
652 case AR_RAID01:
653 printf("RAID0+1 stripesize=%d", status.interleave);
654 break;
655 case AR_RAID5:
656 printf("RAID5 stripesize=%d", status.interleave);
657 break;
658 case AR_JBOD:
659 printf("JBOD");
660 break;
661 case AR_SPAN:
662 printf("SPAN");
663 break;
664 }
665 printf(" status: ");
666 switch (status.status) {
667 case AR_READY:
668 printf("READY\n");
669 break;
670 case AR_READY | AR_DEGRADED:
671 printf("DEGRADED\n");
672 break;
673 case AR_READY | AR_DEGRADED | AR_REBUILDING:
674 printf("REBUILDING %d%% completed\n",
675 status.progress);
676 break;
677 default:
678 printf("BROKEN\n");
679 }
680 printf(" subdisks:\n");
681 for (i = 0; i < status.total_disks; i++) {
682 printf(" %2d ", i);
683 lun = status.disks[i].lun;
684 state = status.disks[i].state;
685 if (lun < 0)
686 printf("---- ");
687 else
688 printf("ad%-2d ", lun);
689 if (state & AR_DISK_ONLINE)
690 printf("ONLINE");
691 else if (state & AR_DISK_SPARE)
692 printf("SPARE");
693 else if (state & AR_DISK_PRESENT)
694 printf("OFFLINE");
695 else
696 printf("MISSING");
697 printf("\n");
698 }
699 exit(EX_OK);
700 }
701 usage();
702 exit(EX_OK);
703 }
DragonFly BSD