[BACK]Return to mount_puffs.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sbin / mount_puffs

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sbin/mount_puffs/mount_puffs.c between version 1.4 and 1.5

version 1.4, 2011/08/29 14:35:02 version 1.5, 2016/11/23 14:33:29
Line 26 
Line 26 
  */   */
   
 /*  /*
  * This is to support -o getargs without having to replicate   * This is to support -o getargs without having to replicate it in
  * it in every file server.   * every file server. It also allows puffs filesystems to be mounted
    * via "mount -a".
  */   */
   
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
Line 41  __RCSID("$NetBSD$");
Line 42  __RCSID("$NetBSD$");
 #include <fs/puffs/puffs_msgif.h>  #include <fs/puffs/puffs_msgif.h>
   
 #include <err.h>  #include <err.h>
 #include <mntopts.h>  
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
   #include <string.h>
   #include <sys/cdefs.h>
 #include <unistd.h>  #include <unistd.h>
   #include <util.h>
   
 const struct mntopt getargmopt[] = {  static int
         MOPT_GETARGS,  
         MOPT_NULL,  
 };  
   
 __dead static void  
 usage(void)  usage(void)
 {  {
   
         fprintf(stderr, "usage: %s -o getargs spec dir\n", getprogname());          fprintf(stderr, "usage: %s [-o options] program[#source] mountpoint\n", getprogname());
         exit(1);          return 1;
 }  }
   
 int  static int show_puffs_mount_args(const char *mountpoint)
 main(int argc, char *argv[])  
 {  {
         const char *vtypes[] = { VNODE_TYPES };          const char *vtypes[] = { VNODE_TYPES };
         struct puffs_kargs kargs;          struct puffs_kargs kargs;
         mntoptparse_t mp;  
         int mntflags, f;  
         int ch;  
   
         if (argc < 3)  
                 usage();  
   
         mntflags = 0;          if (mount(MOUNT_PUFFS, mountpoint, MNT_GETARGS, &kargs, sizeof(kargs)) == -1)
         while ((ch = getopt(argc, argv, "o:")) != -1) {  
                 switch (ch) {  
                 case 'o':  
                         mp = getmntopts(optarg, getargmopt, &mntflags, &f);  
                         if (mp == NULL)  
                                 err(1, "getmntopts");  
                         freemntopts(mp);  
                         break;  
                 default:  
                         usage();  
                 }  
         }  
         argc -= optind;  
         argv += optind;  
   
         if (argc != 2)  
                 usage();  
   
         if (mntflags != MNT_GETARGS)  
                 usage();  
   
         if (mount(MOUNT_PUFFS, argv[1], mntflags, &kargs, sizeof(kargs)) == -1)  
                 err(1, "mount");                  err(1, "mount");
   
         printf("version=%d, ", kargs.pa_vers);          printf("version=%d, ", kargs.pa_vers);
         printf("flags=0x%x, ", kargs.pa_flags);          printf("flags=0x%x, ", kargs.pa_flags);
   
Line 111  main(int argc, char *argv[])
Line 80  main(int argc, char *argv[])
   
         return 0;          return 0;
 }  }
   
   static int
   mount_puffs_filesystem(const char *program, const char *opts,
                                           const char *source, const char *mountpoint)
   {
           int argc = 0;
           const char **argv;
           int rv = 0;
   
           /* Construct an argument vector:
            * program [-o opts] [source] mountpoint */
           argv = ecalloc(1 + 2 + 1 + 1, sizeof(*argv));
           argv[argc++] = program;
           if (opts != NULL) {
                   argv[argc++] = "-o";
                   argv[argc++] = opts;
           }
           if (source != NULL) {
                   argv[argc++] = source;
           }
           argv[argc++] = mountpoint;
           argv[argc] = NULL;
   
           /* We intentionally use execvp(3) here because the program can
            * actually be a basename. */
           if (execvp(program, __UNCONST(argv)) == -1) {
                   warn("Cannot execute %s", program);
                   rv = 1;
           }
   
           free(argv);
           return rv;
   }
   
   static void add_opt(char **opts, const char *opt)
   {
           const size_t orig_len = *opts == NULL ? 0 : strlen(*opts);
   
           *opts = erealloc(*opts, orig_len + 1 + strlen(opt) + 1);
   
           if (orig_len == 0) {
                   strcpy(*opts, opt);
           }
           else {
                   strcat(*opts, ",");
                   strcat(*opts, opt);
           }
   }
   
   int
   main(int argc, char *argv[])
   {
           int mntflags = 0;
           int ch;
           char *opts = NULL;
           int rv = 0;
   
           while ((ch = getopt(argc, argv, "o:")) != -1) {
                   switch (ch) {
                   case 'o':
                           for (char *opt = optarg; (opt = strtok(opt, ",")) != NULL; opt = NULL) {
                                   if (strcmp(opt, "getargs") == 0) {
                                           mntflags |= MNT_GETARGS;
                                           break; /* No need to parse it any further. */
                                   }
                                   else {
                                           add_opt(&opts, opt);
                                   }
                           }
                           break;
                   default:
                           rv = usage();
                           goto free_opts;
                   }
           }
           argc -= optind;
           argv += optind;
   
           if (argc != 2) {
                   rv = usage();
                   goto free_opts;
           }
   
           if (mntflags & MNT_GETARGS) {
                   /* Special case for -o getargs: retrieve kernel arguments for
                    * an already mounted filesystem. */
                   rv = show_puffs_mount_args(argv[1]);
           }
           else {
                   /* Split the program name and source. This is to allow
                    * filesystems to be mounted via "mount -a" i.e. /etc/fstab */
                   char *source  = argv[0];
                   char *program = strsep(&source, "#");
   
                   rv = mount_puffs_filesystem(program, opts, source, argv[1]);
           }
   
   free_opts:
           free(opts);
           return rv;
   }

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5

CVSweb <webmaster@jp.NetBSD.org>