fs/gfs2/mount.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
   4  *
   5  * This copyrighted material is made available to anyone wishing to use,
   6  * modify, copy, or redistribute it subject to the terms and conditions
   7  * of the GNU General Public License version 2.
   8  */
   9
  10 #include <linux/slab.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/completion.h>
  13 #include <linux/buffer_head.h>
  14 #include <linux/gfs2_ondisk.h>
  15 #include <linux/lm_interface.h>
  16 #include <linux/parser.h>
  17
  18 #include "gfs2.h"
  19 #include "incore.h"
  20 #include "mount.h"
  21 #include "sys.h"
  22 #include "util.h"
  23
  24 enum {
  25         Opt_lockproto,
  26         Opt_locktable,
  27         Opt_hostdata,
  28         Opt_spectator,
  29         Opt_ignore_local_fs,
  30         Opt_localflocks,
  31         Opt_localcaching,
  32         Opt_debug,
  33         Opt_nodebug,
  34         Opt_upgrade,
  35         Opt_num_glockd,
  36         Opt_acl,
  37         Opt_noacl,
  38         Opt_quota_off,
  39         Opt_quota_account,
  40         Opt_quota_on,
  41         Opt_suiddir,
  42         Opt_nosuiddir,
  43         Opt_data_writeback,
  44         Opt_data_ordered,
  45         Opt_meta,
  46         Opt_err,
  47 };
  48
  49 static match_table_t tokens = {
  50         {Opt_lockproto, "lockproto=%s"},
  51         {Opt_locktable, "locktable=%s"},
  52         {Opt_hostdata, "hostdata=%s"},
  53         {Opt_spectator, "spectator"},
  54         {Opt_ignore_local_fs, "ignore_local_fs"},
  55         {Opt_localflocks, "localflocks"},
  56         {Opt_localcaching, "localcaching"},
  57         {Opt_debug, "debug"},
  58         {Opt_nodebug, "nodebug"},
  59         {Opt_upgrade, "upgrade"},
  60         {Opt_num_glockd, "num_glockd=%d"},
  61         {Opt_acl, "acl"},
  62         {Opt_noacl, "noacl"},
  63         {Opt_quota_off, "quota=off"},
  64         {Opt_quota_account, "quota=account"},
  65         {Opt_quota_on, "quota=on"},
  66         {Opt_suiddir, "suiddir"},
  67         {Opt_nosuiddir, "nosuiddir"},
  68         {Opt_data_writeback, "data=writeback"},
  69         {Opt_data_ordered, "data=ordered"},
  70         {Opt_meta, "meta"},
  71         {Opt_err, NULL}
  72 };
  73
  74 /**
  75  * gfs2_mount_args - Parse mount options
  76  * @sdp:
  77  * @data:
  78  *
  79  * Return: errno
  80  */
  81
  82 int gfs2_mount_args(struct gfs2_sbd *sdp, char *data_arg, int remount)
  83 {
  84         struct gfs2_args *args = &sdp->sd_args;
  85         char *data = data_arg;
  86         char *options, *o, *v;
  87         int error = 0;
  88
  89         if (!remount) {
  90                 /*  If someone preloaded options, use those instead  */
  91                 spin_lock(&gfs2_sys_margs_lock);
  92                 if (gfs2_sys_margs) {
  93                         data = gfs2_sys_margs;
  94                         gfs2_sys_margs = NULL;
  95                 }
  96                 spin_unlock(&gfs2_sys_margs_lock);
  97
  98                 /*  Set some defaults  */
  99                 args->ar_num_glockd = GFS2_GLOCKD_DEFAULT;
 100                 args->ar_quota = GFS2_QUOTA_DEFAULT;
 101                 args->ar_data = GFS2_DATA_DEFAULT;
 102         }
 103
 104         /* Split the options into tokens with the "," character and
 105            process them */
 106
 107         for (options = data; (o = strsep(&options, ",")); ) {
 108                 int token, option;
 109                 substring_t tmp[MAX_OPT_ARGS];
 110
 111                 if (!*o)
 112                         continue;
 113
 114                 token = match_token(o, tokens, tmp);
 115                 switch (token) {
 116                 case Opt_lockproto:
 117                         v = match_strdup(&tmp[0]);
 118                         if (!v) {
 119                                 fs_info(sdp, "no memory for lockproto\n");
 120                                 error = -ENOMEM;
 121                                 goto out_error;
 122                         }
 123
 124                         if (remount && strcmp(v, args->ar_lockproto)) {
 125                                 kfree(v);
 126                                 goto cant_remount;
 127                         }
 128
 129                         strncpy(args->ar_lockproto, v, GFS2_LOCKNAME_LEN);
 130                         args->ar_lockproto[GFS2_LOCKNAME_LEN - 1] = 0;
 131                         kfree(v);
 132                         break;
 133                 case Opt_locktable:
 134                         v = match_strdup(&tmp[0]);
 135                         if (!v) {
 136                                 fs_info(sdp, "no memory for locktable\n");
 137                                 error = -ENOMEM;
 138                                 goto out_error;
 139                         }
 140
 141                         if (remount && strcmp(v, args->ar_locktable)) {
 142                                 kfree(v);
 143                                 goto cant_remount;
 144                         }
 145
 146                         strncpy(args->ar_locktable, v, GFS2_LOCKNAME_LEN);
 147                         args->ar_locktable[GFS2_LOCKNAME_LEN - 1]  = 0;
 148                         kfree(v);
 149                         break;
 150                 case Opt_hostdata:
 151                         v = match_strdup(&tmp[0]);
 152                         if (!v) {
 153                                 fs_info(sdp, "no memory for hostdata\n");
 154                                 error = -ENOMEM;
 155                                 goto out_error;
 156                         }
 157
 158                         if (remount && strcmp(v, args->ar_hostdata)) {
 159                                 kfree(v);
 160                                 goto cant_remount;
 161                         }
 162
 163                         strncpy(args->ar_hostdata, v, GFS2_LOCKNAME_LEN);
 164                         args->ar_hostdata[GFS2_LOCKNAME_LEN - 1] = 0;
 165                         kfree(v);
 166                         break;
 167                 case Opt_spectator:
 168                         if (remount && !args->ar_spectator)
 169                                 goto cant_remount;
 170                         args->ar_spectator = 1;
 171                         sdp->sd_vfs->s_flags |= MS_RDONLY;
 172                         break;
 173                 case Opt_ignore_local_fs:
 174                         if (remount && !args->ar_ignore_local_fs)
 175                                 goto cant_remount;
 176                         args->ar_ignore_local_fs = 1;
 177                         break;
 178                 case Opt_localflocks:
 179                         if (remount && !args->ar_localflocks)
 180                                 goto cant_remount;
 181                         args->ar_localflocks = 1;
 182                         break;
 183                 case Opt_localcaching:
 184                         if (remount && !args->ar_localcaching)
 185                                 goto cant_remount;
 186                         args->ar_localcaching = 1;
 187                         break;
 188                 case Opt_debug:
 189                         args->ar_debug = 1;
 190                         break;
 191                 case Opt_nodebug:
 192                         args->ar_debug = 0;
 193                         break;
 194                 case Opt_upgrade:
 195                         if (remount && !args->ar_upgrade)
 196                                 goto cant_remount;
 197                         args->ar_upgrade = 1;
 198                         break;
 199                 case Opt_num_glockd:
 200                         if ((error = match_int(&tmp[0], &option))) {
 201                                 fs_info(sdp, "problem getting num_glockd\n");
 202                                 goto out_error;
 203                         }
 204
 205                         if (remount && option != args->ar_num_glockd)
 206                                 goto cant_remount;
 207                         if (!option || option > GFS2_GLOCKD_MAX) {
 208                                 fs_info(sdp, "0 < num_glockd <= %u  (not %u)\n",
 209                                         GFS2_GLOCKD_MAX, option);
 210                                 error = -EINVAL;
 211                                 goto out_error;
 212                         }
 213                         args->ar_num_glockd = option;
 214                         break;
 215                 case Opt_acl:
 216                         args->ar_posix_acl = 1;
 217                         sdp->sd_vfs->s_flags |= MS_POSIXACL;
 218                         break;
 219                 case Opt_noacl:
 220                         args->ar_posix_acl = 0;
 221                         sdp->sd_vfs->s_flags &= ~MS_POSIXACL;
 222                         break;
 223                 case Opt_quota_off:
 224                         args->ar_quota = GFS2_QUOTA_OFF;
 225                         break;
 226                 case Opt_quota_account:
 227                         args->ar_quota = GFS2_QUOTA_ACCOUNT;
 228                         break;
 229                 case Opt_quota_on:
 230                         args->ar_quota = GFS2_QUOTA_ON;
 231                         break;
 232                 case Opt_suiddir:
 233                         args->ar_suiddir = 1;
 234                         break;
 235                 case Opt_nosuiddir:
 236                         args->ar_suiddir = 0;
 237                         break;
 238                 case Opt_data_writeback:
 239                         args->ar_data = GFS2_DATA_WRITEBACK;
 240                         break;
 241                 case Opt_data_ordered:
 242                         args->ar_data = GFS2_DATA_ORDERED;
 243                         break;
 244                 case Opt_meta:
 245                         if (remount && args->ar_meta != 1)
 246                                 goto cant_remount;
 247                         args->ar_meta = 1;
 248                         break;
 249                 case Opt_err:
 250                 default:
 251                         fs_info(sdp, "unknown option: %s\n", o);
 252                         error = -EINVAL;
 253                         goto out_error;
 254                 }
 255         }
 256
 257 out_error:
 258         if (error)
 259                 fs_info(sdp, "invalid mount option(s)\n");
 260
 261         if (data != data_arg)
 262                 kfree(data);
 263
 264         return error;
 265
 266 cant_remount:
 267         fs_info(sdp, "can't remount with option %s\n", o);
 268         return -EINVAL;
 269 }
 270