static int parse_options(char *options, struct omfs_sb_info *sbi) { char *p; substring_t args[MAX_OPT_ARGS]; int option; if (!options) return 1; while ((p = strsep(&options, ",")) != NULL) { int token; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_uid: if (match_int(&args[0], &option)) return 0; sbi->s_uid = make_kuid(current_user_ns(), option); if (!uid_valid(sbi->s_uid)) return 0; break; case Opt_gid: if (match_int(&args[0], &option)) return 0; sbi->s_gid = make_kgid(current_user_ns(), option); if (!gid_valid(sbi->s_gid)) return 0; break; case Opt_umask: if (match_octal(&args[0], &option)) return 0; sbi->s_fmask = sbi->s_dmask = option; break; case Opt_dmask: if (match_octal(&args[0], &option)) return 0; sbi->s_dmask = option; break; case Opt_fmask: if (match_octal(&args[0], &option)) return 0; sbi->s_fmask = option; break; default: return 0; } } return 1; }
static int bpf_parse_options(char *data, struct bpf_mount_opts *opts) { substring_t args[MAX_OPT_ARGS]; int option, token; char *ptr; opts->mode = S_IRWXUGO; while ((ptr = strsep(&data, ",")) != NULL) { if (!*ptr) continue; token = match_token(ptr, bpf_mount_tokens, args); switch (token) { case OPT_MODE: if (match_octal(&args[0], &option)) return -EINVAL; opts->mode = option & S_IALLUGO; break; /* We might like to report bad mount options here, but * traditionally we've ignored all mount options, so we'd * better continue to ignore non-existing options for bpf. */ } } return 0; }
static int ramfs_parse_options(char *data, struct ramfs_mount_opts *opts) { substring_t args[MAX_OPT_ARGS]; int option; int token; char *p; opts->mode = RAMFS_DEFAULT_MODE; while ((p = strsep(&data, ",")) != NULL) { if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_mode: if (match_octal(&args[0], &option)) return -EINVAL; opts->mode = option & S_IALLUGO; break; /* */ } } return 0; }
static int ramfs_parse_options(char *data, struct ramfs_mount_opts *opts) { substring_t args[MAX_OPT_ARGS]; int option; int token; char *p; opts->mode = RAMFS_DEFAULT_MODE; while ((p = strsep(&data, ",")) != NULL) { if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_mode: if (match_octal(&args[0], &option)) return -EINVAL; opts->mode = option & S_IALLUGO; break; /* * We might like to report bad mount options here; * but traditionally ramfs has ignored all mount options, * and as it is used as a !CONFIG_SHMEM simple substitute * for tmpfs, better continue to ignore other mount options. */ } } return 0; }
static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts) { substring_t args[MAX_OPT_ARGS]; int option; int token; kuid_t uid; kgid_t gid; char *p; opts->mode = DEBUGFS_DEFAULT_MODE; while ((p = strsep(&data, ",")) != NULL) { if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_uid: if (match_int(&args[0], &option)) return -EINVAL; uid = make_kuid(current_user_ns(), option); if (!uid_valid(uid)) return -EINVAL; opts->uid = uid; break; case Opt_gid: if (match_octal(&args[0], &option)) return -EINVAL; gid = make_kgid(current_user_ns(), option); if (!gid_valid(gid)) return -EINVAL; opts->gid = gid; break; case Opt_mode: if (match_octal(&args[0], &option)) return -EINVAL; opts->mode = option & S_IALLUGO; break; /* * We might like to report bad mount options here; * but traditionally debugfs has ignored all mount options */ } } return 0; }
/* * Parse the mount options (uid, gid and mode) */ static int parse_options(char *options, struct partsfs_state *state) { char *p; substring_t args[MAX_OPT_ARGS]; /* Initialize the options defaults values */ state->option_uid = current_uid(); state->option_gid = current_gid(); state->option_mode = PARTSFS_DEFAULT_FILE_MODE; if (!options) return 0; while ((p = strsep(&options, ",")) != NULL) { int token; int value; if (*p == '\0') continue; token = match_token(p, tokens, args); switch (token) { case opt_uid: if (match_int(&args[0], &value)) { printk(KERN_ERR "PARTSFS: uid mount option requires an argument\n"); return -EINVAL; } state->option_uid = (uid_t)value; break; case opt_gid: if (match_int(&args[0], &value)) { printk(KERN_ERR "PARTSFS: gid mount option requires an argument\n"); return -EINVAL; } state->option_gid = (gid_t)value; break; case opt_mode: if (match_octal(&args[0], &value)) { printk(KERN_ERR "PARTSFS: mode mount option requires an argument\n"); return -EINVAL; } state->option_mode = (umode_t)value & 0666; break; default: return -EINVAL; } } return 0; }
static int devpts_remount(struct super_block *sb, int *flags, char *data) { char *p; config.setuid = 0; config.setgid = 0; config.uid = 0; config.gid = 0; config.mode = 0600; while ((p = strsep(&data, ",")) != NULL) { substring_t args[MAX_OPT_ARGS]; int token; int option; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_uid: if (match_int(&args[0], &option)) return -EINVAL; config.uid = option; config.setuid = 1; break; case Opt_gid: if (match_int(&args[0], &option)) return -EINVAL; config.gid = option; config.setgid = 1; break; case Opt_mode: if (match_octal(&args[0], &option)) return -EINVAL; config.mode = option & ~S_IFMT; break; default: printk(KERN_ERR "devpts: called with bogus options\n"); return -EINVAL; } } return 0; }
// 解析参数 static int myfs_parse_options(char *data, struct myfs_fs_info *fsinfo) { substring_t args[MAX_OPT_ARGS]; int option; int token; char *p; fsinfo->root_mode = DEFAULT_MODE; fsinfo->file_max_size = MAX_LFS_FILESIZE; fsinfo->fs_max_size = MAX_FS_SIZE; fsinfo->block_size = PAGE_CACHE_SIZE; while ((p = strsep(&data, ",")) != NULL) { if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_mode: if (match_octal(&args[0], &option)) return -EINVAL; fsinfo->root_mode = option & S_IALLUGO; break; case Opt_blksize: if (match_hex(&args[0], &option)) return -EINVAL; fsinfo->block_size = option; break; case Opt_filemsize: if (match_hex(&args[0], &option)) return -EINVAL; fsinfo->file_max_size = option; break; case Opt_fsmsize: if (match_hex(&args[0], &option)) return -EINVAL; fsinfo->fs_max_size = option; break; } } return 0; }
/* * parse_options() * * adapted from linux/fs/msdos/inode.c written 1992,93 by Werner Almesberger * This function is called by hfs_read_super() to parse the mount options. */ static int parse_options(char *options, struct hfs_sb_info *hsb) { char *p; substring_t args[MAX_OPT_ARGS]; int tmp, token; /* initialize the sb with defaults */ hsb->s_uid = current_uid(); hsb->s_gid = current_gid(); hsb->s_file_umask = 0133; hsb->s_dir_umask = 0022; hsb->s_type = hsb->s_creator = cpu_to_be32(0x3f3f3f3f); /* == '????' */ hsb->s_quiet = 0; hsb->part = -1; hsb->session = -1; if (!options) return 1; while ((p = strsep(&options, ",")) != NULL) { if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case opt_uid: if (match_int(&args[0], &tmp)) { printk(KERN_ERR "hfs: uid requires an argument\n"); return 0; } hsb->s_uid = (uid_t)tmp; break; case opt_gid: if (match_int(&args[0], &tmp)) { printk(KERN_ERR "hfs: gid requires an argument\n"); return 0; } hsb->s_gid = (gid_t)tmp; break; case opt_umask: if (match_octal(&args[0], &tmp)) { printk(KERN_ERR "hfs: umask requires a value\n"); return 0; } hsb->s_file_umask = (umode_t)tmp; hsb->s_dir_umask = (umode_t)tmp; break; case opt_file_umask: if (match_octal(&args[0], &tmp)) { printk(KERN_ERR "hfs: file_umask requires a value\n"); return 0; } hsb->s_file_umask = (umode_t)tmp; break; case opt_dir_umask: if (match_octal(&args[0], &tmp)) { printk(KERN_ERR "hfs: dir_umask requires a value\n"); return 0; } hsb->s_dir_umask = (umode_t)tmp; break; case opt_part: if (match_int(&args[0], &hsb->part)) { printk(KERN_ERR "hfs: part requires an argument\n"); return 0; } break; case opt_session: if (match_int(&args[0], &hsb->session)) { printk(KERN_ERR "hfs: session requires an argument\n"); return 0; } break; case opt_type: if (match_fourchar(&args[0], &hsb->s_type)) { printk(KERN_ERR "hfs: type requires a 4 character value\n"); return 0; } break; case opt_creator: if (match_fourchar(&args[0], &hsb->s_creator)) { printk(KERN_ERR "hfs: creator requires a 4 character value\n"); return 0; } break; case opt_quiet: hsb->s_quiet = 1; break; case opt_codepage: if (hsb->nls_disk) { printk(KERN_ERR "hfs: unable to change codepage\n"); return 0; } p = match_strdup(&args[0]); if (p) hsb->nls_disk = load_nls(p); if (!hsb->nls_disk) { printk(KERN_ERR "hfs: unable to load codepage \"%s\"\n", p); kfree(p); return 0; } kfree(p); break; case opt_iocharset: if (hsb->nls_io) { printk(KERN_ERR "hfs: unable to change iocharset\n"); return 0; } p = match_strdup(&args[0]); if (p) hsb->nls_io = load_nls(p); if (!hsb->nls_io) { printk(KERN_ERR "hfs: unable to load iocharset \"%s\"\n", p); kfree(p); return 0; } kfree(p); break; default: return 0; } } if (hsb->nls_disk && !hsb->nls_io) { hsb->nls_io = load_nls_default(); if (!hsb->nls_io) { printk(KERN_ERR "hfs: unable to load default iocharset\n"); return 0; } } hsb->s_dir_umask &= 0777; hsb->s_file_umask &= 0577; return 1; }
/* * parse_options() * * adapted from linux/fs/msdos/inode.c written 1992,93 by Werner Almesberger * This function is called by hfs_read_super() to parse the mount options. */ static int parse_options(char *options, struct hfs_sb_info *hsb, int *part) { char *p; char names, fork; substring_t args[MAX_OPT_ARGS]; int option; /* initialize the sb with defaults */ memset(hsb, 0, sizeof(*hsb)); hsb->magic = HFS_SB_MAGIC; hsb->s_uid = current->uid; hsb->s_gid = current->gid; hsb->s_umask = current->fs->umask; hsb->s_type = 0x3f3f3f3f; /* == '????' */ hsb->s_creator = 0x3f3f3f3f; /* == '????' */ hsb->s_lowercase = 0; hsb->s_quiet = 0; hsb->s_afpd = 0; /* default version. 0 just selects the defaults */ hsb->s_version = 0; hsb->s_conv = 'b'; names = '?'; fork = '?'; *part = 0; if (!options) { goto done; } while ((p = strsep(&options,",")) != NULL) { int token; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { /* Numeric-valued options */ case Opt_version: if (match_int(&args[0], &option)) return 0; hsb->s_version = option; break; case Opt_uid: if (match_int(&args[0], &option)) return 0; hsb->s_uid = option; break; case Opt_gid: if (match_int(&args[0], &option)) return 0; hsb->s_gid = option; break; case Opt_umask: if (match_octal(&args[0], &option)) return 0; hsb->s_umask = option; break; case Opt_part: if (match_int(&args[0], &option)) return 0; *part = option; break; /* String-valued options */ case Opt_type: if (strlen(args[0].from) != 4) { return 0; } hsb->s_type = hfs_get_nl(args[0].from); break; case Opt_creator: if (strlen(args[0].from) != 4) { return 0; } hsb->s_creator = hfs_get_nl(args[0].from); break; /* Boolean-valued options */ case Opt_quiet: hsb->s_quiet = 1; break; case Opt_afpd: hsb->s_afpd = 1; break; /* Multiple choice options */ case Opt_names_netatalk: names = 'n'; break; case Opt_names_trivial: names = 't'; break; case Opt_names_alpha: names = 'a'; break; case Opt_names_latin: names = 'l'; break; case Opt_names_7bit: names = '7'; break; case Opt_names_8bit: names = '8'; break; case Opt_names_cap: names = 'c'; break; case Opt_fork_netatalk: fork = 'n'; break; case Opt_fork_single: fork = 's'; break; case Opt_fork_double: fork = 'd'; break; case Opt_fork_cap: fork = 'c'; break; case Opt_case_lower: hsb->s_lowercase = 1; break; case Opt_case_asis: hsb->s_lowercase = 0; break; case Opt_conv_binary: hsb->s_conv = 'b'; break; case Opt_conv_text: hsb->s_conv = 't'; break; case Opt_conv_auto: hsb->s_conv = 'a'; break; default: return 0; } } done: /* Parse the "fork" and "names" options */ if (fork == '?') { fork = hsb->s_afpd ? 'n' : 'c'; } switch (fork) { default: case 'c': hsb->s_ifill = hfs_cap_ifill; hsb->s_reserved1 = hfs_cap_reserved1; hsb->s_reserved2 = hfs_cap_reserved2; break; case 's': hfs_warn("hfs_fs: AppleSingle not yet implemented.\n"); return 0; /* break; */ case 'd': hsb->s_ifill = hfs_dbl_ifill; hsb->s_reserved1 = hfs_dbl_reserved1; hsb->s_reserved2 = hfs_dbl_reserved2; break; case 'n': hsb->s_ifill = hfs_nat_ifill; hsb->s_reserved1 = hfs_nat_reserved1; hsb->s_reserved2 = hfs_nat_reserved2; break; } if (names == '?') { names = fork; } switch (names) { default: case 'n': hsb->s_nameout = hfs_colon2mac; hsb->s_namein = hfs_mac2nat; break; case 'c': hsb->s_nameout = hfs_colon2mac; hsb->s_namein = hfs_mac2cap; break; case 't': hsb->s_nameout = hfs_triv2mac; hsb->s_namein = hfs_mac2triv; break; case '7': hsb->s_nameout = hfs_prcnt2mac; hsb->s_namein = hfs_mac2seven; break; case '8': hsb->s_nameout = hfs_prcnt2mac; hsb->s_namein = hfs_mac2eight; break; case 'l': hsb->s_nameout = hfs_latin2mac; hsb->s_namein = hfs_mac2latin; break; case 'a': /* 's' and 'd' are unadvertised aliases for 'alpha', */ case 's': /* since 'alpha' is the default if fork=s or fork=d. */ case 'd': /* (It is also helpful for poor typists!) */ hsb->s_nameout = hfs_prcnt2mac; hsb->s_namein = hfs_mac2alpha; break; } return 1; }
/* input is the options passed to mount() as a string */ int hfsplus_parse_options(char *input, struct hfsplus_sb_info *sbi) { char *p; substring_t args[MAX_OPT_ARGS]; int tmp, token; if (!input) goto done; while ((p = strsep(&input, ",")) != NULL) { if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case opt_creator: if (match_fourchar(&args[0], &sbi->creator)) { printk(KERN_ERR "hfs: creator requires a 4 character value\n"); return 0; } break; case opt_type: if (match_fourchar(&args[0], &sbi->type)) { printk(KERN_ERR "hfs: type requires a 4 character value\n"); return 0; } break; case opt_umask: if (match_octal(&args[0], &tmp)) { printk(KERN_ERR "hfs: umask requires a value\n"); return 0; } sbi->umask = (umode_t)tmp; break; case opt_uid: if (match_int(&args[0], &tmp)) { printk(KERN_ERR "hfs: uid requires an argument\n"); return 0; } sbi->uid = (uid_t)tmp; break; case opt_gid: if (match_int(&args[0], &tmp)) { printk(KERN_ERR "hfs: gid requires an argument\n"); return 0; } sbi->gid = (gid_t)tmp; break; case opt_part: if (match_int(&args[0], &sbi->part)) { printk(KERN_ERR "hfs: part requires an argument\n"); return 0; } break; case opt_session: if (match_int(&args[0], &sbi->session)) { printk(KERN_ERR "hfs: session requires an argument\n"); return 0; } break; case opt_nls: if (sbi->nls) { printk(KERN_ERR "hfs: unable to change nls mapping\n"); return 0; } p = match_strdup(&args[0]); if (p) sbi->nls = load_nls(p); if (!sbi->nls) { printk(KERN_ERR "hfs: unable to load " "nls mapping \"%s\"\n", p); kfree(p); return 0; } kfree(p); break; case opt_decompose: clear_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags); break; case opt_nodecompose: set_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags); break; case opt_barrier: clear_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags); break; case opt_nobarrier: set_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags); break; case opt_force: set_bit(HFSPLUS_SB_FORCE, &sbi->flags); break; default: return 0; } } done: if (!sbi->nls) { /* try utf8 first, as this is the old default behaviour */ sbi->nls = load_nls("utf8"); if (!sbi->nls) sbi->nls = load_nls_default(); if (!sbi->nls) return 0; } return 1; }
static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev) { char *p; memset(d, 0, sizeof(struct fuse_mount_data)); d->max_read = ~0; d->blksize = FUSE_DEFAULT_BLKSIZE; while ((p = strsep(&opt, ",")) != NULL) { int token; int value; substring_t args[MAX_OPT_ARGS]; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case OPT_FD: if (match_int(&args[0], &value)) return 0; d->fd = value; d->fd_present = 1; break; case OPT_ROOTMODE: if (match_octal(&args[0], &value)) return 0; if (!fuse_valid_type(value)) return 0; d->rootmode = value; d->rootmode_present = 1; break; case OPT_USER_ID: if (match_int(&args[0], &value)) return 0; d->user_id = value; d->user_id_present = 1; break; case OPT_GROUP_ID: if (match_int(&args[0], &value)) return 0; d->group_id = value; d->group_id_present = 1; break; case OPT_DEFAULT_PERMISSIONS: d->flags |= FUSE_DEFAULT_PERMISSIONS; break; case OPT_ALLOW_OTHER: d->flags |= FUSE_ALLOW_OTHER; break; case OPT_MAX_READ: if (match_int(&args[0], &value)) return 0; d->max_read = value; break; case OPT_BLKSIZE: if (!is_bdev || match_int(&args[0], &value)) return 0; d->blksize = value; break; default: return 0; } } if (!d->fd_present || !d->rootmode_present || !d->user_id_present || !d->group_id_present) return 0; return 1; }
static int parse_opts(char *opts, uid_t *uid, gid_t *gid, umode_t *umask, int *lowercase, int *eas, int *chk, int *errs, int *chkdsk, int *timeshift) { char *p; int option; if (!opts) return 1; /*printk("Parsing opts: '%s'\n",opts);*/ while ((p = strsep(&opts, ",")) != NULL) { substring_t args[MAX_OPT_ARGS]; int token; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_help: return 2; case Opt_uid: if (match_int(args, &option)) return 0; *uid = option; break; case Opt_gid: if (match_int(args, &option)) return 0; *gid = option; break; case Opt_umask: if (match_octal(args, &option)) return 0; *umask = option; break; case Opt_case_lower: *lowercase = 1; break; case Opt_case_asis: *lowercase = 0; break; case Opt_check_none: *chk = 0; break; case Opt_check_normal: *chk = 1; break; case Opt_check_strict: *chk = 2; break; case Opt_err_cont: *errs = 0; break; case Opt_err_ro: *errs = 1; break; case Opt_err_panic: *errs = 2; break; case Opt_eas_no: *eas = 0; break; case Opt_eas_ro: *eas = 1; break; case Opt_eas_rw: *eas = 2; break; case Opt_chkdsk_no: *chkdsk = 0; break; case Opt_chkdsk_errors: *chkdsk = 1; break; case Opt_chkdsk_always: *chkdsk = 2; break; case Opt_timeshift: { int m = 1; char *rhs = args[0].from; if (!rhs || !*rhs) return 0; if (*rhs == '-') m = -1; if (*rhs == '+' || *rhs == '-') rhs++; *timeshift = simple_strtoul(rhs, &rhs, 0) * m; if (*rhs) return 0; break; } default: return 0; } } return 1; }
/* * parse_mount_options(): * Set @opts to mount options specified in @data. If an option is not * specified in @data, set it to its default value. * * Note: @data may be NULL (in which case all options are set to default). */ static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts) { char *p; kuid_t uid; kgid_t gid; opts->setuid = 0; opts->setgid = 0; opts->uid = GLOBAL_ROOT_UID; opts->gid = GLOBAL_ROOT_GID; opts->mode = DEVPTS_DEFAULT_MODE; opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE; opts->max = NR_UNIX98_PTY_MAX; /* Only allow instances mounted from the initial mount * namespace to tap the reserve pool of ptys. */ if (op == PARSE_MOUNT) opts->reserve = (current->nsproxy->mnt_ns == init_task.nsproxy->mnt_ns); while ((p = strsep(&data, ",")) != NULL) { substring_t args[MAX_OPT_ARGS]; int token; int option; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_uid: if (match_int(&args[0], &option)) return -EINVAL; uid = make_kuid(current_user_ns(), option); if (!uid_valid(uid)) return -EINVAL; opts->uid = uid; opts->setuid = 1; break; case Opt_gid: if (match_int(&args[0], &option)) return -EINVAL; gid = make_kgid(current_user_ns(), option); if (!gid_valid(gid)) return -EINVAL; opts->gid = gid; opts->setgid = 1; break; case Opt_mode: if (match_octal(&args[0], &option)) return -EINVAL; opts->mode = option & S_IALLUGO; break; case Opt_ptmxmode: if (match_octal(&args[0], &option)) return -EINVAL; opts->ptmxmode = option & S_IALLUGO; break; case Opt_newinstance: break; case Opt_max: if (match_int(&args[0], &option) || option < 0 || option > NR_UNIX98_PTY_MAX) return -EINVAL; opts->max = option; break; default: pr_err("called with bogus options\n"); return -EINVAL; } } return 0; }
static int nova_parse_options(char *options, struct nova_sb_info *sbi, bool remount) { char *p; substring_t args[MAX_OPT_ARGS]; int option; if (!options) return 0; while ((p = strsep(&options, ",")) != NULL) { int token; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_bpi: if (remount) goto bad_opt; if (match_int(&args[0], &option)) goto bad_val; sbi->bpi = option; break; case Opt_uid: if (remount) goto bad_opt; if (match_int(&args[0], &option)) goto bad_val; sbi->uid = make_kuid(current_user_ns(), option); break; case Opt_gid: if (match_int(&args[0], &option)) goto bad_val; sbi->gid = make_kgid(current_user_ns(), option); break; case Opt_mode: if (match_octal(&args[0], &option)) goto bad_val; sbi->mode = option & 01777U; break; case Opt_init: if (remount) goto bad_opt; set_opt(sbi->s_mount_opt, FORMAT); break; case Opt_err_panic: clear_opt(sbi->s_mount_opt, ERRORS_CONT); clear_opt(sbi->s_mount_opt, ERRORS_RO); set_opt(sbi->s_mount_opt, ERRORS_PANIC); break; case Opt_err_ro: clear_opt(sbi->s_mount_opt, ERRORS_CONT); clear_opt(sbi->s_mount_opt, ERRORS_PANIC); set_opt(sbi->s_mount_opt, ERRORS_RO); break; case Opt_err_cont: clear_opt(sbi->s_mount_opt, ERRORS_RO); clear_opt(sbi->s_mount_opt, ERRORS_PANIC); set_opt(sbi->s_mount_opt, ERRORS_CONT); break; case Opt_wprotect: if (remount) goto bad_opt; set_opt(sbi->s_mount_opt, PROTECT); nova_info("NOVA: Enabling new Write Protection " "(CR0.WP)\n"); break; case Opt_dbgmask: if (match_int(&args[0], &option)) goto bad_val; nova_dbgmask = option; break; default: { goto bad_opt; } } } return 0; bad_val: printk(KERN_INFO "Bad value '%s' for mount option '%s'\n", args[0].from, p); return -EINVAL; bad_opt: printk(KERN_INFO "Bad mount option: \"%s\"\n", p); return -EINVAL; }
static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts) { char *p; opts->setuid = 0; opts->setgid = 0; opts->uid = 0; opts->gid = 0; opts->mode = DEVPTS_DEFAULT_MODE; opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE; opts->max = NR_UNIX98_PTY_MAX; if (op == PARSE_MOUNT) opts->newinstance = 0; while ((p = strsep(&data, ",")) != NULL) { substring_t args[MAX_OPT_ARGS]; int token; int option; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_uid: if (match_int(&args[0], &option)) return -EINVAL; opts->uid = option; opts->setuid = 1; break; case Opt_gid: if (match_int(&args[0], &option)) return -EINVAL; opts->gid = option; opts->setgid = 1; break; case Opt_mode: if (match_octal(&args[0], &option)) return -EINVAL; opts->mode = option & S_IALLUGO; break; #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES case Opt_ptmxmode: if (match_octal(&args[0], &option)) return -EINVAL; opts->ptmxmode = option & S_IALLUGO; break; case Opt_newinstance: if (op == PARSE_MOUNT) opts->newinstance = 1; break; case Opt_max: if (match_int(&args[0], &option) || option < 0 || option > NR_UNIX98_PTY_MAX) return -EINVAL; opts->max = option; break; #endif default: printk(KERN_ERR "devpts: called with bogus options\n"); return -EINVAL; } } return 0; }
static int parse_options(struct super_block *sb, char *options, int silent, int *debug, struct sdcardfs_mount_options *opts) { char *p; substring_t args[MAX_OPT_ARGS]; int option; char *string_option; /* by default, we use AID_MEDIA_RW as uid, gid */ opts->fs_low_uid = AID_MEDIA_RW; opts->fs_low_gid = AID_MEDIA_RW; opts->userid = 0; opts->owner_user = 0; /* by default, we use LOWER_FS_EXT4 as lower fs type */ opts->lower_fs = LOWER_FS_EXT4; /* by default, 0MB is reserved */ opts->reserved_mb = 0; *debug = 0; if (!options) return 0; while ((p = strsep(&options, ",")) != NULL) { int token; if (!*p) continue; token = match_token(p, sdcardfs_tokens, args); switch (token) { case Opt_debug: *debug = 1; break; case Opt_uid: if (match_int(&args[0], &option)) return 0; opts->fs_low_uid = option; break; case Opt_gid: if (match_int(&args[0], &option)) return 0; opts->fs_low_gid = option; break; case Opt_userid: if (match_int(&args[0], &option)) return 0; opts->userid = option; break; case Opt_sdfs_gid: if (match_int(&args[0], &option)) return 0; opts->sdfs_gid = option; break; case Opt_sdfs_mask: if (match_octal(&args[0], &option)) return 0; opts->sdfs_mask = option; break; case Opt_multi_user: opts->multi_user = 1; break; case Opt_owner_user: if (match_int(&args[0], &option)) return 0; opts->owner_user = option; break; case Opt_lower_fs: string_option = match_strdup(&args[0]); if (!string_option) return -ENOMEM; if (!strcmp("ext4", string_option)) { opts->lower_fs = LOWER_FS_EXT4; } else if (!strcmp("exfat", string_option)) { opts->lower_fs = LOWER_FS_EXFAT; } else if (!strcmp("fat", string_option) || !strcmp("vfat", string_option)) { opts->lower_fs = LOWER_FS_FAT; } else { kfree(string_option); goto invalid_option; } kfree(string_option); break; case Opt_reserved_mb: if (match_int(&args[0], &option)) return 0; opts->reserved_mb = option; break; /* unknown option */ default: invalid_option: if (!silent) { printk( KERN_ERR "Unrecognized mount option \"%s\" " "or missing value", p); } return -EINVAL; } } if (*debug) { printk( KERN_INFO "sdcardfs : options - debug:%d\n", *debug); printk( KERN_INFO "sdcardfs : options - uid:%d\n", opts->fs_low_uid); printk( KERN_INFO "sdcardfs : options - gid:%d\n", opts->fs_low_gid); printk( KERN_INFO "sdcardfs : options - userid:%d\n", opts->userid); } return 0; }
/* * parse_mount_options(): * Set @opts to mount options specified in @data. If an option is not * specified in @data, set it to its default value. The exception is * 'newinstance' option which can only be set/cleared on a mount (i.e. * cannot be changed during remount). * * Note: @data may be NULL (in which case all options are set to default). */ static int parse_mount_options(char *data, int op, struct pts_mount_opts *opts) { char *p; kuid_t uid; kgid_t gid; opts->setuid = 0; opts->setgid = 0; opts->uid = GLOBAL_ROOT_UID; opts->gid = GLOBAL_ROOT_GID; opts->mode = DEVPTS_DEFAULT_MODE; opts->ptmxmode = DEVPTS_DEFAULT_PTMX_MODE; opts->max = NR_UNIX98_PTY_MAX; /* newinstance makes sense only on initial mount */ if (op == PARSE_MOUNT) opts->newinstance = 0; while ((p = strsep(&data, ",")) != NULL) { substring_t args[MAX_OPT_ARGS]; int token; int option; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_uid: if (match_int(&args[0], &option)) return -EINVAL; uid = make_kuid(current_user_ns(), option); if (!uid_valid(uid)) return -EINVAL; opts->uid = uid; opts->setuid = 1; break; case Opt_gid: if (match_int(&args[0], &option)) return -EINVAL; gid = make_kgid(current_user_ns(), option); if (!gid_valid(gid)) return -EINVAL; opts->gid = gid; opts->setgid = 1; break; case Opt_mode: if (match_octal(&args[0], &option)) return -EINVAL; opts->mode = option & S_IALLUGO; break; #ifdef CONFIG_DEVPTS_MULTIPLE_INSTANCES case Opt_ptmxmode: if (match_octal(&args[0], &option)) return -EINVAL; opts->ptmxmode = option & S_IALLUGO; break; case Opt_newinstance: /* newinstance makes sense only on initial mount */ if (op == PARSE_MOUNT) opts->newinstance = 1; break; case Opt_max: if (match_int(&args[0], &option) || option < 0 || option > NR_UNIX98_PTY_MAX) return -EINVAL; opts->max = option; break; #endif default: pr_err("called with bogus options\n"); return -EINVAL; } } return 0; }
static int parse_options(char *options, uid_t *uid, gid_t *gid, int *mode, int *reserved, s32 *root, int *blocksize, char **prefix, char *volume, unsigned long *mount_opts) { char *p; substring_t args[MAX_OPT_ARGS]; /* Fill in defaults */ *uid = current_uid(); *gid = current_gid(); *reserved = 2; *root = -1; *blocksize = -1; volume[0] = ':'; volume[1] = 0; *mount_opts = 0; if (!options) return 1; while ((p = strsep(&options, ",")) != NULL) { int token, n, option; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_bs: if (match_int(&args[0], &n)) return 0; if (n != 512 && n != 1024 && n != 2048 && n != 4096) { printk ("AFFS: Invalid blocksize (512, 1024, 2048, 4096 allowed)\n"); return 0; } *blocksize = n; break; case Opt_mode: if (match_octal(&args[0], &option)) return 0; *mode = option & 0777; *mount_opts |= SF_SETMODE; break; case Opt_mufs: *mount_opts |= SF_MUFS; break; case Opt_prefix: *prefix = match_strdup(&args[0]); if (!*prefix) return 0; *mount_opts |= SF_PREFIX; break; case Opt_protect: *mount_opts |= SF_IMMUTABLE; break; case Opt_reserved: if (match_int(&args[0], reserved)) return 0; break; case Opt_root: if (match_int(&args[0], root)) return 0; break; case Opt_setgid: if (match_int(&args[0], &option)) return 0; *gid = option; *mount_opts |= SF_SETGID; break; case Opt_setuid: if (match_int(&args[0], &option)) return 0; *uid = option; *mount_opts |= SF_SETUID; break; case Opt_verbose: *mount_opts |= SF_VERBOSE; break; case Opt_volume: { char *vol = match_strdup(&args[0]); if (!vol) return 0; strlcpy(volume, vol, 32); kfree(vol); break; } case Opt_ignore: /* Silently ignore the quota options */ break; default: printk("AFFS: Unrecognized mount option \"%s\" " "or missing value\n", p); return 0; } } return 1; }
static int parse_options(struct super_block *sb, char *options, int silent, int *debug, struct sdcardfs_mount_options *opts) { char *p; substring_t args[MAX_OPT_ARGS]; int option; char *string_option; char *label; /* by default, we use AID_MEDIA_RW as low_uid, low_gid */ opts->fs_low_uid = AID_MEDIA_RW; opts->fs_low_gid = AID_MEDIA_RW; /* by default, userid is 0, gid is AID_EVERYBODY */ opts->gid = AID_EVERYBODY; opts->userid = 0; /* by default, we use LOWER_FS_EXT4 as lower fs type */ opts->lower_fs = LOWER_FS_EXT4; /* by default, 0MB is reserved */ opts->reserved_mb = 0; /* by default, mask is 0 */ opts->mask = 0; /* by default, multi_user is false */ opts->multi_user = false; opts->label = NULL; opts->type = TYPE_NONE; *debug = 0; if (!options) return 0; while ((p = strsep(&options, ",")) != NULL) { int token; if (!*p) continue; token = match_token(p, sdcardfs_tokens, args); switch (token) { case Opt_debug: *debug = 1; break; case Opt_low_uid: if (match_int(&args[0], &option)) return 0; opts->fs_low_uid = option; break; case Opt_low_gid: if (match_int(&args[0], &option)) return 0; opts->fs_low_gid = option; break; case Opt_gid: if (match_int(&args[0], &option)) goto invalid_option; opts->gid = option; break; case Opt_userid: if (match_int(&args[0], &option)) goto invalid_option; opts->userid = option; break; case Opt_lower_fs: string_option = match_strdup(&args[0]); if (!string_option) return -ENOMEM; if (!strcmp("ext4", string_option)) { opts->lower_fs = LOWER_FS_EXT4; } else if (!strcmp("fat", string_option)) { opts->lower_fs = LOWER_FS_FAT; } else { kfree(string_option); goto invalid_option; } kfree(string_option); break; case Opt_reserved_mb: if (match_int(&args[0], &option)) return 0; opts->reserved_mb = option; break; case Opt_mask: if (match_octal(&args[0], &option)) goto invalid_option; opts->mask = option; break; case Opt_multi_user: opts->multi_user = true; break; case Opt_label: label = match_strdup(&args[0]); if (!label) return -ENOMEM; opts->label = label; break; case Opt_type: string_option = match_strdup(&args[0]); if (!string_option) return -ENOMEM; if (!strcmp("default", string_option)) { opts->type = TYPE_DEFAULT; } else if (!strcmp("read", string_option)) { opts->type = TYPE_READ; } else if (!strcmp("write", string_option)) { opts->type = TYPE_WRITE; } else { kfree(string_option); goto invalid_option; } kfree(string_option); break; /* unknown option */ default: invalid_option: if (!silent) { printk( KERN_ERR "Unrecognized mount option \"%s\" " "or missing value", p); } return -EINVAL; } } if (*debug) { printk( KERN_INFO "sdcardfs : options - debug:%d\n", *debug); printk( KERN_INFO "sdcardfs : options - uid:%d\n", opts->fs_low_uid); printk( KERN_INFO "sdcardfs : options - gid:%d\n", opts->fs_low_gid); } return 0; }