usr.sbin/mptutil/mpt_config.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 2008 Yahoo!, Inc.
   5  * All rights reserved.
   6  * Written by: John Baldwin <jhb@FreeBSD.org>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __RCSID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/errno.h>
  38 #include <err.h>
  39 #include <fcntl.h>
  40 #include <libutil.h>
  41 #include <paths.h>
  42 #ifdef DEBUG
  43 #include <stdint.h>
  44 #endif
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49 #include "mptutil.h"
  50
  51 #ifdef DEBUG
  52 static void     dump_config(CONFIG_PAGE_RAID_VOL_0 *vol);
  53 #endif
  54
  55 static long
  56 dehumanize(const char *value)
  57 {
  58         char    *vtp;
  59         long    iv;
  60
  61         if (value == NULL)
  62                 return (0);
  63         iv = strtoq(value, &vtp, 0);
  64         if (vtp == value || (vtp[0] != '\0' && vtp[1] != '\0')) {
  65                 return (0);
  66         }
  67         switch (vtp[0]) {
  68         case 't': case 'T':
  69                 iv *= 1024;
  70                 /* FALLTHROUGH */
  71         case 'g': case 'G':
  72                 iv *= 1024;
  73                 /* FALLTHROUGH */
  74         case 'm': case 'M':
  75                 iv *= 1024;
  76                 /* FALLTHROUGH */
  77         case 'k': case 'K':
  78                 iv *= 1024;
  79                 /* FALLTHROUGH */
  80         case '\0':
  81                 break;
  82         default:
  83                 return (0);
  84         }
  85         return (iv);
  86 }
  87
  88 /*
  89  * Lock the volume by opening its /dev device read/write.  This will
  90  * only work if nothing else has it opened (including mounts).  We
  91  * leak the fd on purpose since this application is not long-running.
  92  */
  93 int
  94 mpt_lock_volume(U8 VolumeBus, U8 VolumeID)
  95 {
  96         char path[MAXPATHLEN];
  97         struct mpt_query_disk qd;
  98         int error, vfd;
  99
 100         error = mpt_query_disk(VolumeBus, VolumeID, &qd);
 101         if (error == ENOENT)
 102                 /*
 103                  * This means there isn't a CAM device associated with
 104                  * the volume, and thus it is already implicitly
 105                  * locked, so just return.
 106                  */
 107                 return (0);
 108         if (error) {
 109                 warnc(error, "Unable to lookup volume device name");
 110                 return (error);
 111         }
 112         snprintf(path, sizeof(path), "%s%s", _PATH_DEV, qd.devname);
 113         vfd = open(path, O_RDWR);
 114         if (vfd < 0) {
 115                 error = errno;
 116                 warn("Unable to lock volume %s", qd.devname);
 117                 return (error);
 118         }
 119         return (0);
 120 }
 121
 122 static int
 123 mpt_lock_physdisk(struct mpt_standalone_disk *disk)
 124 {
 125         char path[MAXPATHLEN];
 126         int dfd, error;
 127
 128         snprintf(path, sizeof(path), "%s%s", _PATH_DEV, disk->devname);
 129         dfd = open(path, O_RDWR);
 130         if (dfd < 0) {
 131                 error = errno;
 132                 warn("Unable to lock disk %s", disk->devname);
 133                 return (error);
 134         }
 135         return (0);
 136 }
 137
 138 static int
 139 mpt_lookup_standalone_disk(const char *name, struct mpt_standalone_disk *disks,
 140     int ndisks, int *index)
 141 {
 142         char *cp;
 143         long bus, id;
 144         int i;
 145
 146         /* Check for a raw <bus>:<id> string. */
 147         bus = strtol(name, &cp, 0);
 148         if (*cp == ':') {
 149                 id = strtol(cp + 1, &cp, 0);
 150                 if (*cp == '\0') {
 151                         if (bus < 0 || bus > 0xff || id < 0 || id > 0xff) {
 152                                 return (EINVAL);
 153                         }
 154                         for (i = 0; i < ndisks; i++) {
 155                                 if (disks[i].bus == (U8)bus &&
 156                                     disks[i].target == (U8)id) {
 157                                         *index = i;
 158                                         return (0);
 159                                 }
 160                         }
 161                         return (ENOENT);
 162                 }
 163         }
 164
 165         if (name[0] == 'd' && name[1] == 'a') {
 166                 for (i = 0; i < ndisks; i++) {
 167                         if (strcmp(name, disks[i].devname) == 0) {
 168                                 *index = i;
 169                                 return (0);
 170                         }
 171                 }
 172                 return (ENOENT);
 173         }
 174
 175         return (EINVAL);
 176 }
 177
 178 /*
 179  * Mark a standalone disk as being a physical disk.
 180  */
 181 static int
 182 mpt_create_physdisk(int fd, struct mpt_standalone_disk *disk, U8 *PhysDiskNum)
 183 {
 184         CONFIG_PAGE_HEADER header;
 185         CONFIG_PAGE_RAID_PHYS_DISK_0 *config_page;
 186         int error;
 187         U32 ActionData;
 188
 189         error = mpt_read_config_page_header(fd, MPI_CONFIG_PAGETYPE_RAID_PHYSDISK,
 190             0, 0, &header, NULL);
 191         if (error)
 192                 return (error);
 193         if (header.PageVersion > MPI_RAIDPHYSDISKPAGE0_PAGEVERSION) {
 194                 warnx("Unsupported RAID physdisk page 0 version %d",
 195                     header.PageVersion);
 196                 return (EOPNOTSUPP);
 197         }
 198         config_page = calloc(1, sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0));
 199         config_page->Header.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
 200         config_page->Header.PageNumber = 0;
 201         config_page->Header.PageLength = sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0) /
 202             4;
 203         config_page->PhysDiskIOC = 0;   /* XXX */
 204         config_page->PhysDiskBus = disk->bus;
 205         config_page->PhysDiskID = disk->target;
 206
 207         /* XXX: Enclosure info for PhysDiskSettings? */
 208         error = mpt_raid_action(fd, MPI_RAID_ACTION_CREATE_PHYSDISK, 0, 0, 0, 0,
 209             config_page, sizeof(CONFIG_PAGE_RAID_PHYS_DISK_0), NULL,
 210             &ActionData, sizeof(ActionData), NULL, NULL, 1);
 211         if (error)
 212                 return (error);
 213         *PhysDiskNum = ActionData & 0xff;
 214         return (0);
 215 }
 216
 217 static int
 218 mpt_delete_physdisk(int fd, U8 PhysDiskNum)
 219 {
 220
 221         return (mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_PHYSDISK, 0, 0,
 222             PhysDiskNum, 0, NULL, 0, NULL, NULL, 0, NULL, NULL, 0));
 223 }
 224
 225 /*
 226  * MPT's firmware does not have a clear command.  Instead, we
 227  * implement it by deleting each array and disk by hand.
 228  */
 229 static int
 230 clear_config(int ac, char **av)
 231 {
 232         CONFIG_PAGE_IOC_2 *ioc2;
 233         CONFIG_PAGE_IOC_2_RAID_VOL *vol;
 234         CONFIG_PAGE_IOC_3 *ioc3;
 235         IOC_3_PHYS_DISK *disk;
 236         CONFIG_PAGE_IOC_5 *ioc5;
 237         IOC_5_HOT_SPARE *spare;
 238         int ch, error, fd, i;
 239
 240         fd = mpt_open(mpt_unit);
 241         if (fd < 0) {
 242                 error = errno;
 243                 warn("mpt_open");
 244                 return (error);
 245         }
 246
 247         ioc2 = mpt_read_ioc_page(fd, 2, NULL);
 248         if (ioc2 == NULL) {
 249                 error = errno;
 250                 warn("Failed to fetch volume list");
 251                 close(fd);
 252                 return (error);
 253         }
 254
 255         /* Lock all the volumes first. */
 256         vol = ioc2->RaidVolume;
 257         for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++) {
 258                 if (mpt_lock_volume(vol->VolumeBus, vol->VolumeID) < 0) {
 259                         warnx("Volume %s is busy and cannot be deleted",
 260                             mpt_volume_name(vol->VolumeBus, vol->VolumeID));
 261                         free(ioc2);
 262                         close(fd);
 263                         return (EBUSY);
 264                 }
 265         }
 266
 267         printf(
 268             "Are you sure you wish to clear the configuration on mpt%u? [y/N] ",
 269             mpt_unit);
 270         ch = getchar();
 271         if (ch != 'y' && ch != 'Y') {
 272                 printf("\nAborting\n");
 273                 free(ioc2);
 274                 close(fd);
 275                 return (0);
 276         }
 277
 278         /* Delete all the volumes. */
 279         vol = ioc2->RaidVolume;
 280         for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++) {
 281                 error = mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_VOLUME,
 282                     vol->VolumeBus, vol->VolumeID, 0,
 283                     MPI_RAID_ACTION_ADATA_DEL_PHYS_DISKS |
 284                     MPI_RAID_ACTION_ADATA_ZERO_LBA0, NULL, 0, NULL, NULL, 0,
 285                     NULL, NULL, 0);
 286                 if (error)
 287                         warnc(error, "Failed to delete volume %s",
 288                             mpt_volume_name(vol->VolumeBus, vol->VolumeID));
 289         }
 290         free(ioc2);
 291
 292         /* Delete all the spares. */
 293         ioc5 = mpt_read_ioc_page(fd, 5, NULL);
 294         if (ioc5 == NULL)
 295                 warn("Failed to fetch spare list");
 296         else {
 297                 spare = ioc5->HotSpare;
 298                 for (i = 0; i < ioc5->NumHotSpares; spare++, i++)
 299                         if (mpt_delete_physdisk(fd, spare->PhysDiskNum) < 0)
 300                                 warn("Failed to delete physical disk %d",
 301                                     spare->PhysDiskNum);
 302                 free(ioc5);
 303         }
 304
 305         /* Delete any RAID physdisks that may be left. */
 306         ioc3 = mpt_read_ioc_page(fd, 3, NULL);
 307         if (ioc3 == NULL)
 308                 warn("Failed to fetch drive list");
 309         else {
 310                 disk = ioc3->PhysDisk;
 311                 for (i = 0; i < ioc3->NumPhysDisks; disk++, i++)
 312                         if (mpt_delete_physdisk(fd, disk->PhysDiskNum) < 0)
 313                                 warn("Failed to delete physical disk %d",
 314                                     disk->PhysDiskNum);
 315                 free(ioc3);
 316         }
 317
 318         printf("mpt%d: Configuration cleared\n", mpt_unit);
 319         mpt_rescan_bus(-1, -1);
 320         close(fd);
 321
 322         return (0);
 323 }
 324 MPT_COMMAND(top, clear, clear_config);
 325
 326 #define RT_RAID0        0
 327 #define RT_RAID1        1
 328 #define RT_RAID1E       2
 329
 330 static struct raid_type_entry {
 331         const char *name;
 332         int     raid_type;
 333 } raid_type_table[] = {
 334         { "raid0",      RT_RAID0 },
 335         { "raid-0",     RT_RAID0 },
 336         { "raid1",      RT_RAID1 },
 337         { "raid-1",     RT_RAID1 },
 338         { "mirror",     RT_RAID1 },
 339         { "raid1e",     RT_RAID1E },
 340         { "raid-1e",    RT_RAID1E },
 341         { NULL,         0 },
 342 };
 343
 344 struct config_id_state {
 345         struct mpt_standalone_disk *sdisks;
 346         struct mpt_drive_list *list;
 347         CONFIG_PAGE_IOC_2 *ioc2;
 348         U8      target_id;
 349         int     nsdisks;
 350 };
 351
 352 struct drive_info {
 353         CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
 354         struct mpt_standalone_disk *sdisk;
 355 };
 356
 357 struct volume_info {
 358         int     drive_count;
 359         struct drive_info *drives;
 360 };
 361
 362 /* Parse a comma-separated list of drives for a volume. */
 363 static int
 364 parse_volume(int fd, int raid_type, struct config_id_state *state,
 365     char *volume_str, struct volume_info *info)
 366 {
 367         struct drive_info *dinfo;
 368         U8 PhysDiskNum;
 369         char *cp;
 370         int count, error, i;
 371
 372         cp = volume_str;
 373         for (count = 0; cp != NULL; count++) {
 374                 cp = strchr(cp, ',');
 375                 if (cp != NULL) {
 376                         cp++;
 377                         if (*cp == ',') {
 378                                 warnx("Invalid drive list '%s'", volume_str);
 379                                 return (EINVAL);
 380                         }
 381                 }
 382         }
 383
 384         /* Validate the number of drives for this volume. */
 385         switch (raid_type) {
 386         case RT_RAID0:
 387                 if (count < 2) {
 388                         warnx("RAID0 requires at least 2 drives in each "
 389                             "array");
 390                         return (EINVAL);
 391                 }
 392                 break;
 393         case RT_RAID1:
 394                 if (count != 2) {
 395                         warnx("RAID1 requires exactly 2 drives in each "
 396                             "array");
 397                         return (EINVAL);
 398                 }
 399                 break;
 400         case RT_RAID1E:
 401                 if (count < 3) {
 402                         warnx("RAID1E requires at least 3 drives in each "
 403                             "array");
 404                         return (EINVAL);
 405                 }
 406                 break;
 407         }
 408
 409         /* Validate each drive. */
 410         info->drives = calloc(count, sizeof(struct drive_info));
 411         info->drive_count = count;
 412         for (dinfo = info->drives; (cp = strsep(&volume_str, ",")) != NULL;
 413              dinfo++) {
 414                 /* If this drive is already a RAID phys just fetch the info. */
 415                 error = mpt_lookup_drive(state->list, cp, &PhysDiskNum);
 416                 if (error == 0) {
 417                         dinfo->info = mpt_pd_info(fd, PhysDiskNum, NULL);
 418                         if (dinfo->info == NULL)
 419                                 return (errno);
 420                         continue;
 421                 }
 422
 423                 /* See if it is a standalone disk. */
 424                 if (mpt_lookup_standalone_disk(cp, state->sdisks,
 425                     state->nsdisks, &i) < 0) {
 426                         error = errno;
 427                         warn("Unable to lookup drive %s", cp);
 428                         return (error);
 429                 }
 430                 dinfo->sdisk = &state->sdisks[i];
 431
 432                 /* Lock the disk, we will create phys disk pages later. */
 433                 if (mpt_lock_physdisk(dinfo->sdisk) < 0)
 434                         return (errno);
 435         }
 436
 437         return (0);
 438 }
 439
 440 /*
 441  * Add RAID physdisk pages for any standalone disks that a volume is
 442  * going to use.
 443  */
 444 static int
 445 add_drives(int fd, struct volume_info *info, int verbose)
 446 {
 447         struct drive_info *dinfo;
 448         U8 PhysDiskNum;
 449         int error, i;
 450
 451         for (i = 0, dinfo = info->drives; i < info->drive_count;
 452              i++, dinfo++) {
 453                 if (dinfo->info == NULL) {
 454                         if (mpt_create_physdisk(fd, dinfo->sdisk,
 455                             &PhysDiskNum) < 0) {
 456                                 error = errno;
 457                                 warn(
 458                             "Failed to create physical disk page for %s",
 459                                     dinfo->sdisk->devname);
 460                                 return (error);
 461                         }
 462                         if (verbose)
 463                                 printf("Added drive %s with PhysDiskNum %u\n",
 464                                     dinfo->sdisk->devname, PhysDiskNum);
 465
 466                         dinfo->info = mpt_pd_info(fd, PhysDiskNum, NULL);
 467                         if (dinfo->info == NULL)
 468                                 return (errno);
 469                 }
 470         }
 471         return (0);
 472 }
 473
 474 /*
 475  * Find the next free target ID assuming that 'target_id' is the last
 476  * one used.  'target_id' should be 0xff for the initial test.
 477  */
 478 static U8
 479 find_next_volume(struct config_id_state *state)
 480 {
 481         CONFIG_PAGE_IOC_2_RAID_VOL *vol;
 482         int i;
 483
 484 restart:
 485         /* Assume the current one is used. */
 486         state->target_id++;
 487
 488         /* Search drives first. */
 489         for (i = 0; i < state->nsdisks; i++)
 490                 if (state->sdisks[i].target == state->target_id)
 491                         goto restart;
 492         for (i = 0; i < state->list->ndrives; i++)
 493                 if (state->list->drives[i]->PhysDiskID == state->target_id)
 494                         goto restart;
 495
 496         /* Search volumes second. */
 497         vol = state->ioc2->RaidVolume;
 498         for (i = 0; i < state->ioc2->NumActiveVolumes; vol++, i++)
 499                 if (vol->VolumeID == state->target_id)
 500                         goto restart;
 501
 502         return (state->target_id);
 503 }
 504
 505 /* Create a volume and populate it with drives. */
 506 static CONFIG_PAGE_RAID_VOL_0 *
 507 build_volume(int fd, struct volume_info *info, int raid_type, long stripe_size,
 508     struct config_id_state *state, int verbose)
 509 {
 510         CONFIG_PAGE_HEADER header;
 511         CONFIG_PAGE_RAID_VOL_0 *vol;
 512         RAID_VOL0_PHYS_DISK *rdisk;
 513         struct drive_info *dinfo;
 514         U32 MinLBA;
 515         uint64_t MaxLBA;
 516         size_t page_size;
 517         int error, i;
 518
 519         error = mpt_read_config_page_header(fd, MPI_CONFIG_PAGETYPE_RAID_VOLUME,
 520             0, 0, &header, NULL);
 521         if (error) {
 522                 errno = error;
 523                 return (NULL);
 524         }
 525         if (header.PageVersion > MPI_RAIDVOLPAGE0_PAGEVERSION) {
 526                 warnx("Unsupported RAID volume page 0 version %d",
 527                     header.PageVersion);
 528                 errno = EOPNOTSUPP;
 529                 return (NULL);
 530         }
 531         page_size = sizeof(CONFIG_PAGE_RAID_VOL_0) +
 532             sizeof(RAID_VOL0_PHYS_DISK) * (info->drive_count - 1);
 533         vol = calloc(1, page_size);
 534         if (vol == NULL)
 535                 return (NULL);
 536
 537         /* Header */
 538         vol->Header.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
 539         vol->Header.PageNumber = 0;
 540         vol->Header.PageLength = page_size / 4;
 541
 542         /* Properties */
 543         vol->VolumeID = find_next_volume(state);
 544         vol->VolumeBus = 0;
 545         vol->VolumeIOC = 0;     /* XXX */
 546         vol->VolumeStatus.Flags = MPI_RAIDVOL0_STATUS_FLAG_ENABLED;
 547         vol->VolumeStatus.State = MPI_RAIDVOL0_STATUS_STATE_OPTIMAL;
 548         vol->VolumeSettings.Settings = MPI_RAIDVOL0_SETTING_USE_DEFAULTS;
 549         vol->VolumeSettings.HotSparePool = MPI_RAID_HOT_SPARE_POOL_0;
 550         vol->NumPhysDisks = info->drive_count;
 551
 552         /* Find the smallest drive. */
 553         MinLBA = info->drives[0].info->MaxLBA;
 554         for (i = 1; i < info->drive_count; i++)
 555                 if (info->drives[i].info->MaxLBA < MinLBA)
 556                         MinLBA = info->drives[i].info->MaxLBA;
 557
 558         /*
 559          * Now chop off 512MB at the end to leave room for the
 560          * metadata.  The controller might only use 64MB, but we just
 561          * chop off the max to be simple.
 562          */
 563         MinLBA -= (512 * 1024 * 1024) / 512;
 564
 565         switch (raid_type) {
 566         case RT_RAID0:
 567                 vol->VolumeType = MPI_RAID_VOL_TYPE_IS;
 568                 vol->StripeSize = stripe_size / 512;
 569                 MaxLBA = (uint64_t)MinLBA * info->drive_count;
 570                 break;
 571         case RT_RAID1:
 572                 vol->VolumeType = MPI_RAID_VOL_TYPE_IM;
 573                 MaxLBA = (uint64_t)MinLBA * (info->drive_count / 2);
 574                 break;
 575         case RT_RAID1E:
 576                 vol->VolumeType = MPI_RAID_VOL_TYPE_IME;
 577                 vol->StripeSize = stripe_size / 512;
 578                 MaxLBA = (uint64_t)MinLBA * info->drive_count / 2;
 579                 break;
 580         default:
 581                 /* Pacify gcc. */
 582                 abort();
 583         }
 584
 585         /*
 586          * If the controller doesn't support 64-bit addressing and the
 587          * new volume is larger than 2^32 blocks, warn the user and
 588          * truncate the volume.
 589          */
 590         if (MaxLBA >> 32 != 0 &&
 591             !(state->ioc2->CapabilitiesFlags &
 592             MPI_IOCPAGE2_CAP_FLAGS_RAID_64_BIT_ADDRESSING)) {
 593                 warnx(
 594             "Controller does not support volumes > 2TB, truncating volume.");
 595                 MaxLBA = 0xffffffff;
 596         }
 597         vol->MaxLBA = MaxLBA;
 598         vol->MaxLBAHigh = MaxLBA >> 32;
 599
 600         /* Populate drives. */
 601         for (i = 0, dinfo = info->drives, rdisk = vol->PhysDisk;
 602              i < info->drive_count; i++, dinfo++, rdisk++) {
 603                 if (verbose)
 604                         printf("Adding drive %u (%u:%u) to volume %u:%u\n",
 605                             dinfo->info->PhysDiskNum, dinfo->info->PhysDiskBus,
 606                             dinfo->info->PhysDiskID, vol->VolumeBus,
 607                             vol->VolumeID);
 608                 if (raid_type == RT_RAID1) {
 609                         if (i == 0)
 610                                 rdisk->PhysDiskMap =
 611                                     MPI_RAIDVOL0_PHYSDISK_PRIMARY;
 612                         else
 613                                 rdisk->PhysDiskMap =
 614                                     MPI_RAIDVOL0_PHYSDISK_SECONDARY;
 615                 } else
 616                         rdisk->PhysDiskMap = i;
 617                 rdisk->PhysDiskNum = dinfo->info->PhysDiskNum;
 618         }
 619
 620         return (vol);
 621 }
 622
 623 static int
 624 create_volume(int ac, char **av)
 625 {
 626         CONFIG_PAGE_RAID_VOL_0 *vol;
 627         struct config_id_state state;
 628         struct volume_info *info;
 629         long stripe_size;
 630         int ch, error, fd, i, quick, raid_type, verbose;
 631 #ifdef DEBUG
 632         int dump;
 633 #endif
 634
 635         if (ac < 2) {
 636                 warnx("create: volume type required");
 637                 return (EINVAL);
 638         }
 639
 640         fd = mpt_open(mpt_unit);
 641         if (fd < 0) {
 642                 error = errno;
 643                 warn("mpt_open");
 644                 return (error);
 645         }
 646
 647         /* Lookup the RAID type first. */
 648         raid_type = -1;
 649         for (i = 0; raid_type_table[i].name != NULL; i++)
 650                 if (strcasecmp(raid_type_table[i].name, av[1]) == 0) {
 651                         raid_type = raid_type_table[i].raid_type;
 652                         break;
 653                 }
 654
 655         if (raid_type == -1) {
 656                 warnx("Unknown or unsupported volume type %s", av[1]);
 657                 close(fd);
 658                 return (EINVAL);
 659         }
 660
 661         /* Parse any options. */
 662         optind = 2;
 663 #ifdef DEBUG
 664         dump = 0;
 665 #endif
 666         quick = 0;
 667         verbose = 0;
 668         stripe_size = 64 * 1024;
 669
 670         while ((ch = getopt(ac, av, "dqs:v")) != -1) {
 671                 switch (ch) {
 672 #ifdef DEBUG
 673                 case 'd':
 674                         dump = 1;
 675                         break;
 676 #endif
 677                 case 'q':
 678                         quick = 1;
 679                         break;
 680                 case 's':
 681                         stripe_size = dehumanize(optarg);
 682                         if ((stripe_size < 512) || (!powerof2(stripe_size))) {
 683                                 warnx("Invalid stripe size %s", optarg);
 684                                 close(fd);
 685                                 return (EINVAL);
 686                         }
 687                         break;
 688                 case 'v':
 689                         verbose = 1;
 690                         break;
 691                 case '?':
 692                 default:
 693                         close(fd);
 694                         return (EINVAL);
 695                 }
 696         }
 697         ac -= optind;
 698         av += optind;
 699
 700         /* Fetch existing config data. */
 701         state.ioc2 = mpt_read_ioc_page(fd, 2, NULL);
 702         if (state.ioc2 == NULL) {
 703                 error = errno;
 704                 warn("Failed to read volume list");
 705                 close(fd);
 706                 return (error);
 707         }
 708         state.list = mpt_pd_list(fd);
 709         if (state.list == NULL) {
 710                 close(fd);
 711                 return (errno);
 712         }
 713         error = mpt_fetch_disks(fd, &state.nsdisks, &state.sdisks);
 714         if (error) {
 715                 warn("Failed to fetch standalone disk list");
 716                 close(fd);
 717                 return (error);
 718         }
 719         state.target_id = 0xff;
 720
 721         /* Parse the drive list. */
 722         if (ac != 1) {
 723                 warnx("Exactly one drive list is required");
 724                 close(fd);
 725                 return (EINVAL);
 726         }
 727         info = calloc(1, sizeof(*info));
 728         if (info == NULL) {
 729                 close(fd);
 730                 return (ENOMEM);
 731         }
 732         error = parse_volume(fd, raid_type, &state, av[0], info);
 733         if (error) {
 734                 free(info);
 735                 close(fd);
 736                 return (error);
 737         }
 738
 739         /* Create RAID physdisk pages for standalone disks. */
 740         error = add_drives(fd, info, verbose);
 741         if (error) {
 742                 free(info);
 743                 close(fd);
 744                 return (error);
 745         }
 746
 747         /* Build the volume. */
 748         vol = build_volume(fd, info, raid_type, stripe_size, &state, verbose);
 749         if (vol == NULL) {
 750                 free(info);
 751                 close(fd);
 752                 return (errno);
 753         }
 754
 755 #ifdef DEBUG
 756         if (dump) {
 757                 dump_config(vol);
 758                 goto skip;
 759         }
 760 #endif
 761
 762         /* Send the new volume to the controller. */
 763         error = mpt_raid_action(fd, MPI_RAID_ACTION_CREATE_VOLUME, vol->VolumeBus,
 764             vol->VolumeID, 0, quick ? MPI_RAID_ACTION_ADATA_DO_NOT_SYNC : 0,
 765             vol, vol->Header.PageLength * 4, NULL, NULL, 0, NULL, NULL, 1);
 766         if (error) {
 767                 errno = error;
 768                 warn("Failed to add volume");
 769                 free(info);
 770                 close(fd);
 771                 return (error);
 772         }
 773
 774 #ifdef DEBUG
 775 skip:
 776 #endif
 777         mpt_rescan_bus(vol->VolumeBus, vol->VolumeID);
 778
 779         /* Clean up. */
 780         free(vol);
 781         free(info);
 782         free(state.sdisks);
 783         mpt_free_pd_list(state.list);
 784         free(state.ioc2);
 785         close(fd);
 786
 787         return (0);
 788 }
 789 MPT_COMMAND(top, create, create_volume);
 790
 791 static int
 792 delete_volume(int ac, char **av)
 793 {
 794         U8 VolumeBus, VolumeID;
 795         int error, fd;
 796
 797         if (ac != 2) {
 798                 warnx("delete: volume required");
 799                 return (EINVAL);
 800         }
 801
 802         fd = mpt_open(mpt_unit);
 803         if (fd < 0) {
 804                 error = errno;
 805                 warn("mpt_open");
 806                 return (error);
 807         }
 808
 809         error = mpt_lookup_volume(fd, av[1], &VolumeBus, &VolumeID);
 810         if (error) {
 811                 warnc(error, "Invalid volume %s", av[1]);
 812                 close(fd);
 813                 return (error);
 814         }
 815
 816         if (mpt_lock_volume(VolumeBus, VolumeID) < 0) {
 817                 close(fd);
 818                 return (errno);
 819         }
 820
 821         error = mpt_raid_action(fd, MPI_RAID_ACTION_DELETE_VOLUME, VolumeBus,
 822             VolumeID, 0, MPI_RAID_ACTION_ADATA_DEL_PHYS_DISKS |
 823             MPI_RAID_ACTION_ADATA_ZERO_LBA0, NULL, 0, NULL, NULL, 0, NULL,
 824             NULL, 0);
 825         if (error) {
 826                 warnc(error, "Failed to delete volume");
 827                 close(fd);
 828                 return (error);
 829         }
 830
 831         mpt_rescan_bus(-1, -1);
 832         close(fd);
 833
 834         return (0);
 835 }
 836 MPT_COMMAND(top, delete, delete_volume);
 837
 838 static int
 839 find_volume_spare_pool(int fd, const char *name, int *pool)
 840 {
 841         CONFIG_PAGE_RAID_VOL_0 *info;
 842         CONFIG_PAGE_IOC_2 *ioc2;
 843         CONFIG_PAGE_IOC_2_RAID_VOL *vol;
 844         U8 VolumeBus, VolumeID;
 845         int error, i, j, new_pool, pool_count[7];
 846
 847         error = mpt_lookup_volume(fd, name, &VolumeBus, &VolumeID);
 848         if (error) {
 849                 warnc(error, "Invalid volume %s", name);
 850                 return (error);
 851         }
 852
 853         info = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
 854         if (info == NULL)
 855                 return (errno);
 856
 857         /*
 858          * Check for an existing pool other than pool 0 (used for
 859          * global spares).
 860          */
 861         if ((info->VolumeSettings.HotSparePool & ~MPI_RAID_HOT_SPARE_POOL_0) !=
 862             0) {
 863                 *pool = 1 << (ffs(info->VolumeSettings.HotSparePool &
 864                     ~MPI_RAID_HOT_SPARE_POOL_0) - 1);
 865                 free(info);
 866                 return (0);
 867         }
 868         free(info);
 869
 870         /*
 871          * Try to find a free pool.  First, figure out which pools are
 872          * in use.
 873          */
 874         ioc2 = mpt_read_ioc_page(fd, 2, NULL);
 875         if (ioc2 == NULL) {
 876                 error = errno;
 877                 warn("Failed to fetch volume list");
 878                 return (error);
 879         }
 880         bzero(pool_count, sizeof(pool_count));
 881         vol = ioc2->RaidVolume;
 882         for (i = 0; i < ioc2->NumActiveVolumes; vol++, i++) {
 883                 info = mpt_vol_info(fd, vol->VolumeBus, vol->VolumeID, NULL);
 884                 if (info == NULL)
 885                         return (errno);
 886                 for (j = 0; j < 7; j++)
 887                         if (info->VolumeSettings.HotSparePool & (1 << (j + 1)))
 888                                 pool_count[j]++;
 889                 free(info);
 890         }
 891         free(ioc2);
 892
 893         /* Find the pool with the lowest use count. */
 894         new_pool = 0;
 895         for (i = 1; i < 7; i++)
 896                 if (pool_count[i] < pool_count[new_pool])
 897                         new_pool = i;
 898         new_pool++;
 899
 900         /* Add this pool to the volume. */
 901         info = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
 902         if (info == NULL)
 903                 return (error);
 904         info->VolumeSettings.HotSparePool |= (1 << new_pool);
 905         error = mpt_raid_action(fd, MPI_RAID_ACTION_CHANGE_VOLUME_SETTINGS,
 906             VolumeBus, VolumeID, 0, *(U32 *)&info->VolumeSettings, NULL, 0,
 907             NULL, NULL, 0, NULL, NULL, 0);
 908         if (error) {
 909                 warnx("Failed to add spare pool %d to %s", new_pool,
 910                     mpt_volume_name(VolumeBus, VolumeID));
 911                 free(info);
 912                 return (error);
 913         }
 914         free(info);
 915
 916         *pool = (1 << new_pool);
 917         return (0);
 918 }
 919
 920 static int
 921 add_spare(int ac, char **av)
 922 {
 923         CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
 924         struct mpt_standalone_disk *sdisks;
 925         struct mpt_drive_list *list;
 926         U8 PhysDiskNum;
 927         int error, fd, i, nsdisks, pool;
 928
 929         if (ac < 2) {
 930                 warnx("add spare: drive required");
 931                 return (EINVAL);
 932         }
 933         if (ac > 3) {
 934                 warnx("add spare: extra arguments");
 935                 return (EINVAL);
 936         }
 937
 938         fd = mpt_open(mpt_unit);
 939         if (fd < 0) {
 940                 error = errno;
 941                 warn("mpt_open");
 942                 return (error);
 943         }
 944
 945         if (ac == 3) {
 946                 error = find_volume_spare_pool(fd, av[2], &pool);
 947                 if (error) {
 948                         close(fd);
 949                         return (error);
 950                 }
 951         } else
 952                 pool = MPI_RAID_HOT_SPARE_POOL_0;
 953
 954         list = mpt_pd_list(fd);
 955         if (list == NULL)
 956                 return (errno);
 957
 958         error = mpt_lookup_drive(list, av[1], &PhysDiskNum);
 959         if (error) {
 960                 error = mpt_fetch_disks(fd, &nsdisks, &sdisks);
 961                 if (error != 0) {
 962                         warn("Failed to fetch standalone disk list");
 963                         mpt_free_pd_list(list);
 964                         close(fd);
 965                         return (error);
 966                 }
 967
 968                 if (mpt_lookup_standalone_disk(av[1], sdisks, nsdisks, &i) <
 969                     0) {
 970                         error = errno;
 971                         warn("Unable to lookup drive %s", av[1]);
 972                         mpt_free_pd_list(list);
 973                         close(fd);
 974                         return (error);
 975                 }
 976
 977                 if (mpt_lock_physdisk(&sdisks[i]) < 0) {
 978                         mpt_free_pd_list(list);
 979                         close(fd);
 980                         return (errno);
 981                 }
 982
 983                 if (mpt_create_physdisk(fd, &sdisks[i], &PhysDiskNum) < 0) {
 984                         error = errno;
 985                         warn("Failed to create physical disk page");
 986                         mpt_free_pd_list(list);
 987                         close(fd);
 988                         return (error);
 989                 }
 990                 free(sdisks);
 991         }
 992         mpt_free_pd_list(list);
 993
 994         info = mpt_pd_info(fd, PhysDiskNum, NULL);
 995         if (info == NULL) {
 996                 error = errno;
 997                 warn("Failed to fetch drive info");
 998                 close(fd);
 999                 return (error);
1000         }
1001
1002         info->PhysDiskSettings.HotSparePool = pool;
1003         error = mpt_raid_action(fd, MPI_RAID_ACTION_CHANGE_PHYSDISK_SETTINGS, 0,
1004             0, PhysDiskNum, *(U32 *)&info->PhysDiskSettings, NULL, 0, NULL,
1005             NULL, 0, NULL, NULL, 0);
1006         if (error) {
1007                 warnc(error, "Failed to assign spare");
1008                 close(fd);
1009                 return (error);
1010         }
1011
1012         free(info);
1013         close(fd);
1014
1015         return (0);
1016 }
1017 MPT_COMMAND(top, add, add_spare);
1018
1019 static int
1020 remove_spare(int ac, char **av)
1021 {
1022         CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
1023         struct mpt_drive_list *list;
1024         U8 PhysDiskNum;
1025         int error, fd;
1026
1027         if (ac != 2) {
1028                 warnx("remove spare: drive required");
1029                 return (EINVAL);
1030         }
1031
1032         fd = mpt_open(mpt_unit);
1033         if (fd < 0) {
1034                 error = errno;
1035                 warn("mpt_open");
1036                 return (error);
1037         }
1038
1039         list = mpt_pd_list(fd);
1040         if (list == NULL) {
1041                 close(fd);
1042                 return (errno);
1043         }
1044
1045         error = mpt_lookup_drive(list, av[1], &PhysDiskNum);
1046         if (error) {
1047                 warn("Failed to find drive %s", av[1]);
1048                 close(fd);
1049                 return (error);
1050         }
1051         mpt_free_pd_list(list);
1052
1053
1054         info = mpt_pd_info(fd, PhysDiskNum, NULL);
1055         if (info == NULL) {
1056                 error = errno;
1057                 warn("Failed to fetch drive info");
1058                 close(fd);
1059                 return (error);
1060         }
1061
1062         if (info->PhysDiskSettings.HotSparePool == 0) {
1063                 warnx("Drive %u is not a hot spare", PhysDiskNum);
1064                 free(info);
1065                 close(fd);
1066                 return (EINVAL);
1067         }
1068
1069         if (mpt_delete_physdisk(fd, PhysDiskNum) < 0) {
1070                 error = errno;
1071                 warn("Failed to delete physical disk page");
1072                 free(info);
1073                 close(fd);
1074                 return (error);
1075         }
1076
1077         mpt_rescan_bus(info->PhysDiskBus, info->PhysDiskID);
1078         free(info);
1079         close(fd);
1080
1081         return (0);
1082 }
1083 MPT_COMMAND(top, remove, remove_spare);
1084
1085 #ifdef DEBUG
1086 MPT_TABLE(top, pd);
1087
1088 static int
1089 pd_create(int ac, char **av)
1090 {
1091         struct mpt_standalone_disk *disks;
1092         int error, fd, i, ndisks;
1093         U8 PhysDiskNum;
1094
1095         if (ac != 2) {
1096                 warnx("pd create: drive required");
1097                 return (EINVAL);
1098         }
1099
1100         fd = mpt_open(mpt_unit);
1101         if (fd < 0) {
1102                 error = errno;
1103                 warn("mpt_open");
1104                 return (error);
1105         }
1106
1107         error = mpt_fetch_disks(fd, &ndisks, &disks);
1108         if (error != 0) {
1109                 warn("Failed to fetch standalone disk list");
1110                 return (error);
1111         }
1112
1113         if (mpt_lookup_standalone_disk(av[1], disks, ndisks, &i) < 0) {
1114                 error = errno;
1115                 warn("Unable to lookup drive");
1116                 return (error);
1117         }
1118
1119         if (mpt_lock_physdisk(&disks[i]) < 0)
1120                 return (errno);
1121
1122         if (mpt_create_physdisk(fd, &disks[i], &PhysDiskNum) < 0) {
1123                 error = errno;
1124                 warn("Failed to create physical disk page");
1125                 return (error);
1126         }
1127         free(disks);
1128
1129         printf("Added drive %s with PhysDiskNum %u\n", av[1], PhysDiskNum);
1130
1131         close(fd);
1132
1133         return (0);
1134 }
1135 MPT_COMMAND(pd, create, pd_create);
1136
1137 static int
1138 pd_delete(int ac, char **av)
1139 {
1140         CONFIG_PAGE_RAID_PHYS_DISK_0 *info;
1141         struct mpt_drive_list *list;
1142         int error, fd;
1143         U8 PhysDiskNum;
1144
1145         if (ac != 2) {
1146                 warnx("pd delete: drive required");
1147                 return (EINVAL);
1148         }
1149
1150         fd = mpt_open(mpt_unit);
1151         if (fd < 0) {
1152                 error = errno;
1153                 warn("mpt_open");
1154                 return (error);
1155         }
1156
1157         list = mpt_pd_list(fd);
1158         if (list == NULL)
1159                 return (errno);
1160
1161         if (mpt_lookup_drive(list, av[1], &PhysDiskNum) < 0) {
1162                 error = errno;
1163                 warn("Failed to find drive %s", av[1]);
1164                 return (error);
1165         }
1166         mpt_free_pd_list(list);
1167
1168         info = mpt_pd_info(fd, PhysDiskNum, NULL);
1169         if (info == NULL) {
1170                 error = errno;
1171                 warn("Failed to fetch drive info");
1172                 return (error);
1173         }
1174
1175         if (mpt_delete_physdisk(fd, PhysDiskNum) < 0) {
1176                 error = errno;
1177                 warn("Failed to delete physical disk page");
1178                 return (error);
1179         }
1180
1181         mpt_rescan_bus(info->PhysDiskBus, info->PhysDiskID);
1182         free(info);
1183         close(fd);
1184
1185         return (0);
1186 }
1187 MPT_COMMAND(pd, delete, pd_delete);
1188
1189 /* Display raw data about a volume config. */
1190 static void
1191 dump_config(CONFIG_PAGE_RAID_VOL_0 *vol)
1192 {
1193         int i;
1194
1195         printf("Volume Configuration (Debug):\n");
1196         printf(
1197    " Page Header: Type 0x%02x Number 0x%02x Length 0x%02x(%u) Version 0x%02x\n",
1198             vol->Header.PageType, vol->Header.PageNumber,
1199             vol->Header.PageLength, vol->Header.PageLength * 4,
1200             vol->Header.PageVersion);
1201         printf("     Address: %d:%d IOC %d\n", vol->VolumeBus, vol->VolumeID,
1202             vol->VolumeIOC);
1203         printf("        Type: %d (%s)\n", vol->VolumeType,
1204             mpt_raid_level(vol->VolumeType));
1205         printf("      Status: %s (Flags 0x%02x)\n",
1206             mpt_volstate(vol->VolumeStatus.State), vol->VolumeStatus.Flags);
1207         printf("    Settings: 0x%04x (Spare Pools 0x%02x)\n",
1208             vol->VolumeSettings.Settings, vol->VolumeSettings.HotSparePool);
1209         printf("      MaxLBA: %ju\n", (uintmax_t)vol->MaxLBAHigh << 32 |
1210             vol->MaxLBA);
1211         printf(" Stripe Size: %ld\n", (long)vol->StripeSize * 512);
1212         printf(" %d Disks:\n", vol->NumPhysDisks);
1213
1214         for (i = 0; i < vol->NumPhysDisks; i++)
1215                 printf("    Disk %d: Num 0x%02x Map 0x%02x\n", i,
1216                     vol->PhysDisk[i].PhysDiskNum, vol->PhysDisk[i].PhysDiskMap);
1217 }
1218
1219 static int
1220 debug_config(int ac, char **av)
1221 {
1222         CONFIG_PAGE_RAID_VOL_0 *vol;
1223         U8 VolumeBus, VolumeID;
1224         int error, fd;
1225
1226         if (ac != 2) {
1227                 warnx("debug: volume required");
1228                 return (EINVAL);
1229         }
1230
1231         fd = mpt_open(mpt_unit);
1232         if (fd < 0) {
1233                 error = errno;
1234                 warn("mpt_open");
1235                 return (error);
1236         }
1237
1238         error = mpt_lookup_volume(fd, av[1], &VolumeBus, &VolumeID);
1239         if (error) {
1240                 warnc(error, "Invalid volume: %s", av[1]);
1241                 return (error);
1242         }
1243
1244         vol = mpt_vol_info(fd, VolumeBus, VolumeID, NULL);
1245         if (vol == NULL) {
1246                 error = errno;
1247                 warn("Failed to get volume info");
1248                 return (error);
1249         }
1250
1251         dump_config(vol);
1252         free(vol);
1253         close(fd);
1254
1255         return (0);
1256 }
1257 MPT_COMMAND(top, debug, debug_config);
1258 #endif