sbin/natacontrol/natacontrol.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: 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 }