?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sdhci - Implement ADMA2 transfer support. Keep SDMA support for now.
[dragonfly.git] / sbin / natacontrol / natacontrol.c
blob9ec113b468996f95797ca4a626f05be66fbb7f9f
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 *mode2str(int mode);
42 static int str2mode(char *str);
43 static void usage(void);
44 static int version(int ver);
45 static void param_print(struct ata_params *parm);
46 static void cap_print(struct ata_params *parm);
47 static int ata_cap_print(int fd);
48 static int info_print(int fd, int channel, int prchan);
49
50 const char *
51 mode2str(int mode)
52 {
53 switch (mode) {
54 case ATA_PIO: return "BIOSPIO";
55 case ATA_PIO0: return "PIO0";
56 case ATA_PIO1: return "PIO1";
57 case ATA_PIO2: return "PIO2";
58 case ATA_PIO3: return "PIO3";
59 case ATA_PIO4: return "PIO4";
60 case ATA_WDMA2: return "WDMA2";
61 case ATA_UDMA2: return "UDMA33";
62 case ATA_UDMA4: return "UDMA66";
63 case ATA_UDMA5: return "UDMA100";
64 case ATA_UDMA6: return "UDMA133";
65 case ATA_SA150: return "SATA150";
66 case ATA_SA300: return "SATA300";
67 case ATA_USB: return "USB";
68 case ATA_USB1: return "USB1";
69 case ATA_USB2: return "USB2";
70 case ATA_DMA: return "BIOSDMA";
71 default: return "???";
72 }
73 }
74
75 int
76 str2mode(char *str)
77 {
78 if (!strcasecmp(str, "BIOSPIO")) return ATA_PIO;
79 if (!strcasecmp(str, "PIO0")) return ATA_PIO0;
80 if (!strcasecmp(str, "PIO1")) return ATA_PIO1;
81 if (!strcasecmp(str, "PIO2")) return ATA_PIO2;
82 if (!strcasecmp(str, "PIO3")) return ATA_PIO3;
83 if (!strcasecmp(str, "PIO4")) return ATA_PIO4;
84 if (!strcasecmp(str, "WDMA2")) return ATA_WDMA2;
85 if (!strcasecmp(str, "UDMA2")) return ATA_UDMA2;
86 if (!strcasecmp(str, "UDMA33")) return ATA_UDMA2;
87 if (!strcasecmp(str, "UDMA4")) return ATA_UDMA4;
88 if (!strcasecmp(str, "UDMA66")) return ATA_UDMA4;
89 if (!strcasecmp(str, "UDMA5")) return ATA_UDMA5;
90 if (!strcasecmp(str, "UDMA100")) return ATA_UDMA5;
91 if (!strcasecmp(str, "UDMA6")) return ATA_UDMA6;
92 if (!strcasecmp(str, "UDMA133")) return ATA_UDMA6;
93 if (!strcasecmp(str, "BIOSDMA")) return ATA_DMA;
94 return -1;
95 }
96
97 void
98 usage(void)
99 {
100 fprintf(stderr,
101 "usage: natacontrol <command> args:\n"
102 " natacontrol list\n"
103 " natacontrol info channel\n"
104 " natacontrol attach channel\n"
105 " natacontrol detach channel\n"
106 " natacontrol reinit channel\n"
107 " natacontrol create type [interleave] disk0 ... diskN\n"
108 " natacontrol delete array\n"
109 " natacontrol addspare array disk\n"
110 " natacontrol rebuild array\n"
111 " natacontrol status array\n"
112 " natacontrol mode device [mode]\n"
113 " natacontrol feature device apm apmlevel\n"
114 " natacontrol feature device acoustic soundsupplevel\n"
115 " natacontrol cap device\n"
116 );
117 exit(EX_USAGE);
118 }
119
120 int
121 version(int ver)
122 {
123 int bit;
124
125 if (ver == 0xffff)
126 return 0;
127 for (bit = 15; bit >= 0; bit--)
128 if (ver & (1<<bit))
129 return bit;
130 return 0;
131 }
132
133 void
134 param_print(struct ata_params *parm)
135 {
136 printf("<%.40s/%.8s> ", parm->model, parm->revision);
137 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
138 if (parm->satacapabilities & ATA_SATA_GEN2)
139 printf("Serial ATA II\n");
140 else if (parm->satacapabilities & ATA_SATA_GEN1)
141 printf("Serial ATA v1.0\n");
142 else
143 printf("Unknown serial ATA version\n");
144 }
145 else
146 printf("ATA/ATAPI revision %d\n", version(parm->version_major));
147 }
148
149 void
150 cap_print(struct ata_params *parm)
151 {
152 u_int32_t lbasize = (u_int32_t)parm->lba_size_1 |
153 ((u_int32_t)parm->lba_size_2 << 16);
154
155 u_int64_t lbasize48 = ((u_int64_t)parm->lba_size48_1) |
156 ((u_int64_t)parm->lba_size48_2 << 16) |
157 ((u_int64_t)parm->lba_size48_3 << 32) |
158 ((u_int64_t)parm->lba_size48_4 << 48);
159
160 printf("\n");
161 printf("Protocol ");
162 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
163 if (parm->satacapabilities & ATA_SATA_GEN2)
164 printf("Serial ATA II\n");
165 else if (parm->satacapabilities & ATA_SATA_GEN1)
166 printf("Serial ATA v1.0\n");
167 else
168 printf("Unknown serial ATA version\n");
169 }
170 else
171 printf("ATA/ATAPI revision %d\n", version(parm->version_major));
172 printf("device model %.40s\n", parm->model);
173 printf("serial number %.20s\n", parm->serial);
174 printf("firmware revision %.8s\n", parm->revision);
175
176 printf("cylinders %d\n", parm->cylinders);
177 printf("heads %d\n", parm->heads);
178 printf("sectors/track %d\n", parm->sectors);
179
180 printf("lba%ssupported ",
181 parm->capabilities1 & ATA_SUPPORT_LBA ? " " : " not ");
182 if (lbasize)
183 printf("%d sectors\n", lbasize);
184 else
185 printf("\n");
186
187 printf("lba48%ssupported ",
188 parm->support.command2 & ATA_SUPPORT_ADDRESS48 ? " " : " not ");
189 if (lbasize48)
190 printf("%llu sectors\n", (unsigned long long)lbasize48);
191 else
192 printf("\n");
193
194 printf("dma%ssupported\n",
195 parm->capabilities1 & ATA_SUPPORT_DMA ? " " : " not ");
196
197 printf("overlap%ssupported\n",
198 parm->capabilities1 & ATA_SUPPORT_OVERLAP ? " " : " not ");
199
200 printf("\nFeature "
201 "Support Enable Value Vendor\n");
202
203 printf("write cache %s %s\n",
204 parm->support.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no",
205 parm->enabled.command1 & ATA_SUPPORT_WRITECACHE ? "yes" : "no");
206
207 printf("read ahead %s %s\n",
208 parm->support.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no",
209 parm->enabled.command1 & ATA_SUPPORT_LOOKAHEAD ? "yes" : "no");
210
211 if (parm->satacapabilities && parm->satacapabilities != 0xffff) {
212 printf("Native Command Queuing (NCQ) %s %s"
213 " %d/0x%02X\n",
214 parm->satacapabilities & ATA_SUPPORT_NCQ ?
215 "yes" : "no", " -",
216 (parm->satacapabilities & ATA_SUPPORT_NCQ) ?
217 ATA_QUEUE_LEN(parm->queue) : 0,
218 (parm->satacapabilities & ATA_SUPPORT_NCQ) ?
219 ATA_QUEUE_LEN(parm->queue) : 0);
220 }
221 printf("Tagged Command Queuing (TCQ) %s %s %d/0x%02X\n",
222 parm->support.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
223 parm->enabled.command2 & ATA_SUPPORT_QUEUED ? "yes" : "no",
224 ATA_QUEUE_LEN(parm->queue), ATA_QUEUE_LEN(parm->queue));
225
226 printf("SMART %s %s\n",
227 parm->support.command1 & ATA_SUPPORT_SMART ? "yes" : "no",
228 parm->enabled.command1 & ATA_SUPPORT_SMART ? "yes" : "no");
229
230 printf("microcode download %s %s\n",
231 parm->support.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no",
232 parm->enabled.command2 & ATA_SUPPORT_MICROCODE ? "yes" : "no");
233
234 printf("security %s %s\n",
235 parm->support.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no",
236 parm->enabled.command1 & ATA_SUPPORT_SECURITY ? "yes" : "no");
237
238 printf("power management %s %s\n",
239 parm->support.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no",
240 parm->enabled.command1 & ATA_SUPPORT_POWERMGT ? "yes" : "no");
241
242 printf("advanced power management %s %s %d/0x%02X\n",
243 parm->support.command2 & ATA_SUPPORT_APM ? "yes" : "no",
244 parm->enabled.command2 & ATA_SUPPORT_APM ? "yes" : "no",
245 parm->apm_value, parm->apm_value);
246
247 printf("automatic acoustic management %s %s "
248 "%d/0x%02X %d/0x%02X\n",
249 parm->support.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
250 parm->enabled.command2 & ATA_SUPPORT_AUTOACOUSTIC ? "yes" :"no",
251 ATA_ACOUSTIC_CURRENT(parm->acoustic),
252 ATA_ACOUSTIC_CURRENT(parm->acoustic),
253 ATA_ACOUSTIC_VENDOR(parm->acoustic),
254 ATA_ACOUSTIC_VENDOR(parm->acoustic));
255 }
256
257 int
258 ata_cap_print(int fd)
259 {
260 struct ata_params params;
261
262 if (ioctl(fd, IOCATAGPARM, &params) < 0)
263 return errno;
264 cap_print(&params);
265 return 0;
266 }
267
268 int
269 info_print(int fd, int channel, int prchan)
270 {
271 struct ata_ioc_devices devices;
272
273 devices.channel = channel;
274
275 if (ioctl(fd, IOCATADEVICES, &devices) < 0)
276 return errno;
277
278 if (prchan)
279 printf("ATA channel %d:\n", channel);
280 printf("%sMaster: ", prchan ? " " : "");
281 if (*devices.name[0]) {
282 printf("%4.4s ", devices.name[0]);
283 param_print(&devices.params[0]);
284 }
285 else
286 printf(" no device present\n");
287 printf("%sSlave: ", prchan ? " " : "");
288 if (*devices.name[1]) {
289 printf("%4.4s ", devices.name[1]);
290 param_print(&devices.params[1]);
291 }
292 else
293 printf(" no device present\n");
294 return 0;
295 }
296
297 int
298 main(int argc, char **argv)
299 {
300 int fd;
301
302 if (argc < 2)
303 usage();
304
305 if (!strcmp(argv[1], "mode") && (argc == 3 || argc == 4)) {
306 int disk, mode;
307 char device[64];
308
309 if (!(sscanf(argv[2], "ad%d", &disk) == 1 ||
310 sscanf(argv[2], "acd%d", &disk) == 1 ||
311 sscanf(argv[2], "afd%d", &disk) == 1 ||
312 sscanf(argv[2], "ast%d", &disk) == 1)) {
313 fprintf(stderr, "natacontrol: Invalid device %s\n",
314 argv[2]);
315 exit(EX_USAGE);
316 }
317 sprintf(device, "/dev/%s", argv[2]);
318 if ((fd = open(device, O_RDONLY)) < 0)
319 err(1, "device not found");
320 if (argc == 4) {
321 mode = str2mode(argv[3]);
322 if (ioctl(fd, IOCATASMODE, &mode) < 0)
323 warn("ioctl(IOCATASMODE)");
324 }
325 if (argc == 3 || argc == 4) {
326 if (ioctl(fd, IOCATAGMODE, &mode) < 0)
327 err(1, "ioctl(IOCATAGMODE)");
328 printf("current mode = %s\n", mode2str(mode));
329 }
330 exit(EX_OK);
331 }
332 if (!strcmp(argv[1], "feature") && argc == 5) {
333 int disk;
334 char device[64];
335 struct ata_ioc_request request;
336
337 if (!(sscanf(argv[2], "ad%d", &disk) == 1 ||
338 sscanf(argv[2], "acd%d", &disk) == 1 ||
339 sscanf(argv[2], "afd%d", &disk) == 1 ||
340 sscanf(argv[2], "ast%d", &disk) == 1)) {
341 fprintf(stderr, "natacontrol: Invalid device %s\n",
342 argv[2]);
343 exit(EX_USAGE);
344 }
345 sprintf(device, "/dev/%s", argv[2]);
346 if ((fd = open(device, O_RDONLY)) < 0)
347 err(1, "device not found");
348
349 bzero(&request, sizeof(struct ata_ioc_request));
350 request.u.ata.command = ATA_SETFEATURES;
351 request.flags = ATA_CMD_CONTROL;
352 request.timeout = 500;
353 if (!strcmp(argv[3], "apm")) {
354 if (!strcmp(argv[4], "off")) {
355 request.u.ata.feature = ATA_SF_DIS_APM;
356 } else if (!strcmp(argv[4], "maxperf")) {
357 request.u.ata.feature = ATA_SF_ENAB_APM;
358 request.u.ata.count = 0xfe;
359 } else if (!strcmp(argv[4], "minpower")) {
360 request.u.ata.feature = ATA_SF_ENAB_APM;
361 request.u.ata.count = 0x01;
362 } else {
363 int offset = 0;
364
365 request.u.ata.feature = ATA_SF_ENAB_APM;
366 if (argv[4][0] == 's') {
367 offset = atoi(&argv[4][1]);
368 request.u.ata.count = 0x01;
369 } else {
370 offset = atoi(&argv[4][1]);
371 request.u.ata.count = 0x80;
372 }
373 if (offset >= 0 && offset <= 127)
374 request.u.ata.count += offset;
375 }
376 } else if (!strcmp(argv[3], "acoustic")) {
377 if (!strcmp(argv[4], "off")) {
378 request.u.ata.feature = ATA_SF_DIS_ACCOUS;
379 } else if (!strcmp(argv[4], "maxperf")) {
380 request.u.ata.feature = ATA_SF_ENAB_ACCOUS;
381 request.u.ata.count = 0xfe;
382 } else if (!strcmp(argv[4], "maxquiet")) {
383 request.u.ata.feature = ATA_SF_ENAB_ACCOUS;
384 request.u.ata.count = 0x80;
385 } else {
386 request.u.ata.feature = ATA_SF_ENAB_ACCOUS;
387 request.u.ata.count = atoi(argv[4]);
388 if (request.u.ata.count > 124)
389 request.u.ata.count = 124;
390 }
391 } else {
392 usage();
393 }
394
395 if (ioctl(fd, IOCATAREQUEST, &request) < 0)
396 err(1, "ioctl(IOCATAREQUEST)");
397
398 if (request.error != 0) {
399 fprintf(stderr,
400 "IOCATAREQUEST returned err status %d",
401 request.error);
402 exit(EX_IOERR);
403 }
404 exit(EX_OK);
405 }
406 if (!strcmp(argv[1], "cap") && argc == 3) {
407 int disk;
408 char device[64];
409
410 if (!(sscanf(argv[2], "ad%d", &disk) == 1 ||
411 sscanf(argv[2], "acd%d", &disk) == 1 ||
412 sscanf(argv[2], "afd%d", &disk) == 1 ||
413 sscanf(argv[2], "ast%d", &disk) == 1)) {
414 fprintf(stderr, "natacontrol: Invalid device %s\n",
415 argv[2]);
416 exit(EX_USAGE);
417 }
418 sprintf(device, "/dev/%s", argv[2]);
419 if ((fd = open(device, O_RDONLY)) < 0)
420 err(1, "device not found");
421 ata_cap_print(fd);
422 exit(EX_OK);
423 }
424
425 if ((fd = open("/dev/ata", O_RDWR)) < 0)
426 err(1, "control device not found");
427
428 if (!strcmp(argv[1], "list") && argc == 2) {
429 int maxchannel, channel;
430
431 if (ioctl(fd, IOCATAGMAXCHANNEL, &maxchannel) < 0)
432 err(1, "ioctl(IOCATAGMAXCHANNEL)");
433 for (channel = 0; channel < maxchannel; channel++)
434 info_print(fd, channel, 1);
435 exit(EX_OK);
436 }
437 if (!strcmp(argv[1], "info") && argc == 3) {
438 int channel;
439
440 if (!(sscanf(argv[2], "ata%d", &channel) == 1)) {
441 fprintf(stderr,
442 "natacontrol: Invalid channel %s\n", argv[2]);
443 exit(EX_USAGE);
444 }
445 info_print(fd, channel, 0);
446 exit(EX_OK);
447 }
448 if (!strcmp(argv[1], "detach") && argc == 3) {
449 int channel;
450
451 if (!(sscanf(argv[2], "ata%d", &channel) == 1)) {
452 fprintf(stderr,
453 "natacontrol: Invalid channel %s\n", argv[2]);
454 exit(EX_USAGE);
455 }
456 if (ioctl(fd, IOCATADETACH, &channel) < 0)
457 err(1, "ioctl(IOCATADETACH)");
458 exit(EX_OK);
459 }
460 if (!strcmp(argv[1], "attach") && argc == 3) {
461 int channel;
462
463 if (!(sscanf(argv[2], "ata%d", &channel) == 1)) {
464 fprintf(stderr,
465 "natacontrol: Invalid channel %s\n", argv[2]);
466 exit(EX_USAGE);
467 }
468 if (ioctl(fd, IOCATAATTACH, &channel) < 0)
469 err(1, "ioctl(IOCATAATTACH)");
470 info_print(fd, channel, 0);
471 exit(EX_OK);
472 }
473 if (!strcmp(argv[1], "reinit") && argc == 3) {
474 int channel;
475
476 if (!(sscanf(argv[2], "ata%d", &channel) == 1)) {
477 fprintf(stderr,
478 "natacontrol: Invalid channel %s\n", argv[2]);
479 exit(EX_USAGE);
480 }
481 if (ioctl(fd, IOCATAREINIT, &channel) < 0)
482 warn("ioctl(IOCATAREINIT)");
483 info_print(fd, channel, 0);
484 exit(EX_OK);
485 }
486 if (!strcmp(argv[1], "create")) {
487 int disk, dev, offset;
488 struct ata_ioc_raid_config config;
489
490 bzero(&config, sizeof(config));
491 if (argc > 2) {
492 if (!strcasecmp(argv[2], "RAID0") ||
493 !strcasecmp(argv[2], "stripe"))
494 config.type = AR_RAID0;
495 if (!strcasecmp(argv[2], "RAID1") ||
496 !strcasecmp(argv[2],"mirror"))
497 config.type = AR_RAID1;
498 if (!strcasecmp(argv[2], "RAID0+1") ||
499 !strcasecmp(argv[2],"RAID10"))
500 config.type = AR_RAID01;
501 if (!strcasecmp(argv[2], "RAID5"))
502 config.type = AR_RAID5;
503 if (!strcasecmp(argv[2], "SPAN"))
504 config.type = AR_SPAN;
505 if (!strcasecmp(argv[2], "JBOD"))
506 config.type = AR_JBOD;
507 }
508 if (!config.type) {
509 fprintf(stderr, "natacontrol: Invalid RAID type %s\n",
510 argv[2]);
511 fprintf(stderr, "natacontrol: Valid RAID types: \n");
512 fprintf(stderr, " stripe | mirror | "
513 "RAID0 | RAID1 | RAID0+1 | RAID5 | "
514 "SPAN | JBOD\n");
515 exit(EX_USAGE);
516 }
517
518 if (config.type == AR_RAID0 ||
519 config.type == AR_RAID01 ||
520 config.type == AR_RAID5) {
521 if (argc < 4 ||
522 sscanf(argv[3], "%d", &config.interleave) != 1) {
523 fprintf(stderr,
524 "natacontrol: Invalid interleave %s\n",
525 argv[3]);
526 exit(EX_USAGE);
527 }
528 offset = 4;
529 }
530 else
531 offset = 3;
532
533 for (disk = 0; disk < 16 && (offset + disk) < argc; disk++) {
534 if (!(sscanf(argv[offset + disk], "ad%d", &dev) == 1)) {
535 fprintf(stderr,
536 "natacontrol: Invalid disk %s\n",
537 argv[offset + disk]);
538 exit(EX_USAGE);
539 }
540 config.disks[disk] = dev;
541 }
542
543 if ((config.type == AR_RAID1 || config.type == AR_RAID01) &&
544 disk < 2) {
545 fprintf(stderr, "natacontrol: At least 2 disks must be "
546 "specified\n");
547 exit(EX_USAGE);
548 }
549
550 config.total_disks = disk;
551 if (ioctl(fd, IOCATARAIDCREATE, &config) < 0)
552 err(1, "ioctl(IOCATARAIDCREATE)");
553 else
554 printf("ar%d created\n", config.lun);
555 exit(EX_OK);
556 }
557 if (!strcmp(argv[1], "delete") && argc == 3) {
558 int array;
559
560 if (!(sscanf(argv[2], "ar%d", &array) == 1)) {
561 fprintf(stderr,
562 "natacontrol: Invalid array %s\n", argv[2]);
563 exit(EX_USAGE);
564 }
565 if (ioctl(fd, IOCATARAIDDELETE, &array) < 0)
566 warn("ioctl(IOCATARAIDDELETE)");
567 exit(EX_OK);
568 }
569 if (!strcmp(argv[1], "addspare") && argc == 4) {
570 struct ata_ioc_raid_config config;
571
572 if (!(sscanf(argv[2], "ar%d", &config.lun) == 1)) {
573 fprintf(stderr,
574 "natacontrol: Invalid array %s\n", argv[2]);
575 usage();
576 }
577 if (!(sscanf(argv[3], "ad%d", &config.disks[0]) == 1)) {
578 fprintf(stderr,
579 "natacontrol: Invalid disk %s\n", argv[3]);
580 usage();
581 }
582 if (ioctl(fd, IOCATARAIDADDSPARE, &config) < 0)
583 warn("ioctl(IOCATARAIDADDSPARE)");
584 exit(EX_OK);
585 }
586 if (!strcmp(argv[1], "rebuild") && argc == 3) {
587 int array;
588
589 if (!(sscanf(argv[2], "ar%d", &array) == 1)) {
590 fprintf(stderr,
591 "natacontrol: Invalid array %s\n", argv[2]);
592 usage();
593 }
594 if (ioctl(fd, IOCATARAIDREBUILD, &array) < 0)
595 warn("ioctl(IOCATARAIDREBUILD)");
596 else {
597 char device[64];
598 char *buffer;
599 ssize_t len;
600 int arfd;
601
602 if (daemon(0, 1) == -1)
603 err(1, "daemon");
604 nice(20);
605 snprintf(device, sizeof(device), "/dev/ar%d",
606 array);
607 if ((arfd = open(device, O_RDONLY)) == -1)
608 err(1, "open %s", device);
609 if ((buffer = malloc(1024 * 1024)) == NULL)
610 err(1, "malloc");
611 while ((len = read(arfd, buffer, 1024 * 1024)) > 0)
612 ;
613 if (len == -1)
614 err(1, "read");
615 else
616 fprintf(stderr,
617 "natacontrol: ar%d rebuild completed\n",
618 array);
619 free(buffer);
620 close(arfd);
621 }
622 exit(EX_OK);
623 }
624 if (!strcmp(argv[1], "status") && argc == 3) {
625 struct ata_ioc_raid_config config;
626 int i;
627
628 if (!(sscanf(argv[2], "ar%d", &config.lun) == 1)) {
629 fprintf(stderr,
630 "natacontrol: Invalid array %s\n", argv[2]);
631 usage();
632 }
633 if (ioctl(fd, IOCATARAIDSTATUS, &config) < 0)
634 err(1, "ioctl(IOCATARAIDSTATUS)");
635
636 printf("ar%d: ATA ", config.lun);
637 switch (config.type) {
638 case AR_RAID0:
639 printf("RAID0 stripesize=%d", config.interleave);
640 break;
641 case AR_RAID1:
642 printf("RAID1");
643 break;
644 case AR_RAID01:
645 printf("RAID0+1 stripesize=%d", config.interleave);
646 break;
647 case AR_RAID5:
648 printf("RAID5 stripesize=%d", config.interleave);
649 break;
650 case AR_JBOD:
651 printf("JBOD");
652 case AR_SPAN:
653 printf("SPAN");
654 break;
655 }
656 printf(" subdisks: ");
657 for (i = 0; i < config.total_disks; i++) {
658 if (config.disks[i] >= 0)
659 printf("ad%d ", config.disks[i]);
660 else
661 printf("DOWN ");
662 }
663 printf("status: ");
664 switch (config.status) {
665 case AR_READY:
666 printf("READY\n");
667 break;
668 case AR_READY | AR_DEGRADED:
669 printf("DEGRADED\n");
670 break;
671 case AR_READY | AR_DEGRADED | AR_REBUILDING:
672 printf("REBUILDING %d%% completed\n",
673 config.progress);
674 break;
675 default:
676 printf("BROKEN\n");
677 }
678 exit(EX_OK);
679 }
680 usage();
681 exit(EX_OK);
682 }
DragonFly BSD