/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2000-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*
 * Routines to support fssnap subcommand of switchout.  See switchout.c for
 * the real fssnap command.
 */

#include <stdio.h>
#include <kstat.h>
#include <libintl.h>
#include <sys/fssnap_if.h>
#include <string.h>
#include <errno.h>

static void fssnap_display_info(ulong_t, int *, int);

#define MAX_INFO_DESCRIPTORS    (10)

static char *infosubopts[] = {
#define INFO_SNAPSHOT           (0)
        "snapnumber",
#define INFO_BLKDEV             (1)
        "blockdevname",
#define INFO_CHARDEV            (2)
        "rawdevname",
#define INFO_MNTPT              (3)
        "mountpoint",
#define INFO_STATE              (4)
        "state",
#define INFO_BACKPATH           (5)
        "backing-store",
#define INFO_BACKSIZE           (6)
        "backing-store-len",
#define INFO_MAXSIZE            (7)
        "maxsize",
#define INFO_CREATETIME         (8)
        "createtime",
#define INFO_CHUNKSIZE          (9)
        "chunksize",
        NULL
};

#define BLOCK_PATH "/dev/" SNAP_BLOCK_NAME "/"
#define CHAR_PATH  "/dev/" SNAP_CHAR_NAME  "/"

/* labels are truncated to this many characters when displayed */
#define MAX_LABEL_LEN           (30)

/*
 * fssnap_show_status() - display file system snapshot status
 *
 *    displays snapshot information.  If mountpoint is set, information is
 *    only displayed for the snapshot (if one exists) on that file system.
 *    If mountpoint is NULL, information is displayed for all snapshots.
 *
 *    If opts is defined, it is parsed as a list of suboptions (via
 *    getsubopt()) corresponding to the options list defined above. These
 *    options determine what data should be displayed and in what order.  An
 *    option may appear more than once.
 *
 *    The labels parameter is a boolean that determines whether labels
 *    (internationalized) are displayed before each data element.  If it is
 *    0, labels are not displayed, otherwise they are.  The labels parameter
 *    is ignored if brief is nonzero.
 *
 *    The brief parameter is also a boolean and specifies a mode where only
 *    the snapshot number and mount point are displayed, regardless of the
 *    value of labels.  This could be used for listing all active snapshots.
 *
 *    Based on these parameters, an order list is created that tells
 *    fssnap_display_info() what info to display and in what order.
 *
 *    Note that when labels are not specified, the assumption is that the
 *    output is made for script readable consumption.  For this reason, text
 *    is not I18N'd and numbers are left as bytes instead of converted to KB.
 */
void
fssnap_show_status(char *mountpoint, char *opts, int labels, int brief)
{
        int *order, orderlen = MAX_INFO_DESCRIPTORS+1;
        kstat_ctl_t *kslib;
        kstat_t *mnt;
        kstat_t *kshigh;
        kstat_named_t *highp;
        char *suboptions, *v, *n;
        int i = 0;
        int num, usenum = 0;

        kslib = kstat_open();
        kshigh = kstat_lookup(kslib, SNAP_NAME, 0, FSSNAP_KSTAT_HIGHWATER);

        /*
         * First check and see if they gave us a mount point or a device
         * name (ie /dev/fssnap/X or /dev/rfssnap/X).
         */
        if (mountpoint) {
                if (strncmp(BLOCK_PATH, mountpoint, strlen(BLOCK_PATH)) == 0 ||
                    strncmp(CHAR_PATH, mountpoint, strlen(CHAR_PATH)) == 0) {
                        n = strrchr(mountpoint, '/');
                        n++;
                        if (isdigit(*n)) {
                                errno = 0;
                                num = (int)strtol(n, NULL, 10);
                                if (errno == 0) {
                                        usenum++;
                                }
                        }
                }
        }

        if (opts) {
                i = 0;
                order = (int *)malloc(orderlen * sizeof (int));
                if (order == NULL) {
                        fprintf(stderr,
                            gettext("cannot allocate order list.\n"));
                        return;
                }
                suboptions = opts;
                while (*suboptions != '\0') {
                        /*
                         * -1 means invalid option, MAX_INFO_DESCRIPTORS is
                         * the end.
                         */
                        order[i++] = getsubopt(&suboptions, infosubopts, &v);
                        if (i >= orderlen) {
                                order = (int *)realloc(order,
                                    sizeof (int) * (orderlen *= 2));
                                if (order == NULL) {
                                        fprintf(stderr,
                                            gettext("cannot reallocate order "
                                            "list.\n"));
                                        return;
                                }
                        }

                }
                order[i] = MAX_INFO_DESCRIPTORS;
        } else {
                order = (int *)malloc(orderlen * sizeof (int));
                if (order == NULL) {
                        fprintf(stderr,
                            gettext("cannot allocate order list.\n"));
                        return;
                }
                for (i = 0; i <= MAX_INFO_DESCRIPTORS; i++)
                        order[i] = i;
        }

        /* check if fssnap module is loaded */
        if (kshigh == NULL) {
                kstat_close(kslib);
                return;
        }

        (void) kstat_read(kslib, kshigh, NULL);
        highp = kstat_data_lookup(kshigh, FSSNAP_KSTAT_HIGHWATER);

        /* Loop up to the maximum number of snapshots */
        for (i = 0; i <= highp->value.ui32; i++) {
                mnt = kstat_lookup(kslib, SNAP_NAME, i, FSSNAP_KSTAT_MNTPT);

                /* if this snapshot is not allocated, skip to the next */
                if (mnt == NULL)
                        continue;
                if (kstat_read(kslib, mnt, NULL) == -1)
                        continue;
                if (mountpoint != NULL) {
                        if ((usenum && i != num) ||
                            (!usenum && strcmp(mountpoint, mnt->ks_data) != 0))
                                continue;
                }

                if (brief)
                        printf("%4d\t%s\n", i, (char *)mnt->ks_data);
                else
                        fssnap_display_info(i, order, labels);
        }
}

static void
fssnap_display_info(ulong_t snapnum, int *order, int labels)
{
        kstat_ctl_t *kslib;
        kstat_t *back, *num;
        kstat_named_t *numvalp;
        kstat_t *mnt;
        u_longlong_t inuse, size = 0;
        char buf[BUFSIZ], *first;
        int i;

        /* load num kstat */
        kslib = kstat_open();
        num = kstat_lookup(kslib, SNAP_NAME, snapnum, FSSNAP_KSTAT_NUM);
        if (num == NULL)
                return;

        if (kstat_read(kslib, num, NULL) == -1)
                return;

        for (i = 0; order[i] != MAX_INFO_DESCRIPTORS; i++) {
                switch (order[i]) {
                case    INFO_SNAPSHOT:
                        if (labels)
                                printf("%-*s: %lu\n", MAX_LABEL_LEN,
                                    gettext("Snapshot number"), snapnum);
                        else
                                printf("%lu\n", snapnum);
                        break;
                case    INFO_BLKDEV:
                        if (labels)
                                printf("%-*s: /dev/%s/%lu\n", MAX_LABEL_LEN,
                                    gettext("Block Device"), SNAP_BLOCK_NAME,
                                    snapnum);
                        else
                                printf("/dev/%s/%lu\n", SNAP_BLOCK_NAME,
                                    snapnum);
                        break;
                case    INFO_CHARDEV:
                        if (labels)
                                printf("%-*s: /dev/%s/%lu\n", MAX_LABEL_LEN,
                                    gettext("Raw Device"), SNAP_CHAR_NAME,
                                    snapnum);
                        else
                                printf("/dev/%s/%lu\n", SNAP_CHAR_NAME,
                                    snapnum);
                        break;

                case    INFO_MNTPT:
                        mnt = kstat_lookup(kslib, SNAP_NAME, snapnum,
                            FSSNAP_KSTAT_MNTPT);
                        if (mnt == NULL) {
                                fprintf(stderr,
                                    gettext("cannot read mount point kstat\n"));
                                continue;
                        }
                        if (kstat_read(kslib, mnt, NULL) == -1) {
                                continue;
                        }
                        if (labels)
                                printf("%-*s: %s\n", MAX_LABEL_LEN,
                                    gettext("Mount point"),
                                    (char *)mnt->ks_data);
                        else
                                printf("%s\n", (char *)mnt->ks_data);
                        break;
                case    INFO_STATE:
                        /* state */
                        numvalp = kstat_data_lookup(num,
                            FSSNAP_KSTAT_NUM_STATE);
                        if (numvalp == NULL) {
                                fprintf(stderr,
                                    gettext("cannot read state kstat\n"));
                                continue;
                        }

                        if (labels) {
                                printf("%-*s: ", MAX_LABEL_LEN,
                                    gettext("Device state"));
                                switch (numvalp->value.i32) {
                                case 0: printf(gettext("creating\n"));
                                        break;
                                case 1: printf(gettext("idle\n"));
                                        break;
                                case 2: printf(gettext("active\n"));
                                        break;
                                case 3: printf(gettext("disabled\n"));
                                        break;
                                default: printf(gettext("unknown\n"));
                                        break;
                                }
                        } else {
                                switch (numvalp->value.i32) {
                                case 0: printf("creating\n");
                                        break;
                                case 1: printf("idle\n");
                                        break;
                                case 2: printf("active\n");
                                        break;
                                case 3: printf("disabled\n");
                                        break;
                                default: printf("unknown\n");
                                        break;
                                }
                        }
                        break;

                case    INFO_BACKPATH:
                        /* backing file kstat */
                        back = kstat_lookup(kslib, SNAP_NAME, snapnum,
                            FSSNAP_KSTAT_BFNAME);
                        if (back == NULL ||
                            (kstat_read(kslib, back, NULL) == -1) ||
                            (back->ks_data == NULL)) {
                                fprintf(stderr,
                                    gettext("cannot read backing file name "
                                    "kstat from kernel\n"));
                                continue;
                        }
                        if (labels)
                                printf("%-*s: %s\n", MAX_LABEL_LEN,
                                    gettext("Backing store path"),
                                    (char *)back->ks_data);
                        else
                                printf("%s\n", (char *)back->ks_data);
                        break;

                case    INFO_BACKSIZE:
                        numvalp = kstat_data_lookup(num,
                            FSSNAP_KSTAT_NUM_BFSIZE);
                        if (numvalp == NULL) {
                                fprintf(stderr,
                                    gettext("cannot read backing file size "
                                    "kstat from kernel\n"));
                                continue;
                        }

                        size = numvalp->value.ui64;

                        if (labels)
                                printf("%-*s: %llu KB\n", MAX_LABEL_LEN,
                                    gettext("Backing store size"),
                                    size / 1024LL);
                        else
                                printf("%llu\n", size);
                        break;

                case    INFO_MAXSIZE:
                        numvalp = kstat_data_lookup(num,
                            FSSNAP_KSTAT_NUM_MAXSIZE);
                        if (numvalp == NULL) {
                                fprintf(stderr,
                                    gettext("cannot read backing file maxsize "
                                    "kstat from kernel\n"));
                                continue;
                        }
                        if (labels) {
                                printf("%-*s: ", MAX_LABEL_LEN,
                                    gettext("Maximum backing store size"));

                                if (numvalp->value.ui64 == 0LL)
                                        printf(gettext("Unlimited\n"));
                                else
                                        printf("%llu KB\n",
                                            numvalp->value.ui64 / 1024LL);
                        } else {
                                printf("%llu\n", numvalp->value.ui64);
                        }
                        break;

                case    INFO_CREATETIME:
                {
                        /* snapshot creation time */
                        char buf[256];
                        struct tm *tm;
                        char *p;

                        numvalp = kstat_data_lookup(num,
                            FSSNAP_KSTAT_NUM_CREATETIME);
                        if (numvalp == NULL) {
                                fprintf(stderr,
                                    gettext("cannot read snapshot create time "
                                    "kstat from kernel\n"));
                                continue;
                        }

                        if (labels) {
                                printf("%-*s: ", MAX_LABEL_LEN,
                                    gettext("Snapshot create time"));

                                /* get the localized time */
                                tm = localtime(&numvalp->value.l);
                                if (strftime(buf, sizeof (buf),
                                    "%c\n", tm) == 0)
                                        /* Wouldn't fit in buf, fall back */
                                        p = ctime(&numvalp->value.l);
                                else
                                        p = buf;
                        } else {
                                /*
                                 * for script-readable options we want
                                 * the locale-independent time only.
                                 */
                                p = ctime(&numvalp->value.l);
                        }
                        /* p should already have a \n appended */
                        printf("%s", p);
                        break;
                }

                case    INFO_CHUNKSIZE:
                        numvalp = kstat_data_lookup(num,
                            FSSNAP_KSTAT_NUM_CHUNKSIZE);
                        if (numvalp == NULL) {
                                fprintf(stderr,
                                    gettext("cannot read chunksize kstat\n"));
                                continue;
                        }
                        if (labels)
                                printf("%-*s: %lu KB\n", MAX_LABEL_LEN,
                                    gettext("Copy-on-write granularity"),
                                    numvalp->value.ui32 / 1024L);
                        else
                                printf("%lu\n", numvalp->value.ui32);
                        break;

                case    -1:
                        /*
                         * Print a place holder for unknown options so that
                         * the user can determine which option was not
                         * understood and the number outputted is the same
                         * number they requested.
                         */
                        printf("?\n");
                        break;

                default:
                        printf(gettext("No such data type %d.\n"), order[i]);
                        break;
                }
        }
}