/*
 * Copyright (c) 2016 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * 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.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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 "nvmectl.h"

typedef int (*cmd_t)(int ac, char **av, const char *id, int fd);

static cmd_t parsecmd(int ac, char **av, int *globokp);
static int cmd_info(int ac, char **av, const char *id, int fd);
static int cmd_errors(int ac, char **av, const char *id, int fd);
static void usage(int rc);

int VerboseOpt;

int
main(int ac, char **av)
{
        int rc = 0;
        int ch;
        int nvmei;
        int globok;
        int i;
        cmd_t cmd;

        while ((ch = getopt(ac, av, "v")) != -1) {
                switch(ch) {
                case 'v':
                        ++VerboseOpt;
                        break;
                default:
                        usage(1);
                        break;
                }
        }

        ac -= optind;
        av += optind;

        for (nvmei = ac; nvmei > 0; --nvmei) {
                if (strncmp(av[nvmei - 1], "nvme", 4) != 0)
                        break;
        }
        if (nvmei == 0)
                usage(1);

        globok = 0;
        cmd = parsecmd(nvmei, av, &globok);

        if (nvmei == ac && globok) {
                i = 0;
                for (;;) {
                        char *path;
                        int fd;

                        if (i)
                                printf("\n");
                        asprintf(&path, "/dev/nvme%d", i);
                        fd = open(path, O_RDWR);
                        free(path);
                        if (fd < 0)
                                break;
                        rc += cmd(nvmei, av, path + 5, fd);
                        close(fd);
                        ++i;
                }
        } else if (nvmei == ac && !globok) {
                fprintf(stderr, "must specify nvmeX device for command\n");
        } else {
                for (i = nvmei; i < ac; ++i) {
                        char *path;
                        int fd;

                        if (i != nvmei)
                                printf("\n");

                        asprintf(&path, "/dev/%s", av[i]);
                        fd = open(path, O_RDWR);
                        if (fd < 0) {
                                fprintf(stderr, "open \"%s\": %s\n",
                                        path,
                                        strerror(errno));
                        } else {
                                rc += cmd(nvmei, av, path + 5, fd);
                                close(fd);
                        }
                        free(path);
                }
        }
        return (rc ? 1 : 0);
}

static
cmd_t
parsecmd(int ac, char **av, int *globokp)
{
        if (ac == 0)
                usage(1);
        if (strcmp(av[0], "info") == 0) {
                *globokp = 1;
                return cmd_info;
        }
        if (strcmp(av[0], "errors") == 0) {
                *globokp = 1;
                return cmd_errors;
        }
        fprintf(stderr, "Command %s not recognized\n", av[0]);

        usage(1);
        return NULL;    /* NOT REACHED */
}

static
int
cmd_info(int ac __unused, char **av __unused, const char *id, int fd)
{
        nvme_getlog_ioctl_t ioc;
        nvme_log_smart_data_t *smart;
        int count;
        int i;

        bzero(&ioc, sizeof(ioc));
        ioc.lid = NVME_LID_SMART;
        ioc.ret_size = sizeof(ioc.info.logsmart);

        if (ioctl(fd, NVMEIOCGETLOG, &ioc) < 0) {
                fprintf(stderr, "ioctl failed: %s\n", strerror(errno));
                return 1;
        }
        if (NVME_COMQ_STATUS_CODE_GET(ioc.status)) {
                fprintf(stderr, "%s: type %d code 0x%02x\n",
                        id,
                        NVME_COMQ_STATUS_TYPE_GET(ioc.status),
                        NVME_COMQ_STATUS_CODE_GET(ioc.status));
                return 1;
        }
        printf("%s:\n", id);
        smart = &ioc.info.logsmart;

        printf("\tcrit_flags:\t");
        if (smart->crit_flags) {
                if (smart->crit_flags & NVME_SMART_CRF_RES80)
                        printf(" 80");
                if (smart->crit_flags & NVME_SMART_CRF_RES40)
                        printf(" 40");
                if (smart->crit_flags & NVME_SMART_CRF_RES20)
                        printf(" 20");
                if (smart->crit_flags & NVME_SMART_CRF_VOLTL_BKUP_FAIL)
                        printf(" MEM_BACKUP_FAILED");
                if (smart->crit_flags & NVME_SMART_CRF_MEDIA_RO)
                        printf(" MEDIA_RDONLY");
                if (smart->crit_flags & NVME_SMART_CRF_UNRELIABLE)
                        printf(" MEDIA_UNRELIABLE");
                if (smart->crit_flags & NVME_SMART_CRF_ABOVE_THRESH)
                        printf(" TOO_HOT");
                if (smart->crit_flags & NVME_SMART_CRF_BELOW_THRESH)
                        printf(" TOO_COLD");
        } else {
                printf("none\n");
        }
        printf("\tcomp_temp:\t%dC\n",
                (int)(smart->comp_temp1 + (smart->comp_temp2 << 8)) - 273);
        printf("\tLIFE_LEFT:\t%d%% (%d%% used)\n",
                100 - (int)smart->rated_life,
                (int)smart->rated_life);

        printf("\tread_bytes:\t%s\n",
               format_number(smart->read_count[0] * 512000));
        printf("\twrite_bytes:\t%s\n",
               format_number(smart->write_count[0] * 512000));
        printf("\tread_cmds:\t%s\n",
               format_number(smart->read_cmds[0]));
        printf("\twrite_cmds:\t%s\n",
               format_number(smart->write_cmds[0]));
        printf("\tbusy_time:\t%ld min (%1.2f hrs)\n",
                smart->busy_time[0],
                (double)smart->busy_time[0] / 60.0);
        printf("\tpowon_hours:\t%ld\n", smart->powon_hours[0]);
        printf("\tpower_cyc:\t%ld\n", smart->power_cycles[0]);
        printf("\tunsafe_shut:\t%ld\n", smart->unsafe_shutdowns[0]);

        printf("\tUNRECOV_ERR:\t%ld", smart->unrecoverable_errors[0]);
        if (smart->unrecoverable_errors[0])
                printf("\t*******WARNING*******");
        printf("\n");

        printf("\terr_log_ent:\t%ld\n", smart->error_log_entries[0]);
        printf("\twarn_temp_time:\t%d min (%1.2f hrs)\n",
                smart->warn_comp_temp_time,
                (double)smart->warn_comp_temp_time / 60.0);
        printf("\tcrit_temp_time:\t%d min (%1.2f hrs)\n",
                smart->crit_comp_temp_time,
                (double)smart->crit_comp_temp_time / 60.0);

        printf("\ttemp_sensors:\t");
        for (i = count = 0; i < 8; ++i) {
                if (smart->temp_sensors[i]) {
                        if (count)
                                printf(" ");
                        printf("%dC", smart->temp_sensors[i] - 273);
                        ++count;
                }
        }
        if (count == 0)
                printf("none");
        printf("\n");

        return 0;
}

static
int
cmd_errors(int ac __unused, char **av __unused, const char *id, int fd)
{
        nvme_getlog_ioctl_t ioc;
        nvme_log_error_data_t *errs;
        int i;

        bzero(&ioc, sizeof(ioc));
        ioc.lid = NVME_LID_ERROR;
        ioc.ret_size = sizeof(ioc.info.logsmart);

        if (ioctl(fd, NVMEIOCGETLOG, &ioc) < 0) {
                fprintf(stderr, "ioctl failed: %s\n", strerror(errno));
                return 1;
        }
        if (NVME_COMQ_STATUS_CODE_GET(ioc.status)) {
                fprintf(stderr, "%s: type %d code 0x%02x\n",
                        id,
                        NVME_COMQ_STATUS_TYPE_GET(ioc.status),
                        NVME_COMQ_STATUS_CODE_GET(ioc.status));
                return 1;
        }
        printf("%s:\n", id);
        errs = &ioc.info.logerr[0];

        for (i = 0; i < 64; ++i) {
                if (errs->error_count == 0 && errs->subq_id == 0 &&
                    errs->cmd_id == 0 && errs->status == 0 &&
                    errs->param == 0 && errs->nsid == 0 &&
                    errs->vendor == 0 && errs->csi == 0 && errs->lba == 0)
                        continue;

                if (errs->param || errs->vendor || errs->csi) {
                        printf("\t%2d cnt=%-3ld subq=%-2d cmdi=%-3d "
                               "status=%d,0x%02x parm=%04x nsid=%-3d vend=%d "
                               "csi=0x%lx lba=%ld",
                               i, errs->error_count,
                               (int16_t)errs->subq_id,
                               (int16_t)errs->cmd_id,
                               NVME_COMQ_STATUS_TYPE_GET(errs->status),
                               NVME_COMQ_STATUS_CODE_GET(errs->status),
                               errs->param, errs->nsid,
                               errs->vendor,
                               errs->csi, errs->lba);
                } else {
                        printf("\t%2d cnt=%-3ld subq=%-2d cmdi=%-3d "
                               "status=%d,0x%02x nsid=%-3d lba=%ld",
                               i, errs->error_count,
                               (int16_t)errs->subq_id,
                               (int16_t)errs->cmd_id,
                               NVME_COMQ_STATUS_TYPE_GET(errs->status),
                               NVME_COMQ_STATUS_CODE_GET(errs->status),
                               errs->nsid,
                               errs->lba);
                }
                if (errs->status & NVME_COMQ_STATUS_DNR)
                        printf(" DNR");
                printf(" %s\n", status_to_str(errs->status));
                ++errs;
        }

        return 0;
}

static
void
usage(int rc)
{
        fprintf(stderr,
                "nvmectl [-v] cmd [nvme0,1,2...]\n"
                "\tinfo\n"
                "\terrors\n"
        );
        exit(rc);
}