/*      $NetBSD: raidctl.c,v 1.89 2026/02/18 19:45:51 joe Exp $   */

/*-
 * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Greg Oster
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This program is a re-write of the original rf_ctrl program
 * distributed by CMU with RAIDframe 1.1.
 *
 * This program is the user-land interface to the RAIDframe kernel
 * driver in NetBSD.
 */
#include <sys/cdefs.h>

#ifndef lint
__RCSID("$NetBSD: raidctl.c,v 1.89 2026/02/18 19:45:51 joe Exp $");
#endif


#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/disklabel.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <unistd.h>
#include <util.h>

#include <dev/raidframe/raidframevar.h>
#include <dev/raidframe/raidframeio.h>
#include "rf_configure.h"
#include "prog_ops.h"

#ifndef RAIDFRAME_REMOVE_COMPONENT
#define RAIDFRAME_REMOVE_COMPONENT RAIDFRAME_REMOVE_HOT_SPARE
#endif

#define CONFIGURE_TEST  1       /* must be different from any raidframe ioctl */

void    do_ioctl(int, u_long, void *, const char *);
static  void rf_configure(int, char*, int);
static  const char *device_status(RF_DiskStatus_t);
static  void rf_get_device_status(int);
static  void rf_output_configuration(int, const char *);
static  void get_component_number(int, char *, int *, int *);
static  void rf_fail_disk(int, char *, int);
__dead static  void usage(void);
static  void get_component_label(int, char *);
static  void set_component_label(int, char *);
static  void init_component_labels(int, int);
static  void set_autoconfig(int, int, char *);
static  void add_hot_spare(int, char *);
static  void remove_component(int, char *);
static  void rebuild_in_place(int, char *);
static  void check_status(int,int);
static  void check_parity(int,int, char *);
static  void do_meter(int, u_long);
static  void get_bar(char *, double, int);
static  void get_time_string(char *, size_t, int);
static  void rf_output_pmstat(int, int);
static  void rf_pm_configure(int, int, char *, int[]);
static  void rf_simple_create(int, int, char *[]);
static  unsigned int xstrtouint(const char *);

int verbose;

static const char *rootpart[] = { "No", "Force", "Soft", "*invalid*" };

static void
get_comp(char *buf, char *arg, size_t bufsz)
{
        if (getfsspecname(buf, bufsz, arg) == NULL)
                errx(1,"%s",buf);
}

int
main(int argc,char *argv[])
{
        int ch, i;
        int num_options;
        unsigned long action;
        char config_filename[PATH_MAX];
        char dev_name[PATH_MAX];
        char name[PATH_MAX];
        char component[PATH_MAX];
        char autoconf[10];
        char *parityconf = NULL;
        int parityparams[3];
        int do_output;
        int do_recon;
        int do_rewrite;
        int raidID;
        int serial_number;
        struct stat st;
        int fd;
        int force;
        int openmode;
        int last_unit;
        struct timeval tv;

        num_options = 0;
        action = 0;
        do_output = 0;
        do_recon = 0;
        do_rewrite = 0;
        serial_number = 0;
        force = 0;
        last_unit = 0;
        openmode = O_RDWR;      /* default to read/write */

        if (argc > 5) {
                /* we have at least 5 args, so it might be a simplified config */

                strlcpy(name, argv[1], sizeof(name));
                fd = opendisk(name, openmode, dev_name, sizeof(dev_name), 0);
                if (fd != -1) {
                        /* we were able to open the device... */
                        if (fstat(fd, &st) == -1)
                                err(1, "stat failure on: %s", dev_name);
                        if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
                                err(1, "invalid device: %s", dev_name);

                        raidID = DISKUNIT(st.st_rdev);
                        if (strncmp(argv[2],"create",6)==0) {
                                rf_simple_create(fd,argc-3,&argv[3]);

                                /* set serial number, set autoconfig, init parity */

                                if (gettimeofday(&tv,NULL) == -1) {
                                        serial_number = 12345777;
                                } else {
                                        serial_number = tv.tv_sec;
                                }
                                init_component_labels(fd, serial_number);
                                strlcpy(autoconf, "yes", sizeof(autoconf));
                                set_autoconfig(fd, raidID, autoconf);

                        } else
                                usage();

                        close(fd);
                        exit(0);
                }

                /* otherwise we go back to regular parsing */
        }

        while ((ch = getopt(argc, argv,
            "a:A:c:C:f:F:g:GiI:l:LmM:r:R:sSpPt:uU:v")) != -1)
                switch (ch) {
                case 'a':
                        action = RAIDFRAME_ADD_HOT_SPARE;
                        get_comp(component, optarg, sizeof(component));
                        num_options++;
                        break;
                case 'A':
                        action = RAIDFRAME_SET_AUTOCONFIG;
                        strlcpy(autoconf, optarg, sizeof(autoconf));
                        num_options++;
                        break;
                case 'c':
                        action = RAIDFRAME_CONFIGURE;
                        strlcpy(config_filename, optarg,
                            sizeof(config_filename));
                        force = 0;
                        num_options++;
                        break;
                case 'C':
                        strlcpy(config_filename, optarg,
                            sizeof(config_filename));
                        action = RAIDFRAME_CONFIGURE;
                        force = 1;
                        num_options++;
                        break;
                case 'f':
                        action = RAIDFRAME_FAIL_DISK;
                        get_comp(component, optarg, sizeof(component));
                        do_recon = 0;
                        num_options++;
                        break;
                case 'F':
                        action = RAIDFRAME_FAIL_DISK;
                        get_comp(component, optarg, sizeof(component));
                        do_recon = 1;
                        num_options++;
                        break;
                case 'g':
                        action = RAIDFRAME_GET_COMPONENT_LABEL;
                        get_comp(component, optarg, sizeof(component));
                        openmode = O_RDONLY;
                        num_options++;
                        break;
                case 'G':
                        action = RAIDFRAME_GET_INFO;
                        openmode = O_RDONLY;
                        do_output = 1;
                        num_options++;
                        break;
                case 'i':
                        action = RAIDFRAME_REWRITEPARITY;
                        num_options++;
                        break;
                case 'I':
                        action = RAIDFRAME_INIT_LABELS;
                        serial_number = xstrtouint(optarg);
                        num_options++;
                        break;
                case 'l':
                        action = RAIDFRAME_SET_COMPONENT_LABEL;
                        get_comp(component, optarg, sizeof(component));
                        num_options++;
                        break;
                case 'L':
                        action = RAIDFRAME_RESCAN;
                        num_options++;
                        break;
                case 'm':
                        action = RAIDFRAME_PARITYMAP_STATUS;
                        openmode = O_RDONLY;
                        num_options++;
                        break;
                case 'M':
                        action = RAIDFRAME_PARITYMAP_SET_DISABLE;
                        parityconf = strdup(optarg);
                        num_options++;
                        /* XXXjld: should rf_pm_configure do the strtol()s? */
                        i = 0;
                        while (i < 3 && optind < argc &&
                            isdigit((unsigned char)argv[optind][0]))
                                parityparams[i++] = xstrtouint(argv[optind++]);
                        while (i < 3)
                                parityparams[i++] = 0;
                        break;
                case 'p':
                        action = RAIDFRAME_CHECK_PARITY;
                        openmode = O_RDONLY;
                        num_options++;
                        break;
                case 'P':
                        action = RAIDFRAME_CHECK_PARITY;
                        do_rewrite = 1;
                        num_options++;
                        break;
                case 'r':
                        action = RAIDFRAME_REMOVE_COMPONENT;
                        get_comp(component, optarg, sizeof(component));
                        num_options++;
                        break;
                case 'R':
                        get_comp(component, optarg, sizeof(component));
                        action = RAIDFRAME_REBUILD_IN_PLACE;
                        num_options++;
                        break;
                case 's':
                        action = RAIDFRAME_GET_INFO;
                        openmode = O_RDONLY;
                        num_options++;
                        break;
                case 'S':
                        action = RAIDFRAME_CHECK_RECON_STATUS_EXT;
                        openmode = O_RDONLY;
                        num_options++;
                        break;
                case 't':
                        action = CONFIGURE_TEST;
                        strlcpy(config_filename, optarg,
                            sizeof(config_filename));
                        num_options++;
                        break;
                case 'u':
                        action = RAIDFRAME_SHUTDOWN;
                        num_options++;
                        break;
                case 'U':
                        action = RAIDFRAME_SET_LAST_UNIT;
                        num_options++;
                        last_unit = atoi(optarg);
                        if (last_unit < 0)
                                errx(1, "Bad last unit %s", optarg);
                        break;
                case 'v':
                        verbose = 1;
                        /* Don't bump num_options, as '-v' is not
                           an option like the others */
                        /* num_options++; */
                        break;
                default:
                        usage();
                }
        argc -= optind;
        argv += optind;

        if (num_options > 1)
                usage();

        if (action == CONFIGURE_TEST) {
                RF_Config_t cfg;

                if (argc != 0)
                        usage();
                if (rf_MakeConfig(config_filename, &cfg) != 0)
                        exit(1);
                exit(0);;
        }

        if (argc != 1)
                usage();

        if (prog_init && prog_init() == -1)
                err(1, "init failed");

        strlcpy(name, argv[0], sizeof(name));
        fd = opendisk1(name, openmode, dev_name, sizeof(dev_name), 0,
            prog_open);
        if (fd == -1)
                err(1, "Unable to open device file: %s", name);
        if (prog_fstat(fd, &st) == -1)
                err(1, "stat failure on: %s", dev_name);
        if (!S_ISBLK(st.st_mode) && !S_ISCHR(st.st_mode))
                err(1, "invalid device: %s", dev_name);

        raidID = DISKUNIT(st.st_rdev);

        switch (action) {
        case RAIDFRAME_ADD_HOT_SPARE:
                add_hot_spare(fd, component);
                break;
        case RAIDFRAME_REMOVE_COMPONENT:
                remove_component(fd, component);
                break;
        case RAIDFRAME_CONFIGURE:
                rf_configure(fd, config_filename, force);
                break;
        case RAIDFRAME_SET_AUTOCONFIG:
                set_autoconfig(fd, raidID, autoconf);
                break;
        case RAIDFRAME_FAIL_DISK:
                rf_fail_disk(fd, component, do_recon);
                break;
        case RAIDFRAME_SET_COMPONENT_LABEL:
                set_component_label(fd, component);
                break;
        case RAIDFRAME_GET_COMPONENT_LABEL:
                get_component_label(fd, component);
                break;
        case RAIDFRAME_INIT_LABELS:
                init_component_labels(fd, serial_number);
                break;
        case RAIDFRAME_REWRITEPARITY:
                printf("Initiating re-write of parity\n");
                do_ioctl(fd, RAIDFRAME_REWRITEPARITY, NULL,
                         "RAIDFRAME_REWRITEPARITY");
                if (verbose) {
                        sleep(3); /* XXX give it time to get started */
                        printf("Parity Re-write status:\n");
                        do_meter(fd, RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT);
                }
                break;
        case RAIDFRAME_CHECK_RECON_STATUS_EXT:
                check_status(fd,1);
                break;
        case RAIDFRAME_GET_INFO:
                if (do_output)
                        rf_output_configuration(fd, dev_name);
                else
                        rf_get_device_status(fd);
                break;
        case RAIDFRAME_PARITYMAP_STATUS:
                rf_output_pmstat(fd, raidID);
                break;
        case RAIDFRAME_PARITYMAP_SET_DISABLE:
                rf_pm_configure(fd, raidID, parityconf, parityparams);
                break;
        case RAIDFRAME_REBUILD_IN_PLACE:
                rebuild_in_place(fd, component);
                break;
        case RAIDFRAME_CHECK_PARITY:
                check_parity(fd, do_rewrite, dev_name);
                break;
        case RAIDFRAME_SHUTDOWN:
                do_ioctl(fd, RAIDFRAME_SHUTDOWN, NULL, "RAIDFRAME_SHUTDOWN");
                break;
        case RAIDFRAME_SET_LAST_UNIT:
                do_ioctl(fd, RAIDFRAME_SET_LAST_UNIT, &last_unit,
                    "RAIDFRAME_SET_LAST_UNIT");
                break;
        case RAIDFRAME_RESCAN:
                do_ioctl(fd, RAIDFRAME_RESCAN, NULL, "RAIDFRAME_RESCAN");
                break;
        default:
                break;
        }

        prog_close(fd);
        exit(0);
}

void
do_ioctl(int fd, unsigned long command, void *arg, const char *ioctl_name)
{
        if (prog_ioctl(fd, command, arg) == -1)
                err(1, "ioctl (%s) failed", ioctl_name);
}


static void
rf_configure(int fd, char *config_file, int force)
{
        void *generic;
        RF_Config_t cfg;

        if (rf_MakeConfig( config_file, &cfg ) != 0)
                err(1, "Unable to create RAIDframe configuration structure");

        cfg.force = force;

        /*
         * Note the extra level of redirection needed here, since
         * what we really want to pass in is a pointer to the pointer to
         * the configuration structure.
         */

        generic = &cfg;
        do_ioctl(fd, RAIDFRAME_CONFIGURE, &generic, "RAIDFRAME_CONFIGURE");
}

static const char *
device_status(RF_DiskStatus_t status)
{

        switch (status) {
        case rf_ds_optimal:
                return ("optimal");
        case rf_ds_failed:
                return ("failed");
        case rf_ds_reconstructing:
                return ("reconstructing");
        case rf_ds_dist_spared:
                return ("dist_spared");
        case rf_ds_spared:
                return ("spared");
        case rf_ds_spare:
                return ("spare");
        case rf_ds_used_spare:
                return ("used_spare");
        default:
                return ("UNKNOWN");
        }
        /* NOTREACHED */
}

static void
rf_get_device_status(int fd)
{
        RF_DeviceConfig_t device_config;
        void *cfg_ptr;
        int is_clean;
        int i, nspares;

        cfg_ptr = &device_config;

        do_ioctl(fd, RAIDFRAME_GET_INFO, &cfg_ptr, "RAIDFRAME_GET_INFO");

        printf("Components:\n");
        for(i=0; i < device_config.ndevs; i++) {
                printf("%20s: %s\n", device_config.devs[i].devname,
                       device_status(device_config.devs[i].status));
        }

        nspares = MIN(device_config.nspares,
                        __arraycount(device_config.spares));

        if (nspares > 0) {
                printf("Spares:\n");
                for(i=0; i < nspares; i++) {
                        printf("%20s: %s\n",
                               device_config.spares[i].devname,
                               device_status(device_config.spares[i].status));
                }
        } else {
                printf("No spares.\n");
        }
        for(i=0; i < device_config.ndevs; i++) {
                if (device_config.devs[i].status == rf_ds_optimal) {
                        get_component_label(fd, device_config.devs[i].devname);
                } else {
                        printf("%s status is: %s.  Skipping label.\n",
                               device_config.devs[i].devname,
                               device_status(device_config.devs[i].status));
                }
        }

        if (nspares > 0) {
                for(i=0; i < nspares; i++) {
                        if ((device_config.spares[i].status ==
                             rf_ds_optimal) ||
                            (device_config.spares[i].status ==
                             rf_ds_used_spare)) {
                                get_component_label(fd,
                                            device_config.spares[i].devname);
                        } else {
                                printf("%s status is: %s.  Skipping label.\n",
                                       device_config.spares[i].devname,
                                       device_status(
                                           device_config.spares[i].status));
                        }
                }
        }

        do_ioctl(fd, RAIDFRAME_CHECK_PARITY, &is_clean,
                 "RAIDFRAME_CHECK_PARITY");
        if (is_clean) {
                printf("Parity status: clean\n");
        } else {
                printf("Parity status: DIRTY\n");
        }
        check_status(fd,0);
}

static void
rf_output_pmstat(int fd, int raidID)
{
        char srs[7];
        unsigned int i, j;
        int dis, dr;
        struct rf_pmstat st;

        if (prog_ioctl(fd, RAIDFRAME_PARITYMAP_STATUS, &st) == -1) {
                if (errno == EINVAL) {
                        printf("raid%d: has no parity; parity map disabled\n",
                                raidID);
                        return;
                }
                err(1, "ioctl (%s) failed", "RAIDFRAME_PARITYMAP_STATUS");
        }

        if (st.enabled) {
                if (0 > humanize_number(srs, 7, st.region_size * DEV_BSIZE,
                        "B", HN_AUTOSCALE, HN_NOSPACE))
                        strlcpy(srs, "???", 7);

                printf("raid%d: parity map enabled with %u regions of %s\n",
                    raidID, st.params.regions, srs);
                printf("raid%d: regions marked clean after %d intervals of"
                    " %d.%03ds\n", raidID, st.params.cooldown,
                    st.params.tickms / 1000, st.params.tickms % 1000);
                printf("raid%d: write/sync/clean counters "
                    "%"PRIu64"/%"PRIu64"/%"PRIu64"\n", raidID,
                    st.ctrs.nwrite, st.ctrs.ncachesync, st.ctrs.nclearing);

                dr = 0;
                for (i = 0; i < st.params.regions; i++)
                        if (isset(st.dirty, i))
                                dr++;
                printf("raid%d: %d dirty region%s\n", raidID, dr,
                    dr == 1 ? "" : "s");

                if (verbose > 0) {
                        for (i = 0; i < RF_PARITYMAP_NBYTE; i += 32) {
                                printf("    ");
                                for (j = i; j < RF_PARITYMAP_NBYTE
                                         && j < i + 32; j++)
                                        printf("%x%x", st.dirty[j] & 15,
                                            (st.dirty[j] >> 4) & 15);
                                printf("\n");
                        }
                }
        } else {
                printf("raid%d: parity map disabled\n", raidID);
        }

        do_ioctl(fd, RAIDFRAME_PARITYMAP_GET_DISABLE, &dis,
            "RAIDFRAME_PARITYMAP_GET_DISABLE");
        printf("raid%d: parity map will %s %sabled on next configure\n",
            raidID, dis == st.enabled ? "be" : "remain", dis ? "dis" : "en");
}

static void
rf_pm_configure(int fd, int raidID, char *parityconf, int parityparams[])
{
        int dis;
        struct rf_pmparams params;

        if (strcasecmp(parityconf, "yes") == 0)
                dis = 0;
        else if (strcasecmp(parityconf, "no") == 0)
                dis = 1;
        else if (strcasecmp(parityconf, "set") == 0) {
                params.cooldown = parityparams[0];
                params.tickms = parityparams[1];
                params.regions = parityparams[2];

                do_ioctl(fd, RAIDFRAME_PARITYMAP_SET_PARAMS, &params,
                    "RAIDFRAME_PARITYMAP_SET_PARAMS");

                if (params.cooldown != 0 || params.tickms != 0) {
                        printf("raid%d: parity cleaned after", raidID);
                        if (params.cooldown != 0)
                                printf(" %d", params.cooldown);
                        printf(" intervals");
                        if (params.tickms != 0) {
                                printf(" of %d.%03ds", params.tickms / 1000,
                                    params.tickms % 1000);
                        }
                        printf("\n");
                }
                if (params.regions != 0)
                        printf("raid%d: will use %d regions on next"
                            " configuration\n", raidID, params.regions);

                return;
                /* XXX the control flow here could be prettier. */
        } else
                err(1, "`%s' is not a valid parity map command", parityconf);

        do_ioctl(fd, RAIDFRAME_PARITYMAP_SET_DISABLE, &dis,
            "RAIDFRAME_PARITYMAP_SET_DISABLE");
        printf("raid%d: parity map will be %sabled on next configure\n",
            raidID, dis ? "dis" : "en");
}

/* convert "component0" into "absent" */
static const char *rf_output_devname(const char *name)
{

        if (strncmp(name, "component", 9) == 0)
                return "absent";
        return name;
}

static void
rf_output_configuration(int fd, const char *name)
{
        RF_DeviceConfig_t device_config;
        void *cfg_ptr;
        int i, nspares;
        RF_ComponentLabel_t component_label;
        void *label_ptr;
        int component_num;
        int num_cols;

        cfg_ptr = &device_config;

        printf("# raidctl config file for %s\n", name);
        printf("\n");
        do_ioctl(fd, RAIDFRAME_GET_INFO, &cfg_ptr, "RAIDFRAME_GET_INFO");

        nspares = MIN(device_config.nspares,
                        __arraycount(device_config.spares));

        printf("START array\n");
        printf("# numCol numSpare\n");
        printf("%d %d\n", device_config.cols, device_config.nspares);
        printf("\n");

        printf("START disks\n");
        for(i=0; i < device_config.ndevs; i++)
                printf("%s\n",
                    rf_output_devname(device_config.devs[i].devname));
        printf("\n");

        if (nspares > 0) {
                printf("START spare\n");
                for(i=0; i < nspares; i++)
                        printf("%s\n", device_config.spares[i].devname);
                printf("\n");
        }

        for(i=0; i < device_config.ndevs; i++) {
                if (device_config.devs[i].status == rf_ds_optimal)
                        break;
        }
        if (i == device_config.ndevs) {
                printf("# WARNING: no optimal components; using %s\n",
                    device_config.devs[0].devname);
                i = 0;
        }
        get_component_number(fd, device_config.devs[i].devname,
            &component_num, &num_cols);
        memset(&component_label, 0, sizeof(RF_ComponentLabel_t));
        component_label.row = component_num / num_cols;
        component_label.column = component_num % num_cols;
        label_ptr = &component_label;
        do_ioctl(fd, RAIDFRAME_GET_COMPONENT_LABEL, label_ptr,
                  "RAIDFRAME_GET_COMPONENT_LABEL");

        printf("START layout\n");
        printf(
            "# sectPerSU SUsPerParityUnit SUsPerReconUnit RAID_level_%c\n",
            (char) component_label.parityConfig);
        printf("%d %d %d %c\n",
            component_label.sectPerSU, component_label.SUsPerPU,
            component_label.SUsPerRU, (char) component_label.parityConfig);
        printf("\n");

        printf("START queue\n");
        printf("fifo %d\n", device_config.maxqdepth);
}

static void
get_component_number(int fd, char *component_name, int *component_number,
                     int *num_columns)
{
        RF_DeviceConfig_t device_config;
        void *cfg_ptr;
        int i, nspares;
        int found;

        *component_number = -1;

        /* Assuming a full path spec... */
        cfg_ptr = &device_config;
        do_ioctl(fd, RAIDFRAME_GET_INFO, &cfg_ptr,
                 "RAIDFRAME_GET_INFO");

        *num_columns = device_config.cols;

        nspares = MIN(device_config.nspares,
                        __arraycount(device_config.spares));

        found = 0;
        for(i=0; i < device_config.ndevs; i++) {
                if (strncmp(component_name, device_config.devs[i].devname,
                            PATH_MAX)==0) {
                        found = 1;
                        *component_number = i;
                }
        }
        if (!found) { /* maybe it's a spare? */
                for(i=0; i < nspares; i++) {
                        if (strncmp(component_name,
                                    device_config.spares[i].devname,
                                    PATH_MAX)==0) {
                                found = 1;
                                *component_number = i + device_config.ndevs;
                                /* the way spares are done should
                                   really change... */
                                *num_columns = device_config.cols +
                                        device_config.nspares;
                        }
                }
        }

        if (!found)
                err(1,"%s is not a component of this device", component_name);
}

static void
rf_fail_disk(int fd, char *component_to_fail, int do_recon)
{
        struct rf_recon_req recon_request;
        int component_num;
        int num_cols;

        get_component_number(fd, component_to_fail, &component_num, &num_cols);

        recon_request.col = component_num % num_cols;
        if (do_recon) {
                recon_request.flags = RF_FDFLAGS_RECON;
        } else {
                recon_request.flags = RF_FDFLAGS_NONE;
        }
        do_ioctl(fd, RAIDFRAME_FAIL_DISK, &recon_request,
                 "RAIDFRAME_FAIL_DISK");
        if (do_recon && verbose) {
                printf("Reconstruction status:\n");
                sleep(3); /* XXX give reconstruction a chance to start */
                do_meter(fd,RAIDFRAME_CHECK_RECON_STATUS_EXT);
        }
}

static void
get_component_label(int fd, char *component)
{
        RF_ComponentLabel_t component_label;
        void *label_ptr;
        int component_num;
        int num_cols;

        get_component_number(fd, component, &component_num, &num_cols);

        memset( &component_label, 0, sizeof(RF_ComponentLabel_t));
        component_label.row = component_num / num_cols;
        component_label.column = component_num % num_cols;

        label_ptr = &component_label;
        do_ioctl( fd, RAIDFRAME_GET_COMPONENT_LABEL, label_ptr,
                  "RAIDFRAME_GET_COMPONENT_LABEL");

        printf("Component label for %s:\n",component);

        printf("   Row: %d, Column: %d, Num Rows: %d, Num Columns: %d\n",
               component_label.row, component_label.column,
               component_label.num_rows, component_label.num_columns);
        printf("   Version: %d, Serial Number: %u, Mod Counter: %d\n",
               component_label.version, component_label.serial_number,
               component_label.mod_counter);
        printf("   Clean: %s, Status: %d\n",
               component_label.clean ? "Yes" : "No",
               component_label.status );
        printf("   sectPerSU: %d, SUsPerPU: %d, SUsPerRU: %d\n",
               component_label.sectPerSU, component_label.SUsPerPU,
               component_label.SUsPerRU);
        printf("   Queue size: %d, blocksize: %d, numBlocks: %"PRIu64"\n",
               component_label.maxOutstanding, component_label.blockSize,
               rf_component_label_numblocks(&component_label));
        printf("   RAID Level: %c\n", (char) component_label.parityConfig);
        printf("   Autoconfig: %s\n",
               component_label.autoconfigure ? "Yes" : "No" );
        printf("   Root partition: %s\n",
               rootpart[component_label.root_partition & 3]);
        printf("   Last configured as: raid%d\n", component_label.last_unit );
}

static void
set_component_label(int fd, char *component)
{
        RF_ComponentLabel_t component_label;
        int component_num;
        int num_cols;

        get_component_number(fd, component, &component_num, &num_cols);

        /* XXX This is currently here for testing, and future expandability */

        component_label.version = 1;
        component_label.serial_number = 123456;
        component_label.mod_counter = 0;
        component_label.row = component_num / num_cols;
        component_label.column = component_num % num_cols;
        component_label.num_rows = 0;
        component_label.num_columns = 5;
        component_label.clean = 0;
        component_label.status = 1;

        do_ioctl( fd, RAIDFRAME_SET_COMPONENT_LABEL, &component_label,
                  "RAIDFRAME_SET_COMPONENT_LABEL");
}


static void
init_component_labels(int fd, int serial_number)
{
        RF_ComponentLabel_t component_label;

        component_label.version = 0;
        component_label.serial_number = serial_number;
        component_label.mod_counter = 0;
        component_label.row = 0;
        component_label.column = 0;
        component_label.num_rows = 0;
        component_label.num_columns = 0;
        component_label.clean = 0;
        component_label.status = 0;

        do_ioctl( fd, RAIDFRAME_INIT_LABELS, &component_label,
                  "RAIDFRAME_INIT_LABELS");
}

static void
set_autoconfig(int fd, int raidID, char *autoconf)
{
        int auto_config;
        int root_config;

        auto_config = 0;
        root_config = 0;

        if (strncasecmp(autoconf, "root", 4) == 0 ||
            strncasecmp(autoconf, "hard", 4) == 0 ||
            strncasecmp(autoconf, "force", 5) == 0) {
                root_config = 1;
        } else if (strncasecmp(autoconf, "soft", 4) == 0) {
                root_config = 2;
        }

        if ((strncasecmp(autoconf,"yes", 3) == 0) ||
            root_config > 0) {
                auto_config = 1;
        }

        do_ioctl(fd, RAIDFRAME_SET_AUTOCONFIG, &auto_config,
                 "RAIDFRAME_SET_AUTOCONFIG");

        do_ioctl(fd, RAIDFRAME_SET_ROOT, &root_config,
                 "RAIDFRAME_SET_ROOT");

        if (verbose) {
                printf("raid%d: Autoconfigure: %s\n", raidID,
                       auto_config ? "Yes" : "No");
                if (auto_config == 1) {
                        printf("raid%d: Root: %s\n", raidID, rootpart[root_config]);
                }
        }
}

static void
add_hot_spare(int fd, char *component)
{
        RF_SingleComponent_t hot_spare;

        hot_spare.row = 0;
        hot_spare.column = 0;
        strncpy(hot_spare.component_name, component,
                sizeof(hot_spare.component_name));

        do_ioctl( fd, RAIDFRAME_ADD_HOT_SPARE, &hot_spare,
                  "RAIDFRAME_ADD_HOT_SPARE");
}

static void
remove_component(int fd, char *component)
{
        RF_SingleComponent_t comp;
        int component_num;
        int num_cols;

        get_component_number(fd, component, &component_num, &num_cols);

        comp.row = component_num / num_cols;
        comp.column = component_num % num_cols;

        strncpy(comp.component_name, component,
                sizeof(comp.component_name));

        do_ioctl( fd, RAIDFRAME_REMOVE_COMPONENT, &comp,
                  "RAIDFRAME_REMOVE_COMPONENT");
}

static void
rebuild_in_place(int fd, char *component)
{
        RF_SingleComponent_t comp;
        int component_num;
        int num_cols;

        get_component_number(fd, component, &component_num, &num_cols);

        comp.row = 0;
        comp.column = component_num;
        strncpy(comp.component_name, component, sizeof(comp.component_name));

        do_ioctl( fd, RAIDFRAME_REBUILD_IN_PLACE, &comp,
                  "RAIDFRAME_REBUILD_IN_PLACE");

        if (verbose) {
                printf("Reconstruction status:\n");
                sleep(3); /* XXX give reconstruction a chance to start */
                do_meter(fd,RAIDFRAME_CHECK_RECON_STATUS_EXT);
        }

}

static void
check_parity(int fd, int do_rewrite, char *dev_name)
{
        int is_clean;
        int percent_done;

        is_clean = 0;
        percent_done = 0;
        do_ioctl(fd, RAIDFRAME_CHECK_PARITY, &is_clean,
                 "RAIDFRAME_CHECK_PARITY");
        if (is_clean) {
                printf("%s: Parity status: clean\n",dev_name);
        } else {
                printf("%s: Parity status: DIRTY\n",dev_name);
                if (do_rewrite) {
                        printf("%s: Initiating re-write of parity\n",
                               dev_name);
                        do_ioctl(fd, RAIDFRAME_REWRITEPARITY, NULL,
                                 "RAIDFRAME_REWRITEPARITY");
                        sleep(3); /* XXX give it time to
                                     get started. */
                        if (verbose) {
                                printf("Parity Re-write status:\n");
                                do_meter(fd,
                                    RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT);
                        } else {
                                do_ioctl(fd,
                                         RAIDFRAME_CHECK_PARITYREWRITE_STATUS,
                                         &percent_done,
                                         "RAIDFRAME_CHECK_PARITYREWRITE_STATUS"
                                         );
                                while( percent_done < 100 ) {
                                        sleep(3); /* wait a bit... */
                                        do_ioctl(fd,
                                           RAIDFRAME_CHECK_PARITYREWRITE_STATUS,
                                                 &percent_done,
                                    "RAIDFRAME_CHECK_PARITYREWRITE_STATUS");
                                }

                        }
                        printf("%s: Parity Re-write complete\n", dev_name);
                } else {
                        /* parity is wrong, and is not being fixed.
                           Exit w/ an error. */
                        exit(1);
                }
        }
}


static void
check_status(int fd, int meter)
{
        int recon_percent_done = 0;
        int parity_percent_done = 0;

        do_ioctl(fd, RAIDFRAME_CHECK_RECON_STATUS, &recon_percent_done,
                 "RAIDFRAME_CHECK_RECON_STATUS");
        printf("Reconstruction is %d%% complete.\n", recon_percent_done);
        do_ioctl(fd, RAIDFRAME_CHECK_PARITYREWRITE_STATUS,
                 &parity_percent_done,
                 "RAIDFRAME_CHECK_PARITYREWRITE_STATUS");
        printf("Parity Re-write is %d%% complete.\n", parity_percent_done);

        if (meter) {
                /* These 3 should be mutually exclusive at this point */
                if (recon_percent_done < 100) {
                        printf("Reconstruction status:\n");
                        do_meter(fd,RAIDFRAME_CHECK_RECON_STATUS_EXT);
                } else if (parity_percent_done < 100) {
                        printf("Parity Re-write status:\n");
                        do_meter(fd,RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT);
                }
        }
}

const char *tbits = "|/-\\";

static void
do_meter(int fd, u_long option)
{
        int percent_done;
        RF_uint64 start_value;
        RF_ProgressInfo_t progressInfo;
        void *pInfoPtr;
        struct timeval start_time;
        struct timeval current_time;
        double elapsed;
        int elapsed_sec;
        int elapsed_usec;
        int simple_eta,last_eta;
        double rate;
        RF_uint64 amount;
        int tbit_value;
        char bar_buffer[1024];
        char eta_buffer[1024];

        if (gettimeofday(&start_time,NULL) == -1)
                err(1, "gettimeofday failed!?!?");
        memset(&progressInfo, 0, sizeof(RF_ProgressInfo_t));
        pInfoPtr=&progressInfo;

        percent_done = 0;
        do_ioctl(fd, option, pInfoPtr, "");
        start_value = progressInfo.completed;
        current_time = start_time;
        simple_eta = 0;
        last_eta = 0;

        tbit_value = 0;
        while(progressInfo.completed < progressInfo.total) {

                percent_done = (progressInfo.completed * 100) /
                        progressInfo.total;

                get_bar(bar_buffer, percent_done, 40);

                elapsed_sec = current_time.tv_sec - start_time.tv_sec;
                elapsed_usec = current_time.tv_usec - start_time.tv_usec;
                if (elapsed_usec < 0) {
                        elapsed_usec-=1000000;
                        elapsed_sec++;
                }

                elapsed = (double) elapsed_sec +
                        (double) elapsed_usec / 1000000.0;

                amount = progressInfo.completed - start_value;

                if (amount <= 0) { /* we don't do negatives (yet?) */
                        amount = 0;
                }

                if (elapsed == 0)
                        rate = 0.0;
                else
                        rate = amount / elapsed;

                if (rate > 0.0) {
                        simple_eta = (int) (((double)progressInfo.total -
                                             (double) progressInfo.completed)
                                            / rate);
                } else {
                        simple_eta = -1;
                }

                if (simple_eta <=0) {
                        simple_eta = last_eta;
                } else {
                        last_eta = simple_eta;
                }

                get_time_string(eta_buffer, sizeof eta_buffer, simple_eta);

                fprintf(stdout,"\r%3d%% |%s| ETA: %s %c",
                        percent_done,bar_buffer,eta_buffer,tbits[tbit_value]);
                fflush(stdout);

                if (++tbit_value>3)
                        tbit_value = 0;

                sleep(2);

                if (gettimeofday(&current_time,NULL) == -1)
                        err(1, "gettimeofday failed!?!?");

                do_ioctl( fd, option, pInfoPtr, "");


        }
        printf("\n");
}
/* 40 '*''s per line, then 40 ' ''s line. */
/* If you've got a screen wider than 160 characters, "tough" */

#define STAR_MIDPOINT 4*40
const char stars[] = "****************************************"
                     "****************************************"
                     "****************************************"
                     "****************************************"
                     "                                        "
                     "                                        "
                     "                                        "
                     "                                        "
                     "                                        ";

static void
get_bar(char *string, double percent, int max_strlen)
{
        int offset;

        if (max_strlen > STAR_MIDPOINT) {
                max_strlen = STAR_MIDPOINT;
        }
        offset = STAR_MIDPOINT -
                (int)((percent * max_strlen)/ 100);
        if (offset < 0)
                offset = 0;
        snprintf(string,max_strlen,"%s",stars+offset);
}

static void
get_time_string(char *string, size_t len, int simple_time)
{
        int minutes, seconds, hours;
        char hours_buffer[8];
        char minutes_buffer[5];
        char seconds_buffer[5];

        if (simple_time >= 0) {

                minutes = simple_time / 60;
                seconds = simple_time - 60*minutes;
                hours = minutes / 60;
                minutes = minutes - 60*hours;
#if defined(__GNUC__)
                /*
                 * snprintf() truncation checker fails to detect that seconds
                 * and minutes will be 0-59 range.
                 */
                if (minutes < 0 || minutes > 60)
                        minutes = 60;
                if (seconds < 0 || seconds > 60)
                        seconds = 60;
#endif

                if (hours > 0) {
                        snprintf(hours_buffer,sizeof hours_buffer,
                            "%02d:",hours);
                } else {
                        snprintf(hours_buffer,sizeof hours_buffer,"   ");
                }

                snprintf(minutes_buffer,sizeof minutes_buffer,"%02d:",minutes);
                snprintf(seconds_buffer,sizeof seconds_buffer,"%02d",seconds);
                snprintf(string,len,"%s%s%s",
                         hours_buffer, minutes_buffer, seconds_buffer);
        } else {
                snprintf(string,len,"   --:--");
        }

}

static void
component_err(int level)
{
        const char *limit;
        switch (level) {
        case 0:
                limit = "more than one";
                break;
        case 1:
                limit = "exactly two";
                break;
        case 5:
                limit = "more than two";
                break;
        default:
                return; /* no use */
        }

        fprintf(stderr,  "For RAID level %d the number of columns must be %s.\n", level, limit);
        usage();
}

/* Simplified RAID creation with a single command line... */
static void
rf_simple_create(int fd, int argc, char *argv[])
{
        int i;
        int level;
        int num_components;
        char *components[RF_MAXCOL];
        void *generic;
        RF_Config_t cfg;

        /*
         * Note the extra level of redirection needed here, since
         * what we really want to pass in is a pointer to the pointer to
         * the configuration structure.
         */


        if (strcmp(argv[0],"mirror")==0) {
                level = 1;
        } else
                level = xstrtouint(argv[0]);

        if (level != 0 && level != 1 && level !=5)
                usage();

        /* remaining args must be components */
        num_components = 0;
        for (i=1 ; i<argc ; i++) {
                components[i-1] = argv[i];
                num_components++;
        }

        /* Level 0 must have at least two components.
           Level 1 must have exactly two components.
           Level 5 must have at least three components. */
        if ((level == 0 && num_components < 2) ||
            (level == 1 && num_components != 2) ||
            (level == 5 && num_components < 3))
                component_err(level);

        /* build a config... */

        memset(&cfg, 0, sizeof(cfg));

        cfg.numCol = num_components;
        cfg.numSpare = 0;

        for (i=0 ; i<num_components; i++) {
                strlcpy(cfg.devnames[0][i], components[i],
                        sizeof(cfg.devnames[0][i]));
        }

        /* pick some reasonable values for sectPerSU, etc. */
        if (level == 0) {
                if (num_components == 2) {
                        /* 64 blocks (32K) per component - 64K data per stripe */
                        cfg.sectPerSU = 64;
                } else if (num_components == 3 || num_components == 4) {
                        /* 32 blocks (16K) per component - 64K data per strip for
                           the 4-component case. */
                        cfg.sectPerSU = 32;
                } else {
                        /* 16 blocks (8K) per component */
                        cfg.sectPerSU = 16;
                }
        } else if (level == 1) {
                /* 128 blocks (64K per component) - 64K per stripe */
                cfg.sectPerSU = 128;
        } else if (level == 5) {
                if (num_components == 3) {
                        /* 64 blocks (32K) per disk - 64K data per stripe */
                        cfg.sectPerSU = 64;
                } else if (num_components >= 4 && num_components < 9) {
                        /* 4 components makes 3 data components.  No power of 2 is
                           evenly divisible by 3 so performance will be lousy
                           regardless of what number we choose here.  5 components is
                           what we are really hoping for here, as 5 components with 4
                           data components on RAID 5 means 32 blocks (16K) per data
                           component, or 64K per stripe */
                        cfg.sectPerSU = 32;
                } else {
                        /* 9 components here is optimal for 16 blocks (8K) per data
                           component */
                        cfg.sectPerSU = 16;
                }
        } else
                usage();

        cfg.SUsPerPU = 1;
        cfg.SUsPerRU = 1;
        cfg.parityConfig = '0' + level;
        strlcpy(cfg.diskQueueType, "fifo", sizeof(cfg.diskQueueType));
        cfg.maxOutstandingDiskReqs = 1;
        cfg.force = 1;

        /* configure... */

        generic = &cfg;
        do_ioctl(fd, RAIDFRAME_CONFIGURE, &generic, "RAIDFRAME_CONFIGURE");

        if (level == 1 || level == 5)
                do_ioctl(fd, RAIDFRAME_REWRITEPARITY, NULL,
                         "RAIDFRAME_REWRITEPARITY");
}


static void
usage(void)
{
        const char *progname = getprogname();

        fprintf(stderr,
                "usage: %s dev create [0 | 1 | mirror | 5] component component ...\n",
                progname);
        fprintf(stderr, "       %s [-v] -A [yes | no | softroot | hardroot] dev\n",
                progname);
        fprintf(stderr, "       %s [-v] -a component dev\n", progname);
        fprintf(stderr, "       %s [-v] -B dev\n", progname);
        fprintf(stderr, "       %s [-v] -C config_file dev\n", progname);
        fprintf(stderr, "       %s [-v] -c config_file dev\n", progname);
        fprintf(stderr, "       %s [-v] -F component dev\n", progname);
        fprintf(stderr, "       %s [-v] -f component dev\n", progname);
        fprintf(stderr, "       %s [-v] -G dev\n", progname);
        fprintf(stderr, "       %s [-v] -g component dev\n", progname);
        fprintf(stderr, "       %s [-v] -I serial_number dev\n", progname);
        fprintf(stderr, "       %s [-v] -i dev\n", progname);
        fprintf(stderr, "       %s [-v] -M [yes | no | set params] dev\n",
            progname);
        fprintf(stderr, "       %s [-v] -m dev\n", progname);
        fprintf(stderr, "       %s [-v] -P dev\n", progname);
        fprintf(stderr, "       %s [-v] -p dev\n", progname);
        fprintf(stderr, "       %s [-v] -R component dev\n", progname);
        fprintf(stderr, "       %s [-v] -r component dev\n", progname);
        fprintf(stderr, "       %s [-v] -S dev\n", progname);
        fprintf(stderr, "       %s [-v] -s dev\n", progname);
        fprintf(stderr, "       %s [-v] -t config_file\n", progname);
        fprintf(stderr, "       %s [-v] -U unit dev\n", progname);
        fprintf(stderr, "       %s [-v] -u dev\n", progname);
        exit(1);
        /* NOTREACHED */
}

static unsigned int
xstrtouint(const char *str)
{
        int e;
        unsigned int num = (unsigned int)strtou(str, NULL, 10, 0, INT_MAX, &e);
        if (e)
                errc(EXIT_FAILURE, e, "Bad number `%s'", str);
        return num;
}