usr/src/cmd/fs.d/switchout.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 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  23 /*        All Rights Reserved   */
  24
  25
  26 /*
  27  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"
  32
  33 #include        <stdio.h>
  34 #include        <limits.h>
  35 #include        <locale.h>
  36 #include        <libintl.h>
  37 #include        <sys/fstyp.h>
  38 #include        <errno.h>
  39 #include        <sys/vfstab.h>
  40 #include        <sys/types.h>
  41 #include        <sys/stat.h>
  42 #include        <fcntl.h>
  43 #include        <string.h>
  44 #include        <libdiskmgt.h>
  45 #include        "fslib.h"
  46
  47
  48 static int match(char **opts, char *s);
  49 static int has_Nflag(char *opts);
  50
  51 #define FSTYPE_MAX      8
  52 #define ARGV_MAX        1024
  53 #define VFS_PATH        "/usr/lib/fs"
  54 #define ALT_PATH        "/etc/fs"
  55
  56 extern char     *default_fstype();
  57 void    stat_snap(char *, char *, char *);
  58 char    *special = NULL;  /*  device special name  */
  59 char    *fstype = NULL;   /*  fstype name is filled in here  */
  60 char    *cbasename;       /* name of command */
  61 char    *newargv[ARGV_MAX];     /* args for the fstype specific command  */
  62 char    vfstab[] = VFSTAB;
  63 int     newargc = 2;
  64
  65 /*
  66  * TRANSLATION_NOTE - the usage strings in the c_usgstr[] of the
  67  * following structures should be given a translation; the call to gettext
  68  * is in the usage() function. The strings are the ones containing
  69  * "[-F FSType]".
  70  */
  71
  72 struct commands {
  73         char *c_basename;
  74         char *c_optstr;
  75         char *c_usgstr[4]; /* make sure as large as largest array size */
  76 } cmd_data[] = {
  77         "clri", "F:o:?V",
  78         {
  79                 "[-F FSType] [-V] special inumber ...",
  80                 NULL
  81         },
  82         "mkfs", "F:o:mb:?V",
  83         {
  84                 "[-F FSType] [-V] [-m] [-o specific_options] special ",
  85                 "[operands]", NULL
  86         },
  87         "dcopy", "F:o:?V",
  88         {
  89                 "[-F FSType] [-V] special inumber ...",
  90                 NULL
  91         },
  92         "fsdb", "F:o:z:?V",
  93         {
  94                 "[-F FSType] [-V] [-o specific_options] special",
  95                 NULL
  96         },
  97         "fssnap", "F:dio:?V",
  98         {
  99                 "[-F FSType] [-V] -o special_options  /mount/point",
 100                 "-d [-F FSType] [-V] /mount/point | dev",
 101                 "-i [-F FSType] [-V] [-o special-options] [/mount/point | dev]",
 102                 NULL
 103         },
 104         "labelit", "F:o:?nV",
 105         {
 106                 "[-F FSType] [-V] [-o specific_options] special [operands]",
 107                 NULL
 108         },
 109         NULL, "F:o:?V",
 110         {
 111                 "[-F FSType] [-V] [-o specific_options] special [operands]",
 112                 NULL
 113         }
 114 };
 115 struct  commands *c_ptr;
 116
 117 static void usage(char *cmd, char **usg);
 118 static void lookup(void);
 119
 120 int
 121 main(int argc, char *argv[])
 122 {
 123         char    *ptr;
 124         char    full_path[PATH_MAX];
 125         char    *vfs_path = VFS_PATH;
 126         char    *alt_path = ALT_PATH;
 127         int     i;
 128         int     j;
 129         int     verbose = 0;            /* set if -V is specified */
 130         int     F_flg = 0;
 131         int     mflag = 0;
 132         int     Nflag = 0;
 133         char    *oopts = NULL;
 134         char    *tmpopts = NULL;        /* used for in use checking */
 135         int     iflag = 0;
 136         int     usgflag = 0;
 137         int     arg;                    /* argument from getopt() */
 138         char    *msg;
 139         int     error;
 140         extern  char *optarg;           /* getopt specific */
 141         extern  int optind;
 142         extern  int opterr;
 143
 144         (void) setlocale(LC_ALL, "");
 145
 146 #if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
 147 #define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
 148 #endif
 149
 150         (void) textdomain(TEXT_DOMAIN);
 151
 152         cbasename = ptr = argv[0];
 153         while (*ptr) {
 154                 if (*ptr++ == '/')
 155                         cbasename = ptr;
 156         }
 157
 158
 159         if (argc == 1) {
 160                 for (c_ptr = cmd_data; ((c_ptr->c_basename != NULL) &&
 161                     (strcmp(c_ptr->c_basename, cbasename) != 0)); c_ptr++)
 162                 ;
 163                 usage(cbasename, c_ptr->c_usgstr);
 164                 exit(2);
 165         }
 166
 167         for (c_ptr = cmd_data; ((c_ptr->c_basename != NULL) &&
 168             (strcmp(c_ptr->c_basename, cbasename) != 0));  c_ptr++)
 169                 ;
 170         while ((arg = getopt(argc, argv, c_ptr->c_optstr)) != -1) {
 171                         switch (arg) {
 172                         case 'V':       /* echo complete command line */
 173                                 verbose = 1;
 174                                 break;
 175                         case 'F':       /* FSType specified */
 176                                 F_flg++;
 177                                 fstype = optarg;
 178                                 break;
 179                         case 'o':       /* FSType specific arguments */
 180                                 newargv[newargc++] = "-o";
 181                                 newargv[newargc++] = optarg;
 182                                 oopts = optarg;
 183                                 if (!Nflag) {
 184                                         tmpopts = optarg;
 185                                         Nflag = has_Nflag(tmpopts);
 186                                 }
 187                                 break;
 188                         case '?':       /* print usage message */
 189                                 newargv[newargc++] = "-?";
 190                                 usgflag = 1;
 191                                 break;
 192                         case 'm':       /* FSType specific arguments */
 193                                 mflag = 1;
 194                                 newargv[newargc] = (char *)malloc(3);
 195                                 sprintf(newargv[newargc++], "-%c", arg);
 196                                 if (optarg)
 197                                         newargv[newargc++] = optarg;
 198                                 break;
 199                         case 'i': /* fssnap only */
 200                                 iflag = 1;
 201                                 /*FALLTHROUGH*/
 202                         default:
 203                                 newargv[newargc] = (char *)malloc(3);
 204                                 sprintf(newargv[newargc++], "-%c", arg);
 205                                 if (optarg)
 206                                         newargv[newargc++] = optarg;
 207                                 break;
 208                         }
 209                         optarg = NULL;
 210         }
 211         if (F_flg > 1) {
 212                 (void) fprintf(stderr,
 213                     gettext("%s: more than one FSType specified\n"),
 214                     cbasename);
 215                 usage(cbasename, c_ptr->c_usgstr);
 216                 exit(2);
 217         }
 218         if (fstype != NULL) {
 219                 if (strlen(fstype) > FSTYPE_MAX) {
 220                         (void) fprintf(stderr,
 221                             gettext("%s: FSType %s exceeds %d characters\n"),
 222                             cbasename, fstype, FSTYPE_MAX);
 223                         exit(2);
 224                 }
 225         }
 226
 227         /*  perform a lookup if fstype is not specified  */
 228         special = argv[optind];
 229         optind++;
 230
 231         /* handle -i (fssnap command only) */
 232         if (iflag) {
 233                 int diff = argc - optind;
 234                 /*
 235                  * There is no reason to ever call a file system specific
 236                  * version since its all in kstats.
 237                  */
 238                 if (diff > 0) /* gave more than one mountpoint or device */
 239                         usage(cbasename, c_ptr->c_usgstr);
 240                 stat_snap(cbasename, diff == 0 ? argv[argc-1] : NULL, oopts);
 241                 exit(0);
 242         }
 243
 244         if ((special == NULL) && (!usgflag)) {
 245                 (void) fprintf(stderr, gettext("%s: special not specified\n"),
 246                     cbasename);
 247                 usage(cbasename, c_ptr->c_usgstr);
 248                 exit(2);
 249         }
 250
 251         if ((fstype == NULL) && (usgflag))
 252                 usage(cbasename, c_ptr->c_usgstr);
 253         if (fstype == NULL)
 254                 lookup();
 255         if (fstype == NULL) {
 256                 (void) fprintf(stderr,
 257                     gettext("%s: FSType cannot be identified\n"), cbasename);
 258                 usage(cbasename, c_ptr->c_usgstr);
 259                 exit(2);
 260         }
 261         newargv[newargc++] = special;
 262         for (; optind < argc; optind++)
 263                 newargv[newargc++] = argv[optind];
 264
 265         /*  build the full pathname of the fstype dependent command  */
 266         sprintf(full_path, "%s/%s/%s", vfs_path, fstype, cbasename);
 267
 268         newargv[1] = cbasename;
 269
 270         if (verbose) {
 271                 printf("%s -F %s ", cbasename, fstype);
 272                 for (i = 2; newargv[i]; i++)
 273                         printf("%s ", newargv[i]);
 274                 printf("\n");
 275                 exit(0);
 276         }
 277
 278         /*
 279          * Prior to executing the command for mkfs check for device in use.
 280          * If the mflag is set, user wants to see command that created
 281          * an already existing filesystem. Do not check for in use in this
 282          * case. If Nflag is set user wants to see what the parameters
 283          * would be to create the filesystem. Do not check for in use in
 284          * this case.
 285          */
 286         if (strcmp(cbasename, "mkfs") == 0 && !mflag && !Nflag) {
 287                 if (dm_inuse(special, &msg, DM_WHO_MKFS, &error) ||
 288                     error) {
 289                         if (error != 0) {
 290                                 (void) fprintf(stderr, gettext("Error occurred"
 291                                     " with device in use checking: %s\n"),
 292                                     strerror(error));
 293                         } else {
 294                                 (void) fprintf(stderr, "%s", msg);
 295                                 free(msg);
 296                                 exit(2);
 297                         }
 298                 }
 299         }
 300
 301         /*
 302          *  Execute the FSType specific command.
 303          */
 304         execv(full_path, &newargv[1]);
 305         if ((errno == ENOENT) || (errno == EACCES)) {
 306                 /*  build the alternate pathname */
 307                 sprintf(full_path, "%s/%s/%s", alt_path, fstype, cbasename);
 308                 if (verbose) {
 309                         printf("%s -F %s ", cbasename, fstype);
 310                         for (i = 2; newargv[i]; i++)
 311                                 printf("%s ", newargv[i]);
 312                         printf("\n");
 313                         exit(0);
 314                 }
 315                 execv(full_path, &newargv[1]);
 316         }
 317         if (errno == ENOEXEC) {
 318                 newargv[0] = "sh";
 319                 newargv[1] = full_path;
 320                 execv("/sbin/sh", &newargv[0]);
 321         }
 322         if (errno != ENOENT) {
 323                 perror(cbasename);
 324                 (void) fprintf(stderr, gettext("%s: cannot execute %s\n"),
 325                     cbasename, full_path);
 326                 exit(2);
 327         }
 328
 329         if (sysfs(GETFSIND, fstype) == (-1)) {
 330                 (void) fprintf(stderr,
 331                     gettext("%s: FSType %s not installed in the kernel\n"),
 332                     cbasename, fstype);
 333                 exit(2);
 334         }
 335         (void) fprintf(stderr,
 336             gettext("%s: Operation not applicable for FSType %s \n"),
 337             cbasename, fstype);
 338         return (2);
 339 }
 340
 341 static void
 342 usage(char *cmd, char **usg)
 343 {
 344         int i;
 345         (void) fprintf(stderr, gettext("Usage:\n"));
 346         for (i = 0; usg[i] != NULL; i++)
 347                 (void) fprintf(stderr, "%s %s\n", gettext(cmd),
 348                     gettext(usg[i]));
 349         exit(2);
 350 }
 351
 352
 353 /*
 354  *  This looks up the /etc/vfstab entry given the device 'special'.
 355  *  It is called when the fstype is not specified on the command line.
 356  *
 357  *  The following global variables are used:
 358  *      special, fstype
 359  */
 360
 361 static void
 362 lookup(void)
 363 {
 364         FILE    *fd;
 365         int     ret;
 366         struct vfstab   vget, vref;
 367
 368         if ((fd = fopen(vfstab, "r")) == NULL) {
 369                 (void) fprintf(stderr, gettext("%s: cannot open vfstab\n"),
 370                     cbasename);
 371                 exit(1);
 372         }
 373         vfsnull(&vref);
 374         vref.vfs_special = special;
 375         ret = getvfsany(fd, &vget, &vref);
 376         if (ret == -1) {
 377                 rewind(fd);
 378                 vfsnull(&vref);
 379                 vref.vfs_fsckdev = special;
 380                 ret = getvfsany(fd, &vget, &vref);
 381         }
 382         fclose(fd);
 383
 384         switch (ret) {
 385         case -1:
 386                 fstype = default_fstype(special);
 387                 break;
 388         case 0:
 389                 fstype = vget.vfs_fstype;
 390                 break;
 391         case VFS_TOOLONG:
 392                 (void) fprintf(stderr,
 393                     gettext("%s: line in vfstab exceeds %d characters\n"),
 394                     cbasename, VFS_LINE_MAX-2);
 395                 exit(1);
 396                 break;
 397         case VFS_TOOFEW:
 398                 (void) fprintf(stderr,
 399                     gettext("%s: line in vfstab has too few entries\n"),
 400                     cbasename);
 401                 exit(1);
 402                 break;
 403         }
 404 }
 405
 406 void
 407 stat_snap(char *cmd, char *mountpoint, char *opts)
 408 {
 409         int fd; /* check mount point if given */
 410         int en;
 411         char *errstr;
 412
 413         if (mountpoint) {
 414                 if ((fd = open(mountpoint, O_RDONLY)) < 0) {
 415                         en = errno;
 416                         errstr = strerror(errno);
 417                         if (errstr == NULL)
 418                                 errstr = gettext("Unknown error");
 419
 420                         (void) fprintf(stderr,
 421                             gettext("%s: %s: error %d: %s\n"),
 422                             cmd, mountpoint, en, errstr);
 423
 424                         exit(2);
 425                 }
 426                 close(fd);
 427         }
 428         fssnap_show_status(mountpoint, opts, 1, (opts ? 0 : 1));
 429 }
 430 static int
 431 has_Nflag(char *opts)
 432 {
 433         while (opts != NULL && *opts != '\0') {
 434                 if (match(&opts, "N")) {
 435                         return (1);
 436                 }
 437                 if (!opts)
 438                         break;
 439                 if (*opts == ',')
 440                         opts ++;
 441                 if (*opts == ' ')
 442                         opts ++;
 443         }
 444         return (0);
 445 }
 446 /*
 447  * Parses the -o [fs specific options string] to search for the UFS -N flag.
 448  * Return the opts string pointing to the next position in the string if
 449  * match is not found. A delimiter of , or ' ' can be used depending on the
 450  * caller, newfs or mkfs.
 451  */
 452 static int
 453 match(char **opts, char *s)
 454 {
 455         char *cs;
 456         char *tmp_str;
 457
 458         cs = *opts;
 459
 460         while (*cs++ == *s) {
 461                 if (*s++ == '\0') {
 462                         goto true;
 463                 }
 464         }
 465         if (*s != '\0') {
 466                 /*
 467                  * If we cannot find the delimiter it means we
 468                  * have hit the end of the string.
 469                  */
 470                 tmp_str = strchr(*opts, ',');
 471                 if (!tmp_str)
 472                         tmp_str = strchr(*opts, ' ');
 473
 474                 *opts = tmp_str;
 475                 return (0);
 476         }
 477 true:
 478         cs--;
 479         *opts = cs;
 480         return (1);
 481 }