/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 1999 Michael Smith
 * All rights reserved.
 *
 * 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 AUTHOR 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 AUTHOR 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.
 */

#include <fcntl.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <err.h>

#include <dev/mlx/mlxio.h>
#include <dev/mlx/mlxreg.h>

#include "mlxcontrol.h"

static int      cmd_status(int argc, char *argv[]);
static int      cmd_rescan(int argc, char *argv[]);
static int      cmd_detach(int argc, char *argv[]);
static int      cmd_check(int argc, char *argv[]);
static int      cmd_rebuild(int argc, char *argv[]);
#ifdef SUPPORT_PAUSE
static int      cmd_pause(int argc, char *argv[]);
#endif
static int      cmd_help(int argc, char *argv[]);

extern int      cmd_config(int argc, char *argv[]);


struct 
{
    char        *cmd;
    int         (*func)(int argc, char *argv[]);
    char        *desc;
    char        *text;
} commands[] = {
    {"status",  cmd_status, 
     "displays device status",
     "  status [-qv] [<drive>...]\n"
     "      Display status for <drive> or all drives if none is listed\n"
     "  -q    Suppress output.\n"
     "  -v    Display verbose information.\n"
     "  Returns 0 if all drives tested are online, 1 if one or more are\n"
     "  critical, and 2 if one or more are offline."},
    {"rescan",  cmd_rescan, 
     "scan for new system drives",
     "  rescan <controller> [<controller>...]\n"
     "      Rescan <controller> for system drives.\n"
     "  rescan -a\n"
     "      Rescan all controllers for system drives."},
    {"detach",  cmd_detach,
     "detach system drives",
     "  detach <drive> [<drive>...]\n"
     "      Detaches <drive> from the controller.\n"
     "  detach -a <controller>\n"
     "      Detaches all drives on <controller>."},
    {"check",   cmd_check,
     "consistency-check a system drive",
     "  check <drive>\n"
     "      Requests a check and rebuild of the parity information on <drive>.\n"
     "      Note that each controller can only check one system drive at a time."},
    {"rebuild", cmd_rebuild,
     "initiate a rebuild of a dead physical drive",
     "  rebuild <controller> <physdrive>\n"
     "      All system drives using space on the physical drive <physdrive>\n"
     "      are rebuilt, reconstructing all data on the drive.\n"
     "      Note that each controller can only perform one rebuild at a time."},
#ifdef SUPPORT_PAUSE
    {"pause",   cmd_pause,
     "pauses controller channels",
     "  pause [-t <howlong>] [-d <delay>] <controller> [<channel>...]\n"
     "      Pauses SCSI I/O on <channel> and <controller>.  If no channel is specified,\n"
     "      all channels are paused.\n"
     "  <howlong>   How long (seconds) to pause for (default 30).\n"
     "  <delay>     How long (seconds) to wait before pausing (default 30).\n"
     "  pause <controller> -c\n"
     "      Cancels any pending pause operation on <controller>."},
#endif
    {"config",  cmd_config,
     "examine and update controller configuration",
     "  config <controller>\n"
     "      Print configuration for <controller>."},
    {"help",    cmd_help,   
     "give help on usage",
     ""},
    {NULL, NULL, NULL, NULL}
};

/********************************************************************************
 * Command dispatch and global options parsing.
 */

int
main(int argc, char *argv[])
{
    int         ch, i, oargc;
    char        **oargv;
    
    oargc = argc;
    oargv = argv;
    while ((ch = getopt(argc, argv, "")) != -1)
        switch(ch) {
        default:
            return(cmd_help(0, NULL));
        }

    argc -= optind;
    argv += optind;
    
    if (argc > 0)
        for (i = 0; commands[i].cmd != NULL; i++)
            if (!strcmp(argv[0], commands[i].cmd))
                return(commands[i].func(argc, argv));

    return(cmd_help(oargc, oargv));
}

/********************************************************************************
 * Helptext output
 */
static int
cmd_help(int argc, char *argv[]) 
{
    int         i;
    
    if (argc > 1)
        for (i = 0; commands[i].cmd != NULL; i++)
            if (!strcmp(argv[1], commands[i].cmd)) {
                fprintf(stderr, "%s\n", commands[i].text);
                fflush(stderr);
                return(0);
            }

    if (argv != NULL)
        fprintf(stderr, "Unknown command '%s'.\n", argv[1]);    
    fprintf(stderr, "Valid commands are:\n");
    for (i = 0; commands[i].cmd != NULL; i++)
        fprintf(stderr, "  %-20s %s\n", commands[i].cmd, commands[i].desc);
    fflush(stderr);
    return(0);
}

/********************************************************************************
 * Status output
 *
 * status [-qv] [<device> ...]
 *              Prints status for <device>, or all if none listed.
 *
 * -q   Suppresses output, command returns 0 if devices are OK, 1 if one or
 *      more devices are critical, 2 if one or more devices are offline.
 */
static struct mlx_rebuild_status        rs;
static int                              rs_ctrlr = -1;
static int                              status_result = 0;

/* XXX more verbosity! */
static void
status_print(int unit, void *arg)
{
    int                         verbosity = *(int *)arg;
    int                         fd, result, ctrlr, sysdrive, statvalid;
    
    /* Find which controller and what system drive we are */
    statvalid = 0;
    if (mlxd_find_ctrlr(unit, &ctrlr, &sysdrive)) {
        warnx("couldn't get controller/drive for %s", drivepath(unit));
    } else {
        /* If we don't have rebuild stats for this controller, get them */
        if (rs_ctrlr == ctrlr) {
            statvalid = 1;
        } else {
            if ((fd = open(ctrlrpath(ctrlr), 0)) < 0) {
                warn("can't open %s", ctrlrpath(ctrlr));
            } else {
                if (ioctl(fd, MLX_REBUILDSTAT, &rs) < 0) {
                    warn("ioctl MLX_REBUILDSTAT");
                } else {
                    rs_ctrlr = ctrlr;
                    statvalid = 1;
                }
                close(fd);
            }
        }
    }

    /* Get the device */
    if ((fd = open(drivepath(unit), 0)) < 0) {
        warn("can't open %s", drivepath(unit));
        return;
    }

    /* Get its status */
    if (ioctl(fd, MLXD_STATUS, &result) < 0) {
        warn("ioctl MLXD_STATUS");
    } else {
        switch(result) {
        case MLX_SYSD_ONLINE:
            if (verbosity > 0)
                printf("%s: online", drivename(unit));
            break;
        case MLX_SYSD_CRITICAL:
            if (verbosity > 0)
                printf("%s: critical", drivename(unit));
            if (status_result < 1)
                status_result = 1;
            break;
        case MLX_SYSD_OFFLINE:
            if (verbosity > 0)
                printf("%s: offline", drivename(unit));
            if (status_result < 2)
                status_result = 2;
            break;
        default:
            if (verbosity > 0) {
                printf("%s: unknown status 0x%x", drivename(unit), result);
            }
        }
        if (verbosity > 0) {
            /* rebuild/check in progress on this drive? */
            if (statvalid && (rs_ctrlr == ctrlr) && 
                (rs.rs_drive == sysdrive) && (rs.rs_code != MLX_REBUILDSTAT_IDLE)) {
                switch(rs.rs_code) {
                case MLX_REBUILDSTAT_REBUILDCHECK:
                    printf(" [consistency check");
                    break;
                case MLX_REBUILDSTAT_ADDCAPACITY:
                    printf(" [add capacity");
                    break;
                case MLX_REBUILDSTAT_ADDCAPACITYINIT:
                    printf(" [add capacity init");
                    break;
                default:
                    printf(" [unknown operation");
                }
                printf(": %d/%d, %d%% complete]",
                       rs.rs_remaining, rs.rs_size, 
                       ((rs.rs_size - rs.rs_remaining) / (rs.rs_size / 100)));
            }
            printf("\n");
        }
    }
    close(fd);
}

static struct 
{
    int         hwid;
    char        *name;
} mlx_controller_names[] = {
    {0x01,      "960P/PD"},
    {0x02,      "960PL"},
    {0x10,      "960PG"},
    {0x11,      "960PJ"},
    {0x12,      "960PR"},
    {0x13,      "960PT"},
    {0x14,      "960PTL0"},
    {0x15,      "960PRL"},
    {0x16,      "960PTL1"},
    {0x20,      "1100PVX"},
    {-1, NULL}
};

static void
controller_print(int unit, void *arg)
{
    struct mlx_enquiry2 enq;
    struct mlx_phys_drv pd;
    int                 verbosity = *(int *)arg;
    static char         buf[80];
    char                *model;
    int                 i, channel, target;

    if (verbosity == 0)
        return;

    /* fetch and print controller data */
    if (mlx_enquiry(unit, &enq)) {
        printf("mlx%d: error submitting ENQUIRY2\n", unit);
    } else {
        
        for (i = 0, model = NULL; mlx_controller_names[i].name != NULL; i++) {
            if ((enq.me_hardware_id & 0xff) == mlx_controller_names[i].hwid) {
                model = mlx_controller_names[i].name;
                break;
            }
        }
        if (model == NULL) {
            sprintf(buf, " model 0x%x", enq.me_hardware_id & 0xff);
            model = buf;
        }

        printf("mlx%d: DAC%s, %d channel%s, firmware %d.%02d-%c-%02d, %dMB RAM\n",
               unit, model, 
               enq.me_actual_channels, 
               enq.me_actual_channels > 1 ? "s" : "",
               enq.me_firmware_id & 0xff,
               (enq.me_firmware_id >> 8) & 0xff,
               (enq.me_firmware_id >> 16),
               (enq.me_firmware_id >> 24) & 0xff,
               enq.me_mem_size / (1024 * 1024));

        if (verbosity > 1) {
            printf("  Hardware ID                 0x%08x\n", enq.me_hardware_id);
            printf("  Firmware ID                 0x%08x\n", enq.me_firmware_id);
            printf("  Configured/Actual channels  %d/%d\n", enq.me_configured_channels,
                      enq.me_actual_channels);
            printf("  Max Targets                 %d\n", enq.me_max_targets);
            printf("  Max Tags                    %d\n", enq.me_max_tags);
            printf("  Max System Drives           %d\n", enq.me_max_sys_drives);
            printf("  Max Arms                    %d\n", enq.me_max_arms);
            printf("  Max Spans                   %d\n", enq.me_max_spans);
            printf("  DRAM/cache/flash/NVRAM size %d/%d/%d/%d\n", enq.me_mem_size,
                      enq.me_cache_size, enq.me_flash_size, enq.me_nvram_size);
            printf("  DRAM type                   %d\n", enq.me_mem_type);
            printf("  Clock Speed                 %dns\n", enq.me_clock_speed);
            printf("  Hardware Speed              %dns\n", enq.me_hardware_speed);
            printf("  Max Commands                %d\n", enq.me_max_commands);
            printf("  Max SG Entries              %d\n", enq.me_max_sg);
            printf("  Max DP                      %d\n", enq.me_max_dp);
            printf("  Max IOD                     %d\n", enq.me_max_iod);
            printf("  Max Comb                    %d\n", enq.me_max_comb);
            printf("  Latency                     %ds\n", enq.me_latency);
            printf("  SCSI Timeout                %ds\n", enq.me_scsi_timeout);
            printf("  Min Free Lines              %d\n", enq.me_min_freelines);
            printf("  Rate Constant               %d\n", enq.me_rate_const);
            printf("  MAXBLK                      %d\n", enq.me_maxblk);
            printf("  Blocking Factor             %d sectors\n", enq.me_blocking_factor);
            printf("  Cache Line Size             %d blocks\n", enq.me_cacheline);
            printf("  SCSI Capability             %s%dMHz, %d bit\n", 
                      enq.me_scsi_cap & (1<<4) ? "differential " : "",
                      (1 << ((enq.me_scsi_cap >> 2) & 3)) * 10,
                      8 << (enq.me_scsi_cap & 0x3));
            printf("  Firmware Build Number       %d\n", enq.me_firmware_build);
            printf("  Fault Management Type       %d\n", enq.me_fault_mgmt_type);
#if 0
            printf("  Features                    %b\n", enq.me_firmware_features,
                      "\20\4Background Init\3Read Ahead\2MORE\1Cluster\n");
#endif
        }

        /* fetch and print physical drive data */
        for (channel = 0; channel < enq.me_configured_channels; channel++) {
            for (target = 0; target < enq.me_max_targets; target++) {
                if ((mlx_get_device_state(unit, channel, target, &pd) == 0) &&
                    (pd.pd_flags1 & MLX_PHYS_DRV_PRESENT)) {
                    mlx_print_phys_drv(&pd, channel, target, "  ", verbosity - 1);
                    if (verbosity > 1) {
                        /* XXX print device statistics? */
                    }
                }
            }
        }
    }
}

static int
cmd_status(int argc, char *argv[])
{
    int         ch, verbosity = 1, i, unit;

    optreset = 1;
    optind = 1;
    while ((ch = getopt(argc, argv, "qv")) != -1)
        switch(ch) {
        case 'q':
            verbosity = 0;
            break;
        case 'v':
            verbosity = 2;
            break;
        default:
            return(cmd_help(argc, argv));
        }
    argc -= optind;
    argv += optind;

    if (argc < 1) {
        mlx_foreach(controller_print, &verbosity);
        mlxd_foreach(status_print, &verbosity);
    } else {
        for (i = 0; i < argc; i++) {
            if ((unit = driveunit(argv[i])) == -1) {
                warnx("'%s' is not a valid drive", argv[i]);
            } else {
                status_print(unit, &verbosity);
            }
        }
    }
    return(status_result);
}

/********************************************************************************
 * Recscan for system drives on one or more controllers.
 *
 * rescan <controller> [<controller>...]
 * rescan -a
 */
static void
rescan_ctrlr(int unit, void *junk)
{
    int         fd;
    
    /* Get the device */
    if ((fd = open(ctrlrpath(unit), 0)) < 0) {
        warn("can't open %s", ctrlrpath(unit));
        return;
    }

    if (ioctl(fd, MLX_RESCAN_DRIVES) < 0)
        warn("can't rescan %s", ctrlrname(unit));
    close(fd);
}

static int
cmd_rescan(int argc, char *argv[]) 
{
    int         all = 0, i, ch, unit;

    optreset = 1;
    optind = 1;
    while ((ch = getopt(argc, argv, "a")) != -1)
        switch(ch) {
        case 'a':
            all = 1;
            break;
        default:
            return(cmd_help(argc, argv));
        }
    argc -= optind;
    argv += optind;

    if (all) {
        mlx_foreach(rescan_ctrlr, NULL);
    } else {
        for (i = 0; i < argc; i++) {
            if ((unit = ctrlrunit(argv[i])) == -1) {
                warnx("'%s' is not a valid controller", argv[i]);
            } else {
                rescan_ctrlr(unit, NULL);
            }
        }
    }
    return(0);
}

/********************************************************************************
 * Detach one or more system drives from a controller.
 *
 * detach <drive> [<drive>...]
 *              Detach <drive>.
 *
 * detach -a <controller> [<controller>...]
 *              Detach all drives on <controller>.
 *
 */
static void
detach_drive(int unit, void *arg)
{
    int         fd;
    
    /* Get the device */
    if ((fd = open(ctrlrpath(unit), 0)) < 0) {
        warn("can't open %s", ctrlrpath(unit));
        return;
    }

    if (ioctl(fd, MLX_DETACH_DRIVE, &unit) < 0)
        warn("can't detach %s", drivename(unit));
    close(fd);
}

static int
cmd_detach(int argc, char *argv[]) 
{
    struct mlxd_foreach_action  ma;
    int                         all = 0, i, ch, unit;

    optreset = 1;
    optind = 1;
    while ((ch = getopt(argc, argv, "a")) != -1)
        switch(ch) {
        case 'a':
            all = 1;
            break;
        default:
            return(cmd_help(argc, argv));
        }
    argc -= optind;
    argv += optind;

    if (all) {
        ma.func = detach_drive;
        ma.arg = &unit;
        for (i = 0; i < argc; i++) {
            if ((unit = ctrlrunit(argv[i])) == -1) {
                warnx("'%s' is not a valid controller", argv[i]);
            } else {
                mlxd_foreach_ctrlr(unit, &ma);
            }
        }
    } else {
        for (i = 0; i < argc; i++) {
            if ((unit = driveunit(argv[i])) == -1) {
                warnx("'%s' is not a valid drive", argv[i]);
            } else {
                /* run across all controllers to find this drive */
                mlx_foreach(detach_drive, &unit);
            }
        }
    }
    return(0);
}

/********************************************************************************
 * Initiate a consistency check on a system drive.
 *
 * check [<drive>]
 *      Start a check of <drive>
 *
 */
static int
cmd_check(int argc, char *argv[])
{
    int         unit, fd, result;

    if (argc != 2)
        return(cmd_help(argc, argv));

    if ((unit = driveunit(argv[1])) == -1) {
        warnx("'%s' is not a valid drive", argv[1]);
    } else {
        
        /* Get the device */
        if ((fd = open(drivepath(unit), 0)) < 0) {
            warn("can't open %s", drivepath(unit));
        } else {
            /* Try to start the check */
            if ((ioctl(fd, MLXD_CHECKASYNC, &result)) < 0) {
                switch(result) {
                case 0x0002:
                    warnx("one or more of the SCSI disks on which the drive '%s' depends is DEAD", argv[1]);
                    break;
                case 0x0105:
                    warnx("drive %s is invalid, or not a drive which can be checked", argv[1]);
                    break;
                case 0x0106:
                    warnx("drive rebuild or consistency check is already in progress on this controller");
                    break;
                default:
                    warn("ioctl MLXD_CHECKASYNC");
                }
            }
        }
    }
    return(0);
}

/********************************************************************************
 * Initiate a physical drive rebuild
 *
 * rebuild <controller> <channel>:<target>
 *      Start a rebuild of <controller>:<channel>:<target>
 *
 */
static int
cmd_rebuild(int argc, char *argv[])
{
    struct mlx_rebuild_request  rb;
    int                         unit, fd;

    if (argc != 3)
        return(cmd_help(argc, argv));

    /* parse arguments */
    if ((unit = ctrlrunit(argv[1])) == -1) {
        warnx("'%s' is not a valid controller", argv[1]);
        return(1);
    }
    /* try diskXXXX and unknownXXXX as we report the latter for a dead drive ... */
    if ((sscanf(argv[2], "disk%2d%2d", &rb.rr_channel, &rb.rr_target) != 2) &&
        (sscanf(argv[2], "unknown%2d%2d", &rb.rr_channel, &rb.rr_target) != 2)) {       
        warnx("'%s' is not a valid physical drive", argv[2]);
        return(1);
    }
    /* get the device */
    if ((fd = open(ctrlrpath(unit), 0)) < 0) {
        warn("can't open %s", ctrlrpath(unit));
        return(1);
    }
    /* try to start the rebuild */
    if ((ioctl(fd, MLX_REBUILDASYNC, &rb)) < 0) {
        switch(rb.rr_status) {
        case 0x0002:
            warnx("the drive at %d:%d is already ONLINE", rb.rr_channel, rb.rr_target);
            break;
        case 0x0004:
            warnx("drive failed during rebuild");
            break;
        case 0x0105:
            warnx("there is no drive at channel %d, target %d", rb.rr_channel, rb.rr_target);
            break;
        case 0x0106:
            warnx("drive rebuild or consistency check is already in progress on this controller");
            break;
        default:
            warn("ioctl MLXD_REBUILDASYNC");
        }
    }
    return(0);
}

#ifdef SUPPORT_PAUSE
/********************************************************************************
 * Pause one or more channels on a controller
 *
 * pause [-d <delay>] [-t <time>] <controller> [<channel>...]
 *              Pauses <channel> (or all channels) for <time> seconds after a
 *              delay of <delay> seconds.
 * pause <controller> -c
 *              Cancels pending pause
 */
static int
cmd_pause(int argc, char *argv[]) 
{
    struct mlx_pause    mp;
    int                 unit, i, ch, fd, cancel = 0;
    char                *cp;
    int                 oargc = argc;
    char                **oargv = argv;

    mp.mp_which = 0;
    mp.mp_when = 30;
    mp.mp_howlong = 30;
    optreset = 1;
    optind = 1;
    while ((ch = getopt(argc, argv, "cd:t:")) != -1)
        switch(ch) {
        case 'c':
            cancel = 1;
            break;
        case 'd':
            mp.mp_when = strtol(optarg, &cp, 0);
            if (*cp != 0)
                return(cmd_help(argc, argv));
            break;
        case 't':
            mp.mp_howlong = strtol(optarg, &cp, 0);
            if (*cp != 0)
                return(cmd_help(argc, argv));
            break;
        default:
            return(cmd_help(argc, argv));
        }
    argc -= optind;
    argv += optind;

    /* get controller unit number that we're working on */
    if ((argc < 1) || ((unit = ctrlrunit(argv[0])) == -1))
        return(cmd_help(oargc, oargv));

    /* Get the device */
    if ((fd = open(ctrlrpath(unit), 0)) < 0) {
        warn("can't open %s", ctrlrpath(unit));
        return(1);
    }

    if (argc == 1) {
        /* controller-wide pause/cancel */
        mp.mp_which = cancel ? MLX_PAUSE_CANCEL : MLX_PAUSE_ALL;
    } else {
        for (i = 1; i < argc; i++) {
            ch = strtol(argv[i], &cp, 0);
            if (*cp != 0) {
                warnx("bad channel number '%s'", argv[i]);
                continue;
            } else {
                mp.mp_which |= (1 << ch);
            }
        }
    }
    if ((ioctl(fd, MLX_PAUSE_CHANNEL, &mp)) < 0)
        warn("couldn't %s %s", cancel ? "cancel pause on" : "pause", ctrlrname(unit));
    close(fd);
    return(0);
}
#endif  /* SUPPORT_PAUSE */