sbin/atacontrol/atacontrol.c

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