usr/src/cmd/fs.d/fssnapsup.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2000-2001 by Sun Microsystems, Inc.
  24  * All rights reserved.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * Routines to support fssnap subcommand of switchout.  See switchout.c for
  31  * the real fssnap command.
  32  */
  33
  34 #include <stdio.h>
  35 #include <kstat.h>
  36 #include <libintl.h>
  37 #include <sys/fssnap_if.h>
  38 #include <string.h>
  39 #include <errno.h>
  40
  41 static void fssnap_display_info(ulong_t, int *, int);
  42
  43 #define MAX_INFO_DESCRIPTORS    (10)
  44
  45 static char *infosubopts[] = {
  46 #define INFO_SNAPSHOT           (0)
  47         "snapnumber",
  48 #define INFO_BLKDEV             (1)
  49         "blockdevname",
  50 #define INFO_CHARDEV            (2)
  51         "rawdevname",
  52 #define INFO_MNTPT              (3)
  53         "mountpoint",
  54 #define INFO_STATE              (4)
  55         "state",
  56 #define INFO_BACKPATH           (5)
  57         "backing-store",
  58 #define INFO_BACKSIZE           (6)
  59         "backing-store-len",
  60 #define INFO_MAXSIZE            (7)
  61         "maxsize",
  62 #define INFO_CREATETIME         (8)
  63         "createtime",
  64 #define INFO_CHUNKSIZE          (9)
  65         "chunksize",
  66         NULL
  67 };
  68
  69 #define BLOCK_PATH "/dev/" SNAP_BLOCK_NAME "/"
  70 #define CHAR_PATH  "/dev/" SNAP_CHAR_NAME  "/"
  71
  72 /* labels are truncated to this many characters when displayed */
  73 #define MAX_LABEL_LEN           (30)
  74
  75 /*
  76  * fssnap_show_status() - display file system snapshot status
  77  *
  78  *    displays snapshot information.  If mountpoint is set, information is
  79  *    only displayed for the snapshot (if one exists) on that file system.
  80  *    If mountpoint is NULL, information is displayed for all snapshots.
  81  *
  82  *    If opts is defined, it is parsed as a list of suboptions (via
  83  *    getsubopt()) corresponding to the options list defined above. These
  84  *    options determine what data should be displayed and in what order.  An
  85  *    option may appear more than once.
  86  *
  87  *    The labels parameter is a boolean that determines whether labels
  88  *    (internationalized) are displayed before each data element.  If it is
  89  *    0, labels are not displayed, otherwise they are.  The labels parameter
  90  *    is ignored if brief is nonzero.
  91  *
  92  *    The brief parameter is also a boolean and specifies a mode where only
  93  *    the snapshot number and mount point are displayed, regardless of the
  94  *    value of labels.  This could be used for listing all active snapshots.
  95  *
  96  *    Based on these parameters, an order list is created that tells
  97  *    fssnap_display_info() what info to display and in what order.
  98  *
  99  *    Note that when labels are not specified, the assumption is that the
 100  *    output is made for script readable consumption.  For this reason, text
 101  *    is not I18N'd and numbers are left as bytes instead of converted to KB.
 102  */
 103 void
 104 fssnap_show_status(char *mountpoint, char *opts, int labels, int brief)
 105 {
 106         int *order, orderlen = MAX_INFO_DESCRIPTORS+1;
 107         kstat_ctl_t *kslib;
 108         kstat_t *mnt;
 109         kstat_t *kshigh;
 110         kstat_named_t *highp;
 111         char *suboptions, *v, *n;
 112         int i = 0;
 113         int num, usenum = 0;
 114
 115         kslib = kstat_open();
 116         kshigh = kstat_lookup(kslib, SNAP_NAME, 0, FSSNAP_KSTAT_HIGHWATER);
 117
 118         /*
 119          * First check and see if they gave us a mount point or a device
 120          * name (ie /dev/fssnap/X or /dev/rfssnap/X).
 121          */
 122         if (mountpoint) {
 123                 if (strncmp(BLOCK_PATH, mountpoint, strlen(BLOCK_PATH)) == 0 ||
 124                     strncmp(CHAR_PATH, mountpoint, strlen(CHAR_PATH)) == 0) {
 125                         n = strrchr(mountpoint, '/');
 126                         n++;
 127                         if (isdigit(*n)) {
 128                                 errno = 0;
 129                                 num = (int)strtol(n, NULL, 10);
 130                                 if (errno == 0) {
 131                                         usenum++;
 132                                 }
 133                         }
 134                 }
 135         }
 136
 137         if (opts) {
 138                 i = 0;
 139                 order = (int *)malloc(orderlen * sizeof (int));
 140                 if (order == NULL) {
 141                         fprintf(stderr,
 142                             gettext("cannot allocate order list.\n"));
 143                         return;
 144                 }
 145                 suboptions = opts;
 146                 while (*suboptions != '\0') {
 147                         /*
 148                          * -1 means invalid option, MAX_INFO_DESCRIPTORS is
 149                          * the end.
 150                          */
 151                         order[i++] = getsubopt(&suboptions, infosubopts, &v);
 152                         if (i >= orderlen) {
 153                                 order = (int *)realloc(order,
 154                                     sizeof (int) * (orderlen *= 2));
 155                                 if (order == NULL) {
 156                                         fprintf(stderr,
 157                                             gettext("cannot reallocate order "
 158                                             "list.\n"));
 159                                         return;
 160                                 }
 161                         }
 162
 163                 }
 164                 order[i] = MAX_INFO_DESCRIPTORS;
 165         } else {
 166                 order = (int *)malloc(orderlen * sizeof (int));
 167                 if (order == NULL) {
 168                         fprintf(stderr,
 169                             gettext("cannot allocate order list.\n"));
 170                         return;
 171                 }
 172                 for (i = 0; i <= MAX_INFO_DESCRIPTORS; i++)
 173                         order[i] = i;
 174         }
 175
 176         /* check if fssnap module is loaded */
 177         if (kshigh == NULL) {
 178                 kstat_close(kslib);
 179                 return;
 180         }
 181
 182         (void) kstat_read(kslib, kshigh, NULL);
 183         highp = kstat_data_lookup(kshigh, FSSNAP_KSTAT_HIGHWATER);
 184
 185         /* Loop up to the maximum number of snapshots */
 186         for (i = 0; i <= highp->value.ui32; i++) {
 187                 mnt = kstat_lookup(kslib, SNAP_NAME, i, FSSNAP_KSTAT_MNTPT);
 188
 189                 /* if this snapshot is not allocated, skip to the next */
 190                 if (mnt == NULL)
 191                         continue;
 192                 if (kstat_read(kslib, mnt, NULL) == -1)
 193                         continue;
 194                 if (mountpoint != NULL) {
 195                         if ((usenum && i != num) ||
 196                             (!usenum && strcmp(mountpoint, mnt->ks_data) != 0))
 197                                 continue;
 198                 }
 199
 200                 if (brief)
 201                         printf("%4d\t%s\n", i, (char *)mnt->ks_data);
 202                 else
 203                         fssnap_display_info(i, order, labels);
 204         }
 205 }
 206
 207 static void
 208 fssnap_display_info(ulong_t snapnum, int *order, int labels)
 209 {
 210         kstat_ctl_t *kslib;
 211         kstat_t *back, *num;
 212         kstat_named_t *numvalp;
 213         kstat_t *mnt;
 214         u_longlong_t inuse, size = 0;
 215         char buf[BUFSIZ], *first;
 216         int i;
 217
 218         /* load num kstat */
 219         kslib = kstat_open();
 220         num = kstat_lookup(kslib, SNAP_NAME, snapnum, FSSNAP_KSTAT_NUM);
 221         if (num == NULL)
 222                 return;
 223
 224         if (kstat_read(kslib, num, NULL) == -1)
 225                 return;
 226
 227         for (i = 0; order[i] != MAX_INFO_DESCRIPTORS; i++) {
 228                 switch (order[i]) {
 229                 case    INFO_SNAPSHOT:
 230                         if (labels)
 231                                 printf("%-*s: %lu\n", MAX_LABEL_LEN,
 232                                     gettext("Snapshot number"), snapnum);
 233                         else
 234                                 printf("%lu\n", snapnum);
 235                         break;
 236                 case    INFO_BLKDEV:
 237                         if (labels)
 238                                 printf("%-*s: /dev/%s/%lu\n", MAX_LABEL_LEN,
 239                                     gettext("Block Device"), SNAP_BLOCK_NAME,
 240                                     snapnum);
 241                         else
 242                                 printf("/dev/%s/%lu\n", SNAP_BLOCK_NAME,
 243                                     snapnum);
 244                         break;
 245                 case    INFO_CHARDEV:
 246                         if (labels)
 247                                 printf("%-*s: /dev/%s/%lu\n", MAX_LABEL_LEN,
 248                                     gettext("Raw Device"), SNAP_CHAR_NAME,
 249                                     snapnum);
 250                         else
 251                                 printf("/dev/%s/%lu\n", SNAP_CHAR_NAME,
 252                                     snapnum);
 253                         break;
 254
 255                 case    INFO_MNTPT:
 256                         mnt = kstat_lookup(kslib, SNAP_NAME, snapnum,
 257                             FSSNAP_KSTAT_MNTPT);
 258                         if (mnt == NULL) {
 259                                 fprintf(stderr,
 260                                     gettext("cannot read mount point kstat\n"));
 261                                 continue;
 262                         }
 263                         if (kstat_read(kslib, mnt, NULL) == -1) {
 264                                 continue;
 265                         }
 266                         if (labels)
 267                                 printf("%-*s: %s\n", MAX_LABEL_LEN,
 268                                     gettext("Mount point"),
 269                                     (char *)mnt->ks_data);
 270                         else
 271                                 printf("%s\n", (char *)mnt->ks_data);
 272                         break;
 273                 case    INFO_STATE:
 274                         /* state */
 275                         numvalp = kstat_data_lookup(num,
 276                             FSSNAP_KSTAT_NUM_STATE);
 277                         if (numvalp == NULL) {
 278                                 fprintf(stderr,
 279                                     gettext("cannot read state kstat\n"));
 280                                 continue;
 281                         }
 282
 283                         if (labels) {
 284                                 printf("%-*s: ", MAX_LABEL_LEN,
 285                                     gettext("Device state"));
 286                                 switch (numvalp->value.i32) {
 287                                 case 0: printf(gettext("creating\n"));
 288                                         break;
 289                                 case 1: printf(gettext("idle\n"));
 290                                         break;
 291                                 case 2: printf(gettext("active\n"));
 292                                         break;
 293                                 case 3: printf(gettext("disabled\n"));
 294                                         break;
 295                                 default: printf(gettext("unknown\n"));
 296                                         break;
 297                                 }
 298                         } else {
 299                                 switch (numvalp->value.i32) {
 300                                 case 0: printf("creating\n");
 301                                         break;
 302                                 case 1: printf("idle\n");
 303                                         break;
 304                                 case 2: printf("active\n");
 305                                         break;
 306                                 case 3: printf("disabled\n");
 307                                         break;
 308                                 default: printf("unknown\n");
 309                                         break;
 310                                 }
 311                         }
 312                         break;
 313
 314                 case    INFO_BACKPATH:
 315                         /* backing file kstat */
 316                         back = kstat_lookup(kslib, SNAP_NAME, snapnum,
 317                             FSSNAP_KSTAT_BFNAME);
 318                         if (back == NULL ||
 319                             (kstat_read(kslib, back, NULL) == -1) ||
 320                             (back->ks_data == NULL)) {
 321                                 fprintf(stderr,
 322                                     gettext("cannot read backing file name "
 323                                     "kstat from kernel\n"));
 324                                 continue;
 325                         }
 326                         if (labels)
 327                                 printf("%-*s: %s\n", MAX_LABEL_LEN,
 328                                     gettext("Backing store path"),
 329                                     (char *)back->ks_data);
 330                         else
 331                                 printf("%s\n", (char *)back->ks_data);
 332                         break;
 333
 334                 case    INFO_BACKSIZE:
 335                         numvalp = kstat_data_lookup(num,
 336                             FSSNAP_KSTAT_NUM_BFSIZE);
 337                         if (numvalp == NULL) {
 338                                 fprintf(stderr,
 339                                     gettext("cannot read backing file size "
 340                                     "kstat from kernel\n"));
 341                                 continue;
 342                         }
 343
 344                         size = numvalp->value.ui64;
 345
 346                         if (labels)
 347                                 printf("%-*s: %llu KB\n", MAX_LABEL_LEN,
 348                                     gettext("Backing store size"),
 349                                     size / 1024LL);
 350                         else
 351                                 printf("%llu\n", size);
 352                         break;
 353
 354                 case    INFO_MAXSIZE:
 355                         numvalp = kstat_data_lookup(num,
 356                             FSSNAP_KSTAT_NUM_MAXSIZE);
 357                         if (numvalp == NULL) {
 358                                 fprintf(stderr,
 359                                     gettext("cannot read backing file maxsize "
 360                                     "kstat from kernel\n"));
 361                                 continue;
 362                         }
 363                         if (labels) {
 364                                 printf("%-*s: ", MAX_LABEL_LEN,
 365                                     gettext("Maximum backing store size"));
 366
 367                                 if (numvalp->value.ui64 == 0LL)
 368                                         printf(gettext("Unlimited\n"));
 369                                 else
 370                                         printf("%llu KB\n",
 371                                             numvalp->value.ui64 / 1024LL);
 372                         } else {
 373                                 printf("%llu\n", numvalp->value.ui64);
 374                         }
 375                         break;
 376
 377                 case    INFO_CREATETIME:
 378                 {
 379                         /* snapshot creation time */
 380                         char buf[256];
 381                         struct tm *tm;
 382                         char *p;
 383
 384                         numvalp = kstat_data_lookup(num,
 385                             FSSNAP_KSTAT_NUM_CREATETIME);
 386                         if (numvalp == NULL) {
 387                                 fprintf(stderr,
 388                                     gettext("cannot read snapshot create time "
 389                                     "kstat from kernel\n"));
 390                                 continue;
 391                         }
 392
 393                         if (labels) {
 394                                 printf("%-*s: ", MAX_LABEL_LEN,
 395                                     gettext("Snapshot create time"));
 396
 397                                 /* get the localized time */
 398                                 tm = localtime(&numvalp->value.l);
 399                                 if (strftime(buf, sizeof (buf),
 400                                     "%c\n", tm) == 0)
 401                                         /* Wouldn't fit in buf, fall back */
 402                                         p = ctime(&numvalp->value.l);
 403                                 else
 404                                         p = buf;
 405                         } else {
 406                                 /*
 407                                  * for script-readable options we want
 408                                  * the locale-independent time only.
 409                                  */
 410                                 p = ctime(&numvalp->value.l);
 411                         }
 412                         /* p should already have a \n appended */
 413                         printf("%s", p);
 414                         break;
 415                 }
 416
 417                 case    INFO_CHUNKSIZE:
 418                         numvalp = kstat_data_lookup(num,
 419                             FSSNAP_KSTAT_NUM_CHUNKSIZE);
 420                         if (numvalp == NULL) {
 421                                 fprintf(stderr,
 422                                     gettext("cannot read chunksize kstat\n"));
 423                                 continue;
 424                         }
 425                         if (labels)
 426                                 printf("%-*s: %lu KB\n", MAX_LABEL_LEN,
 427                                     gettext("Copy-on-write granularity"),
 428                                     numvalp->value.ui32 / 1024L);
 429                         else
 430                                 printf("%lu\n", numvalp->value.ui32);
 431                         break;
 432
 433                 case    -1:
 434                         /*
 435                          * Print a place holder for unknown options so that
 436                          * the user can determine which option was not
 437                          * understood and the number outputted is the same
 438                          * number they requested.
 439                          */
 440                         printf("?\n");
 441                         break;
 442
 443                 default:
 444                         printf(gettext("No such data type %d.\n"), order[i]);
 445                         break;
 446                 }
 447         }
 448 }