Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
0004  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
0005  */
0006 
0007 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0008 
0009 #include <linux/sched.h>
0010 #include <linux/slab.h>
0011 #include <linux/spinlock.h>
0012 #include <linux/completion.h>
0013 #include <linux/buffer_head.h>
0014 #include <linux/blkdev.h>
0015 #include <linux/kthread.h>
0016 #include <linux/export.h>
0017 #include <linux/namei.h>
0018 #include <linux/mount.h>
0019 #include <linux/gfs2_ondisk.h>
0020 #include <linux/quotaops.h>
0021 #include <linux/lockdep.h>
0022 #include <linux/module.h>
0023 #include <linux/backing-dev.h>
0024 #include <linux/fs_parser.h>
0025 
0026 #include "gfs2.h"
0027 #include "incore.h"
0028 #include "bmap.h"
0029 #include "glock.h"
0030 #include "glops.h"
0031 #include "inode.h"
0032 #include "recovery.h"
0033 #include "rgrp.h"
0034 #include "super.h"
0035 #include "sys.h"
0036 #include "util.h"
0037 #include "log.h"
0038 #include "quota.h"
0039 #include "dir.h"
0040 #include "meta_io.h"
0041 #include "trace_gfs2.h"
0042 #include "lops.h"
0043 
0044 #define DO 0
0045 #define UNDO 1
0046 
0047 /**
0048  * gfs2_tune_init - Fill a gfs2_tune structure with default values
0049  * @gt: tune
0050  *
0051  */
0052 
0053 static void gfs2_tune_init(struct gfs2_tune *gt)
0054 {
0055     spin_lock_init(&gt->gt_spin);
0056 
0057     gt->gt_quota_warn_period = 10;
0058     gt->gt_quota_scale_num = 1;
0059     gt->gt_quota_scale_den = 1;
0060     gt->gt_new_files_jdata = 0;
0061     gt->gt_max_readahead = BIT(18);
0062     gt->gt_complain_secs = 10;
0063 }
0064 
0065 void free_sbd(struct gfs2_sbd *sdp)
0066 {
0067     if (sdp->sd_lkstats)
0068         free_percpu(sdp->sd_lkstats);
0069     kfree(sdp);
0070 }
0071 
0072 static struct gfs2_sbd *init_sbd(struct super_block *sb)
0073 {
0074     struct gfs2_sbd *sdp;
0075     struct address_space *mapping;
0076 
0077     sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
0078     if (!sdp)
0079         return NULL;
0080 
0081     sdp->sd_vfs = sb;
0082     sdp->sd_lkstats = alloc_percpu(struct gfs2_pcpu_lkstats);
0083     if (!sdp->sd_lkstats)
0084         goto fail;
0085     sb->s_fs_info = sdp;
0086 
0087     set_bit(SDF_NOJOURNALID, &sdp->sd_flags);
0088     gfs2_tune_init(&sdp->sd_tune);
0089 
0090     init_waitqueue_head(&sdp->sd_glock_wait);
0091     init_waitqueue_head(&sdp->sd_async_glock_wait);
0092     atomic_set(&sdp->sd_glock_disposal, 0);
0093     init_completion(&sdp->sd_locking_init);
0094     init_completion(&sdp->sd_wdack);
0095     spin_lock_init(&sdp->sd_statfs_spin);
0096 
0097     spin_lock_init(&sdp->sd_rindex_spin);
0098     sdp->sd_rindex_tree.rb_node = NULL;
0099 
0100     INIT_LIST_HEAD(&sdp->sd_jindex_list);
0101     spin_lock_init(&sdp->sd_jindex_spin);
0102     mutex_init(&sdp->sd_jindex_mutex);
0103     init_completion(&sdp->sd_journal_ready);
0104 
0105     INIT_LIST_HEAD(&sdp->sd_quota_list);
0106     mutex_init(&sdp->sd_quota_mutex);
0107     mutex_init(&sdp->sd_quota_sync_mutex);
0108     init_waitqueue_head(&sdp->sd_quota_wait);
0109     spin_lock_init(&sdp->sd_bitmap_lock);
0110 
0111     INIT_LIST_HEAD(&sdp->sd_sc_inodes_list);
0112 
0113     mapping = &sdp->sd_aspace;
0114 
0115     address_space_init_once(mapping);
0116     mapping->a_ops = &gfs2_rgrp_aops;
0117     mapping->host = sb->s_bdev->bd_inode;
0118     mapping->flags = 0;
0119     mapping_set_gfp_mask(mapping, GFP_NOFS);
0120     mapping->private_data = NULL;
0121     mapping->writeback_index = 0;
0122 
0123     spin_lock_init(&sdp->sd_log_lock);
0124     atomic_set(&sdp->sd_log_pinned, 0);
0125     INIT_LIST_HEAD(&sdp->sd_log_revokes);
0126     INIT_LIST_HEAD(&sdp->sd_log_ordered);
0127     spin_lock_init(&sdp->sd_ordered_lock);
0128 
0129     init_waitqueue_head(&sdp->sd_log_waitq);
0130     init_waitqueue_head(&sdp->sd_logd_waitq);
0131     spin_lock_init(&sdp->sd_ail_lock);
0132     INIT_LIST_HEAD(&sdp->sd_ail1_list);
0133     INIT_LIST_HEAD(&sdp->sd_ail2_list);
0134 
0135     init_rwsem(&sdp->sd_log_flush_lock);
0136     atomic_set(&sdp->sd_log_in_flight, 0);
0137     init_waitqueue_head(&sdp->sd_log_flush_wait);
0138     atomic_set(&sdp->sd_freeze_state, SFS_UNFROZEN);
0139     mutex_init(&sdp->sd_freeze_mutex);
0140 
0141     return sdp;
0142 
0143 fail:
0144     free_sbd(sdp);
0145     return NULL;
0146 }
0147 
0148 /**
0149  * gfs2_check_sb - Check superblock
0150  * @sdp: the filesystem
0151  * @silent: Don't print a message if the check fails
0152  *
0153  * Checks the version code of the FS is one that we understand how to
0154  * read and that the sizes of the various on-disk structures have not
0155  * changed.
0156  */
0157 
0158 static int gfs2_check_sb(struct gfs2_sbd *sdp, int silent)
0159 {
0160     struct gfs2_sb_host *sb = &sdp->sd_sb;
0161 
0162     if (sb->sb_magic != GFS2_MAGIC ||
0163         sb->sb_type != GFS2_METATYPE_SB) {
0164         if (!silent)
0165             pr_warn("not a GFS2 filesystem\n");
0166         return -EINVAL;
0167     }
0168 
0169     if (sb->sb_fs_format < GFS2_FS_FORMAT_MIN ||
0170         sb->sb_fs_format > GFS2_FS_FORMAT_MAX ||
0171         sb->sb_multihost_format != GFS2_FORMAT_MULTI) {
0172         fs_warn(sdp, "Unknown on-disk format, unable to mount\n");
0173         return -EINVAL;
0174     }
0175 
0176     if (sb->sb_bsize < 512 || sb->sb_bsize > PAGE_SIZE ||
0177         (sb->sb_bsize & (sb->sb_bsize - 1))) {
0178         pr_warn("Invalid block size\n");
0179         return -EINVAL;
0180     }
0181 
0182     return 0;
0183 }
0184 
0185 static void end_bio_io_page(struct bio *bio)
0186 {
0187     struct page *page = bio->bi_private;
0188 
0189     if (!bio->bi_status)
0190         SetPageUptodate(page);
0191     else
0192         pr_warn("error %d reading superblock\n", bio->bi_status);
0193     unlock_page(page);
0194 }
0195 
0196 static void gfs2_sb_in(struct gfs2_sbd *sdp, const void *buf)
0197 {
0198     struct gfs2_sb_host *sb = &sdp->sd_sb;
0199     struct super_block *s = sdp->sd_vfs;
0200     const struct gfs2_sb *str = buf;
0201 
0202     sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
0203     sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
0204     sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
0205     sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
0206     sb->sb_bsize = be32_to_cpu(str->sb_bsize);
0207     sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
0208     sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
0209     sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
0210     sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
0211     sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
0212 
0213     memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
0214     memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
0215     memcpy(&s->s_uuid, str->sb_uuid, 16);
0216 }
0217 
0218 /**
0219  * gfs2_read_super - Read the gfs2 super block from disk
0220  * @sdp: The GFS2 super block
0221  * @sector: The location of the super block
0222  * @silent: Don't print a message if the check fails
0223  *
0224  * This uses the bio functions to read the super block from disk
0225  * because we want to be 100% sure that we never read cached data.
0226  * A super block is read twice only during each GFS2 mount and is
0227  * never written to by the filesystem. The first time its read no
0228  * locks are held, and the only details which are looked at are those
0229  * relating to the locking protocol. Once locking is up and working,
0230  * the sb is read again under the lock to establish the location of
0231  * the master directory (contains pointers to journals etc) and the
0232  * root directory.
0233  *
0234  * Returns: 0 on success or error
0235  */
0236 
0237 static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector, int silent)
0238 {
0239     struct super_block *sb = sdp->sd_vfs;
0240     struct gfs2_sb *p;
0241     struct page *page;
0242     struct bio *bio;
0243 
0244     page = alloc_page(GFP_NOFS);
0245     if (unlikely(!page))
0246         return -ENOMEM;
0247 
0248     ClearPageUptodate(page);
0249     ClearPageDirty(page);
0250     lock_page(page);
0251 
0252     bio = bio_alloc(sb->s_bdev, 1, REQ_OP_READ | REQ_META, GFP_NOFS);
0253     bio->bi_iter.bi_sector = sector * (sb->s_blocksize >> 9);
0254     bio_add_page(bio, page, PAGE_SIZE, 0);
0255 
0256     bio->bi_end_io = end_bio_io_page;
0257     bio->bi_private = page;
0258     submit_bio(bio);
0259     wait_on_page_locked(page);
0260     bio_put(bio);
0261     if (!PageUptodate(page)) {
0262         __free_page(page);
0263         return -EIO;
0264     }
0265     p = kmap(page);
0266     gfs2_sb_in(sdp, p);
0267     kunmap(page);
0268     __free_page(page);
0269     return gfs2_check_sb(sdp, silent);
0270 }
0271 
0272 /**
0273  * gfs2_read_sb - Read super block
0274  * @sdp: The GFS2 superblock
0275  * @silent: Don't print message if mount fails
0276  *
0277  */
0278 
0279 static int gfs2_read_sb(struct gfs2_sbd *sdp, int silent)
0280 {
0281     u32 hash_blocks, ind_blocks, leaf_blocks;
0282     u32 tmp_blocks;
0283     unsigned int x;
0284     int error;
0285 
0286     error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
0287     if (error) {
0288         if (!silent)
0289             fs_err(sdp, "can't read superblock\n");
0290         return error;
0291     }
0292 
0293     sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
0294                    GFS2_BASIC_BLOCK_SHIFT;
0295     sdp->sd_fsb2bb = BIT(sdp->sd_fsb2bb_shift);
0296     sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
0297               sizeof(struct gfs2_dinode)) / sizeof(u64);
0298     sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
0299               sizeof(struct gfs2_meta_header)) / sizeof(u64);
0300     sdp->sd_ldptrs = (sdp->sd_sb.sb_bsize -
0301               sizeof(struct gfs2_log_descriptor)) / sizeof(u64);
0302     sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
0303     sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
0304     sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
0305     sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
0306     sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
0307                 sizeof(struct gfs2_meta_header)) /
0308                     sizeof(struct gfs2_quota_change);
0309     sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize -
0310                      sizeof(struct gfs2_meta_header))
0311         * GFS2_NBBY; /* not the rgrp bitmap, subsequent bitmaps only */
0312 
0313     /*
0314      * We always keep at least one block reserved for revokes in
0315      * transactions.  This greatly simplifies allocating additional
0316      * revoke blocks.
0317      */
0318     atomic_set(&sdp->sd_log_revokes_available, sdp->sd_ldptrs);
0319 
0320     /* Compute maximum reservation required to add a entry to a directory */
0321 
0322     hash_blocks = DIV_ROUND_UP(sizeof(u64) * BIT(GFS2_DIR_MAX_DEPTH),
0323                  sdp->sd_jbsize);
0324 
0325     ind_blocks = 0;
0326     for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
0327         tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
0328         ind_blocks += tmp_blocks;
0329     }
0330 
0331     leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
0332 
0333     sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
0334 
0335     sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
0336                 sizeof(struct gfs2_dinode);
0337     sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
0338     for (x = 2;; x++) {
0339         u64 space, d;
0340         u32 m;
0341 
0342         space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
0343         d = space;
0344         m = do_div(d, sdp->sd_inptrs);
0345 
0346         if (d != sdp->sd_heightsize[x - 1] || m)
0347             break;
0348         sdp->sd_heightsize[x] = space;
0349     }
0350     sdp->sd_max_height = x;
0351     sdp->sd_heightsize[x] = ~0;
0352     gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
0353 
0354     sdp->sd_max_dents_per_leaf = (sdp->sd_sb.sb_bsize -
0355                       sizeof(struct gfs2_leaf)) /
0356                      GFS2_MIN_DIRENT_SIZE;
0357     return 0;
0358 }
0359 
0360 static int init_names(struct gfs2_sbd *sdp, int silent)
0361 {
0362     char *proto, *table;
0363     int error = 0;
0364 
0365     proto = sdp->sd_args.ar_lockproto;
0366     table = sdp->sd_args.ar_locktable;
0367 
0368     /*  Try to autodetect  */
0369 
0370     if (!proto[0] || !table[0]) {
0371         error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
0372         if (error)
0373             return error;
0374 
0375         if (!proto[0])
0376             proto = sdp->sd_sb.sb_lockproto;
0377         if (!table[0])
0378             table = sdp->sd_sb.sb_locktable;
0379     }
0380 
0381     if (!table[0])
0382         table = sdp->sd_vfs->s_id;
0383 
0384     strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
0385     strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
0386 
0387     table = sdp->sd_table_name;
0388     while ((table = strchr(table, '/')))
0389         *table = '_';
0390 
0391     return error;
0392 }
0393 
0394 static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
0395             int undo)
0396 {
0397     int error = 0;
0398 
0399     if (undo)
0400         goto fail_trans;
0401 
0402     error = gfs2_glock_nq_num(sdp,
0403                   GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
0404                   LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
0405                   mount_gh);
0406     if (error) {
0407         fs_err(sdp, "can't acquire mount glock: %d\n", error);
0408         goto fail;
0409     }
0410 
0411     error = gfs2_glock_nq_num(sdp,
0412                   GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
0413                   LM_ST_SHARED,
0414                   LM_FLAG_NOEXP | GL_EXACT,
0415                   &sdp->sd_live_gh);
0416     if (error) {
0417         fs_err(sdp, "can't acquire live glock: %d\n", error);
0418         goto fail_mount;
0419     }
0420 
0421     error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
0422                    CREATE, &sdp->sd_rename_gl);
0423     if (error) {
0424         fs_err(sdp, "can't create rename glock: %d\n", error);
0425         goto fail_live;
0426     }
0427 
0428     error = gfs2_glock_get(sdp, GFS2_FREEZE_LOCK, &gfs2_freeze_glops,
0429                    CREATE, &sdp->sd_freeze_gl);
0430     if (error) {
0431         fs_err(sdp, "can't create transaction glock: %d\n", error);
0432         goto fail_rename;
0433     }
0434 
0435     return 0;
0436 
0437 fail_trans:
0438     gfs2_glock_put(sdp->sd_freeze_gl);
0439 fail_rename:
0440     gfs2_glock_put(sdp->sd_rename_gl);
0441 fail_live:
0442     gfs2_glock_dq_uninit(&sdp->sd_live_gh);
0443 fail_mount:
0444     gfs2_glock_dq_uninit(mount_gh);
0445 fail:
0446     return error;
0447 }
0448 
0449 static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
0450                 u64 no_addr, const char *name)
0451 {
0452     struct gfs2_sbd *sdp = sb->s_fs_info;
0453     struct dentry *dentry;
0454     struct inode *inode;
0455 
0456     inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0,
0457                   GFS2_BLKST_FREE /* ignore */);
0458     if (IS_ERR(inode)) {
0459         fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
0460         return PTR_ERR(inode);
0461     }
0462     dentry = d_make_root(inode);
0463     if (!dentry) {
0464         fs_err(sdp, "can't alloc %s dentry\n", name);
0465         return -ENOMEM;
0466     }
0467     *dptr = dentry;
0468     return 0;
0469 }
0470 
0471 static int init_sb(struct gfs2_sbd *sdp, int silent)
0472 {
0473     struct super_block *sb = sdp->sd_vfs;
0474     struct gfs2_holder sb_gh;
0475     u64 no_addr;
0476     int ret;
0477 
0478     ret = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
0479                 LM_ST_SHARED, 0, &sb_gh);
0480     if (ret) {
0481         fs_err(sdp, "can't acquire superblock glock: %d\n", ret);
0482         return ret;
0483     }
0484 
0485     ret = gfs2_read_sb(sdp, silent);
0486     if (ret) {
0487         fs_err(sdp, "can't read superblock: %d\n", ret);
0488         goto out;
0489     }
0490 
0491     switch(sdp->sd_sb.sb_fs_format) {
0492     case GFS2_FS_FORMAT_MAX:
0493         sb->s_xattr = gfs2_xattr_handlers_max;
0494         break;
0495 
0496     case GFS2_FS_FORMAT_MIN:
0497         sb->s_xattr = gfs2_xattr_handlers_min;
0498         break;
0499 
0500     default:
0501         BUG();
0502     }
0503 
0504     /* Set up the buffer cache and SB for real */
0505     if (sdp->sd_sb.sb_bsize < bdev_logical_block_size(sb->s_bdev)) {
0506         ret = -EINVAL;
0507         fs_err(sdp, "FS block size (%u) is too small for device "
0508                "block size (%u)\n",
0509                sdp->sd_sb.sb_bsize, bdev_logical_block_size(sb->s_bdev));
0510         goto out;
0511     }
0512     if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
0513         ret = -EINVAL;
0514         fs_err(sdp, "FS block size (%u) is too big for machine "
0515                "page size (%u)\n",
0516                sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
0517         goto out;
0518     }
0519     sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
0520 
0521     /* Get the root inode */
0522     no_addr = sdp->sd_sb.sb_root_dir.no_addr;
0523     ret = gfs2_lookup_root(sb, &sdp->sd_root_dir, no_addr, "root");
0524     if (ret)
0525         goto out;
0526 
0527     /* Get the master inode */
0528     no_addr = sdp->sd_sb.sb_master_dir.no_addr;
0529     ret = gfs2_lookup_root(sb, &sdp->sd_master_dir, no_addr, "master");
0530     if (ret) {
0531         dput(sdp->sd_root_dir);
0532         goto out;
0533     }
0534     sb->s_root = dget(sdp->sd_args.ar_meta ? sdp->sd_master_dir : sdp->sd_root_dir);
0535 out:
0536     gfs2_glock_dq_uninit(&sb_gh);
0537     return ret;
0538 }
0539 
0540 static void gfs2_others_may_mount(struct gfs2_sbd *sdp)
0541 {
0542     char *message = "FIRSTMOUNT=Done";
0543     char *envp[] = { message, NULL };
0544 
0545     fs_info(sdp, "first mount done, others may mount\n");
0546 
0547     if (sdp->sd_lockstruct.ls_ops->lm_first_done)
0548         sdp->sd_lockstruct.ls_ops->lm_first_done(sdp);
0549 
0550     kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
0551 }
0552 
0553 /**
0554  * gfs2_jindex_hold - Grab a lock on the jindex
0555  * @sdp: The GFS2 superblock
0556  * @ji_gh: the holder for the jindex glock
0557  *
0558  * Returns: errno
0559  */
0560 
0561 static int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
0562 {
0563     struct gfs2_inode *dip = GFS2_I(sdp->sd_jindex);
0564     struct qstr name;
0565     char buf[20];
0566     struct gfs2_jdesc *jd;
0567     int error;
0568 
0569     name.name = buf;
0570 
0571     mutex_lock(&sdp->sd_jindex_mutex);
0572 
0573     for (;;) {
0574         struct gfs2_inode *jip;
0575 
0576         error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, ji_gh);
0577         if (error)
0578             break;
0579 
0580         name.len = sprintf(buf, "journal%u", sdp->sd_journals);
0581         name.hash = gfs2_disk_hash(name.name, name.len);
0582 
0583         error = gfs2_dir_check(sdp->sd_jindex, &name, NULL);
0584         if (error == -ENOENT) {
0585             error = 0;
0586             break;
0587         }
0588 
0589         gfs2_glock_dq_uninit(ji_gh);
0590 
0591         if (error)
0592             break;
0593 
0594         error = -ENOMEM;
0595         jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);
0596         if (!jd)
0597             break;
0598 
0599         INIT_LIST_HEAD(&jd->extent_list);
0600         INIT_LIST_HEAD(&jd->jd_revoke_list);
0601 
0602         INIT_WORK(&jd->jd_work, gfs2_recover_func);
0603         jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1);
0604         if (IS_ERR_OR_NULL(jd->jd_inode)) {
0605             if (!jd->jd_inode)
0606                 error = -ENOENT;
0607             else
0608                 error = PTR_ERR(jd->jd_inode);
0609             kfree(jd);
0610             break;
0611         }
0612 
0613         d_mark_dontcache(jd->jd_inode);
0614         spin_lock(&sdp->sd_jindex_spin);
0615         jd->jd_jid = sdp->sd_journals++;
0616         jip = GFS2_I(jd->jd_inode);
0617         jd->jd_no_addr = jip->i_no_addr;
0618         list_add_tail(&jd->jd_list, &sdp->sd_jindex_list);
0619         spin_unlock(&sdp->sd_jindex_spin);
0620     }
0621 
0622     mutex_unlock(&sdp->sd_jindex_mutex);
0623 
0624     return error;
0625 }
0626 
0627 /**
0628  * init_statfs - look up and initialize master and local (per node) statfs inodes
0629  * @sdp: The GFS2 superblock
0630  *
0631  * This should be called after the jindex is initialized in init_journal() and
0632  * before gfs2_journal_recovery() is called because we need to be able to write
0633  * to these inodes during recovery.
0634  *
0635  * Returns: errno
0636  */
0637 static int init_statfs(struct gfs2_sbd *sdp)
0638 {
0639     int error = 0;
0640     struct inode *master = d_inode(sdp->sd_master_dir);
0641     struct inode *pn = NULL;
0642     char buf[30];
0643     struct gfs2_jdesc *jd;
0644     struct gfs2_inode *ip;
0645 
0646     sdp->sd_statfs_inode = gfs2_lookup_simple(master, "statfs");
0647     if (IS_ERR(sdp->sd_statfs_inode)) {
0648         error = PTR_ERR(sdp->sd_statfs_inode);
0649         fs_err(sdp, "can't read in statfs inode: %d\n", error);
0650         goto out;
0651     }
0652     if (sdp->sd_args.ar_spectator)
0653         goto out;
0654 
0655     pn = gfs2_lookup_simple(master, "per_node");
0656     if (IS_ERR(pn)) {
0657         error = PTR_ERR(pn);
0658         fs_err(sdp, "can't find per_node directory: %d\n", error);
0659         goto put_statfs;
0660     }
0661 
0662     /* For each jid, lookup the corresponding local statfs inode in the
0663      * per_node metafs directory and save it in the sdp->sd_sc_inodes_list. */
0664     list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
0665         struct local_statfs_inode *lsi =
0666             kmalloc(sizeof(struct local_statfs_inode), GFP_NOFS);
0667         if (!lsi) {
0668             error = -ENOMEM;
0669             goto free_local;
0670         }
0671         sprintf(buf, "statfs_change%u", jd->jd_jid);
0672         lsi->si_sc_inode = gfs2_lookup_simple(pn, buf);
0673         if (IS_ERR(lsi->si_sc_inode)) {
0674             error = PTR_ERR(lsi->si_sc_inode);
0675             fs_err(sdp, "can't find local \"sc\" file#%u: %d\n",
0676                    jd->jd_jid, error);
0677             kfree(lsi);
0678             goto free_local;
0679         }
0680         lsi->si_jid = jd->jd_jid;
0681         if (jd->jd_jid == sdp->sd_jdesc->jd_jid)
0682             sdp->sd_sc_inode = lsi->si_sc_inode;
0683 
0684         list_add_tail(&lsi->si_list, &sdp->sd_sc_inodes_list);
0685     }
0686 
0687     iput(pn);
0688     pn = NULL;
0689     ip = GFS2_I(sdp->sd_sc_inode);
0690     error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
0691                    &sdp->sd_sc_gh);
0692     if (error) {
0693         fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
0694         goto free_local;
0695     }
0696     /* read in the local statfs buffer - other nodes don't change it. */
0697     error = gfs2_meta_inode_buffer(ip, &sdp->sd_sc_bh);
0698     if (error) {
0699         fs_err(sdp, "Cannot read in local statfs: %d\n", error);
0700         goto unlock_sd_gh;
0701     }
0702     return 0;
0703 
0704 unlock_sd_gh:
0705     gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
0706 free_local:
0707     free_local_statfs_inodes(sdp);
0708     iput(pn);
0709 put_statfs:
0710     iput(sdp->sd_statfs_inode);
0711 out:
0712     return error;
0713 }
0714 
0715 /* Uninitialize and free up memory used by the list of statfs inodes */
0716 static void uninit_statfs(struct gfs2_sbd *sdp)
0717 {
0718     if (!sdp->sd_args.ar_spectator) {
0719         brelse(sdp->sd_sc_bh);
0720         gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
0721         free_local_statfs_inodes(sdp);
0722     }
0723     iput(sdp->sd_statfs_inode);
0724 }
0725 
0726 static int init_journal(struct gfs2_sbd *sdp, int undo)
0727 {
0728     struct inode *master = d_inode(sdp->sd_master_dir);
0729     struct gfs2_holder ji_gh;
0730     struct gfs2_inode *ip;
0731     int jindex = 1;
0732     int error = 0;
0733 
0734     if (undo) {
0735         jindex = 0;
0736         goto fail_statfs;
0737     }
0738 
0739     sdp->sd_jindex = gfs2_lookup_simple(master, "jindex");
0740     if (IS_ERR(sdp->sd_jindex)) {
0741         fs_err(sdp, "can't lookup journal index: %d\n", error);
0742         return PTR_ERR(sdp->sd_jindex);
0743     }
0744 
0745     /* Load in the journal index special file */
0746 
0747     error = gfs2_jindex_hold(sdp, &ji_gh);
0748     if (error) {
0749         fs_err(sdp, "can't read journal index: %d\n", error);
0750         goto fail;
0751     }
0752 
0753     error = -EUSERS;
0754     if (!gfs2_jindex_size(sdp)) {
0755         fs_err(sdp, "no journals!\n");
0756         goto fail_jindex;
0757     }
0758 
0759     atomic_set(&sdp->sd_log_blks_needed, 0);
0760     if (sdp->sd_args.ar_spectator) {
0761         sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
0762         atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
0763         atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
0764         atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
0765     } else {
0766         if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
0767             fs_err(sdp, "can't mount journal #%u\n",
0768                    sdp->sd_lockstruct.ls_jid);
0769             fs_err(sdp, "there are only %u journals (0 - %u)\n",
0770                    gfs2_jindex_size(sdp),
0771                    gfs2_jindex_size(sdp) - 1);
0772             goto fail_jindex;
0773         }
0774         sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
0775 
0776         error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
0777                       &gfs2_journal_glops,
0778                       LM_ST_EXCLUSIVE,
0779                       LM_FLAG_NOEXP | GL_NOCACHE,
0780                       &sdp->sd_journal_gh);
0781         if (error) {
0782             fs_err(sdp, "can't acquire journal glock: %d\n", error);
0783             goto fail_jindex;
0784         }
0785 
0786         ip = GFS2_I(sdp->sd_jdesc->jd_inode);
0787         sdp->sd_jinode_gl = ip->i_gl;
0788         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
0789                        LM_FLAG_NOEXP | GL_EXACT | GL_NOCACHE,
0790                        &sdp->sd_jinode_gh);
0791         if (error) {
0792             fs_err(sdp, "can't acquire journal inode glock: %d\n",
0793                    error);
0794             goto fail_journal_gh;
0795         }
0796 
0797         error = gfs2_jdesc_check(sdp->sd_jdesc);
0798         if (error) {
0799             fs_err(sdp, "my journal (%u) is bad: %d\n",
0800                    sdp->sd_jdesc->jd_jid, error);
0801             goto fail_jinode_gh;
0802         }
0803         atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
0804         atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
0805         atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
0806 
0807         /* Map the extents for this journal's blocks */
0808         gfs2_map_journal_extents(sdp, sdp->sd_jdesc);
0809     }
0810     trace_gfs2_log_blocks(sdp, atomic_read(&sdp->sd_log_blks_free));
0811 
0812     /* Lookup statfs inodes here so journal recovery can use them. */
0813     error = init_statfs(sdp);
0814     if (error)
0815         goto fail_jinode_gh;
0816 
0817     if (sdp->sd_lockstruct.ls_first) {
0818         unsigned int x;
0819         for (x = 0; x < sdp->sd_journals; x++) {
0820             struct gfs2_jdesc *jd = gfs2_jdesc_find(sdp, x);
0821 
0822             if (sdp->sd_args.ar_spectator) {
0823                 error = check_journal_clean(sdp, jd, true);
0824                 if (error)
0825                     goto fail_statfs;
0826                 continue;
0827             }
0828             error = gfs2_recover_journal(jd, true);
0829             if (error) {
0830                 fs_err(sdp, "error recovering journal %u: %d\n",
0831                        x, error);
0832                 goto fail_statfs;
0833             }
0834         }
0835 
0836         gfs2_others_may_mount(sdp);
0837     } else if (!sdp->sd_args.ar_spectator) {
0838         error = gfs2_recover_journal(sdp->sd_jdesc, true);
0839         if (error) {
0840             fs_err(sdp, "error recovering my journal: %d\n", error);
0841             goto fail_statfs;
0842         }
0843     }
0844 
0845     sdp->sd_log_idle = 1;
0846     set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
0847     gfs2_glock_dq_uninit(&ji_gh);
0848     jindex = 0;
0849     INIT_WORK(&sdp->sd_freeze_work, gfs2_freeze_func);
0850     return 0;
0851 
0852 fail_statfs:
0853     uninit_statfs(sdp);
0854 fail_jinode_gh:
0855     /* A withdraw may have done dq/uninit so now we need to check it */
0856     if (!sdp->sd_args.ar_spectator &&
0857         gfs2_holder_initialized(&sdp->sd_jinode_gh))
0858         gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
0859 fail_journal_gh:
0860     if (!sdp->sd_args.ar_spectator &&
0861         gfs2_holder_initialized(&sdp->sd_journal_gh))
0862         gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
0863 fail_jindex:
0864     gfs2_jindex_free(sdp);
0865     if (jindex)
0866         gfs2_glock_dq_uninit(&ji_gh);
0867 fail:
0868     iput(sdp->sd_jindex);
0869     return error;
0870 }
0871 
0872 static struct lock_class_key gfs2_quota_imutex_key;
0873 
0874 static int init_inodes(struct gfs2_sbd *sdp, int undo)
0875 {
0876     int error = 0;
0877     struct inode *master = d_inode(sdp->sd_master_dir);
0878 
0879     if (undo)
0880         goto fail_qinode;
0881 
0882     error = init_journal(sdp, undo);
0883     complete_all(&sdp->sd_journal_ready);
0884     if (error)
0885         goto fail;
0886 
0887     /* Read in the resource index inode */
0888     sdp->sd_rindex = gfs2_lookup_simple(master, "rindex");
0889     if (IS_ERR(sdp->sd_rindex)) {
0890         error = PTR_ERR(sdp->sd_rindex);
0891         fs_err(sdp, "can't get resource index inode: %d\n", error);
0892         goto fail_journal;
0893     }
0894     sdp->sd_rindex_uptodate = 0;
0895 
0896     /* Read in the quota inode */
0897     sdp->sd_quota_inode = gfs2_lookup_simple(master, "quota");
0898     if (IS_ERR(sdp->sd_quota_inode)) {
0899         error = PTR_ERR(sdp->sd_quota_inode);
0900         fs_err(sdp, "can't get quota file inode: %d\n", error);
0901         goto fail_rindex;
0902     }
0903     /*
0904      * i_rwsem on quota files is special. Since this inode is hidden system
0905      * file, we are safe to define locking ourselves.
0906      */
0907     lockdep_set_class(&sdp->sd_quota_inode->i_rwsem,
0908               &gfs2_quota_imutex_key);
0909 
0910     error = gfs2_rindex_update(sdp);
0911     if (error)
0912         goto fail_qinode;
0913 
0914     return 0;
0915 
0916 fail_qinode:
0917     iput(sdp->sd_quota_inode);
0918 fail_rindex:
0919     gfs2_clear_rgrpd(sdp);
0920     iput(sdp->sd_rindex);
0921 fail_journal:
0922     init_journal(sdp, UNDO);
0923 fail:
0924     return error;
0925 }
0926 
0927 static int init_per_node(struct gfs2_sbd *sdp, int undo)
0928 {
0929     struct inode *pn = NULL;
0930     char buf[30];
0931     int error = 0;
0932     struct gfs2_inode *ip;
0933     struct inode *master = d_inode(sdp->sd_master_dir);
0934 
0935     if (sdp->sd_args.ar_spectator)
0936         return 0;
0937 
0938     if (undo)
0939         goto fail_qc_gh;
0940 
0941     pn = gfs2_lookup_simple(master, "per_node");
0942     if (IS_ERR(pn)) {
0943         error = PTR_ERR(pn);
0944         fs_err(sdp, "can't find per_node directory: %d\n", error);
0945         return error;
0946     }
0947 
0948     sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
0949     sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
0950     if (IS_ERR(sdp->sd_qc_inode)) {
0951         error = PTR_ERR(sdp->sd_qc_inode);
0952         fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
0953         goto fail_ut_i;
0954     }
0955 
0956     iput(pn);
0957     pn = NULL;
0958 
0959     ip = GFS2_I(sdp->sd_qc_inode);
0960     error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
0961                    &sdp->sd_qc_gh);
0962     if (error) {
0963         fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
0964         goto fail_qc_i;
0965     }
0966 
0967     return 0;
0968 
0969 fail_qc_gh:
0970     gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
0971 fail_qc_i:
0972     iput(sdp->sd_qc_inode);
0973 fail_ut_i:
0974     iput(pn);
0975     return error;
0976 }
0977 
0978 static const match_table_t nolock_tokens = {
0979     { Opt_jid, "jid=%d", },
0980     { Opt_err, NULL },
0981 };
0982 
0983 static const struct lm_lockops nolock_ops = {
0984     .lm_proto_name = "lock_nolock",
0985     .lm_put_lock = gfs2_glock_free,
0986     .lm_tokens = &nolock_tokens,
0987 };
0988 
0989 /**
0990  * gfs2_lm_mount - mount a locking protocol
0991  * @sdp: the filesystem
0992  * @silent: if 1, don't complain if the FS isn't a GFS2 fs
0993  *
0994  * Returns: errno
0995  */
0996 
0997 static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
0998 {
0999     const struct lm_lockops *lm;
1000     struct lm_lockstruct *ls = &sdp->sd_lockstruct;
1001     struct gfs2_args *args = &sdp->sd_args;
1002     const char *proto = sdp->sd_proto_name;
1003     const char *table = sdp->sd_table_name;
1004     char *o, *options;
1005     int ret;
1006 
1007     if (!strcmp("lock_nolock", proto)) {
1008         lm = &nolock_ops;
1009         sdp->sd_args.ar_localflocks = 1;
1010 #ifdef CONFIG_GFS2_FS_LOCKING_DLM
1011     } else if (!strcmp("lock_dlm", proto)) {
1012         lm = &gfs2_dlm_ops;
1013 #endif
1014     } else {
1015         pr_info("can't find protocol %s\n", proto);
1016         return -ENOENT;
1017     }
1018 
1019     fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
1020 
1021     ls->ls_ops = lm;
1022     ls->ls_first = 1;
1023 
1024     for (options = args->ar_hostdata; (o = strsep(&options, ":")); ) {
1025         substring_t tmp[MAX_OPT_ARGS];
1026         int token, option;
1027 
1028         if (!o || !*o)
1029             continue;
1030 
1031         token = match_token(o, *lm->lm_tokens, tmp);
1032         switch (token) {
1033         case Opt_jid:
1034             ret = match_int(&tmp[0], &option);
1035             if (ret || option < 0) 
1036                 goto hostdata_error;
1037             if (test_and_clear_bit(SDF_NOJOURNALID, &sdp->sd_flags))
1038                 ls->ls_jid = option;
1039             break;
1040         case Opt_id:
1041         case Opt_nodir:
1042             /* Obsolete, but left for backward compat purposes */
1043             break;
1044         case Opt_first:
1045             ret = match_int(&tmp[0], &option);
1046             if (ret || (option != 0 && option != 1))
1047                 goto hostdata_error;
1048             ls->ls_first = option;
1049             break;
1050         case Opt_err:
1051         default:
1052 hostdata_error:
1053             fs_info(sdp, "unknown hostdata (%s)\n", o);
1054             return -EINVAL;
1055         }
1056     }
1057 
1058     if (lm->lm_mount == NULL) {
1059         fs_info(sdp, "Now mounting FS (format %u)...\n", sdp->sd_sb.sb_fs_format);
1060         complete_all(&sdp->sd_locking_init);
1061         return 0;
1062     }
1063     ret = lm->lm_mount(sdp, table);
1064     if (ret == 0)
1065         fs_info(sdp, "Joined cluster. Now mounting FS (format %u)...\n",
1066                 sdp->sd_sb.sb_fs_format);
1067     complete_all(&sdp->sd_locking_init);
1068     return ret;
1069 }
1070 
1071 void gfs2_lm_unmount(struct gfs2_sbd *sdp)
1072 {
1073     const struct lm_lockops *lm = sdp->sd_lockstruct.ls_ops;
1074     if (likely(!gfs2_withdrawn(sdp)) && lm->lm_unmount)
1075         lm->lm_unmount(sdp);
1076 }
1077 
1078 static int wait_on_journal(struct gfs2_sbd *sdp)
1079 {
1080     if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
1081         return 0;
1082 
1083     return wait_on_bit(&sdp->sd_flags, SDF_NOJOURNALID, TASK_INTERRUPTIBLE)
1084         ? -EINTR : 0;
1085 }
1086 
1087 void gfs2_online_uevent(struct gfs2_sbd *sdp)
1088 {
1089     struct super_block *sb = sdp->sd_vfs;
1090     char ro[20];
1091     char spectator[20];
1092     char *envp[] = { ro, spectator, NULL };
1093     sprintf(ro, "RDONLY=%d", sb_rdonly(sb));
1094     sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
1095     kobject_uevent_env(&sdp->sd_kobj, KOBJ_ONLINE, envp);
1096 }
1097 
1098 static int init_threads(struct gfs2_sbd *sdp)
1099 {
1100     struct task_struct *p;
1101     int error = 0;
1102 
1103     p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
1104     if (IS_ERR(p)) {
1105         error = PTR_ERR(p);
1106         fs_err(sdp, "can't start logd thread: %d\n", error);
1107         return error;
1108     }
1109     sdp->sd_logd_process = p;
1110 
1111     p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
1112     if (IS_ERR(p)) {
1113         error = PTR_ERR(p);
1114         fs_err(sdp, "can't start quotad thread: %d\n", error);
1115         goto fail;
1116     }
1117     sdp->sd_quotad_process = p;
1118     return 0;
1119 
1120 fail:
1121     kthread_stop(sdp->sd_logd_process);
1122     sdp->sd_logd_process = NULL;
1123     return error;
1124 }
1125 
1126 /**
1127  * gfs2_fill_super - Read in superblock
1128  * @sb: The VFS superblock
1129  * @fc: Mount options and flags
1130  *
1131  * Returns: -errno
1132  */
1133 static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
1134 {
1135     struct gfs2_args *args = fc->fs_private;
1136     int silent = fc->sb_flags & SB_SILENT;
1137     struct gfs2_sbd *sdp;
1138     struct gfs2_holder mount_gh;
1139     struct gfs2_holder freeze_gh;
1140     int error;
1141 
1142     sdp = init_sbd(sb);
1143     if (!sdp) {
1144         pr_warn("can't alloc struct gfs2_sbd\n");
1145         return -ENOMEM;
1146     }
1147     sdp->sd_args = *args;
1148 
1149     if (sdp->sd_args.ar_spectator) {
1150                 sb->s_flags |= SB_RDONLY;
1151         set_bit(SDF_RORECOVERY, &sdp->sd_flags);
1152     }
1153     if (sdp->sd_args.ar_posix_acl)
1154         sb->s_flags |= SB_POSIXACL;
1155     if (sdp->sd_args.ar_nobarrier)
1156         set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1157 
1158     sb->s_flags |= SB_NOSEC;
1159     sb->s_magic = GFS2_MAGIC;
1160     sb->s_op = &gfs2_super_ops;
1161     sb->s_d_op = &gfs2_dops;
1162     sb->s_export_op = &gfs2_export_ops;
1163     sb->s_qcop = &gfs2_quotactl_ops;
1164     sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
1165     sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
1166     sb->s_time_gran = 1;
1167     sb->s_maxbytes = MAX_LFS_FILESIZE;
1168 
1169     /* Set up the buffer cache and fill in some fake block size values
1170        to allow us to read-in the on-disk superblock. */
1171     sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
1172     sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
1173     sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
1174                                GFS2_BASIC_BLOCK_SHIFT;
1175     sdp->sd_fsb2bb = BIT(sdp->sd_fsb2bb_shift);
1176 
1177     sdp->sd_tune.gt_logd_secs = sdp->sd_args.ar_commit;
1178     sdp->sd_tune.gt_quota_quantum = sdp->sd_args.ar_quota_quantum;
1179     if (sdp->sd_args.ar_statfs_quantum) {
1180         sdp->sd_tune.gt_statfs_slow = 0;
1181         sdp->sd_tune.gt_statfs_quantum = sdp->sd_args.ar_statfs_quantum;
1182     } else {
1183         sdp->sd_tune.gt_statfs_slow = 1;
1184         sdp->sd_tune.gt_statfs_quantum = 30;
1185     }
1186 
1187     error = init_names(sdp, silent);
1188     if (error)
1189         goto fail_free;
1190 
1191     snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s", sdp->sd_table_name);
1192 
1193     error = gfs2_sys_fs_add(sdp);
1194     if (error)
1195         goto fail_free;
1196 
1197     gfs2_create_debugfs_file(sdp);
1198 
1199     error = gfs2_lm_mount(sdp, silent);
1200     if (error)
1201         goto fail_debug;
1202 
1203     error = init_locking(sdp, &mount_gh, DO);
1204     if (error)
1205         goto fail_lm;
1206 
1207     error = init_sb(sdp, silent);
1208     if (error)
1209         goto fail_locking;
1210 
1211     /* Turn rgrplvb on by default if fs format is recent enough */
1212     if (!sdp->sd_args.ar_got_rgrplvb && sdp->sd_sb.sb_fs_format > 1801)
1213         sdp->sd_args.ar_rgrplvb = 1;
1214 
1215     error = wait_on_journal(sdp);
1216     if (error)
1217         goto fail_sb;
1218 
1219     /*
1220      * If user space has failed to join the cluster or some similar
1221      * failure has occurred, then the journal id will contain a
1222      * negative (error) number. This will then be returned to the
1223      * caller (of the mount syscall). We do this even for spectator
1224      * mounts (which just write a jid of 0 to indicate "ok" even though
1225      * the jid is unused in the spectator case)
1226      */
1227     if (sdp->sd_lockstruct.ls_jid < 0) {
1228         error = sdp->sd_lockstruct.ls_jid;
1229         sdp->sd_lockstruct.ls_jid = 0;
1230         goto fail_sb;
1231     }
1232 
1233     if (sdp->sd_args.ar_spectator)
1234         snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s.s",
1235              sdp->sd_table_name);
1236     else
1237         snprintf(sdp->sd_fsname, sizeof(sdp->sd_fsname), "%s.%u",
1238              sdp->sd_table_name, sdp->sd_lockstruct.ls_jid);
1239 
1240     error = init_inodes(sdp, DO);
1241     if (error)
1242         goto fail_sb;
1243 
1244     error = init_per_node(sdp, DO);
1245     if (error)
1246         goto fail_inodes;
1247 
1248     error = gfs2_statfs_init(sdp);
1249     if (error) {
1250         fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
1251         goto fail_per_node;
1252     }
1253 
1254     if (!sb_rdonly(sb)) {
1255         error = init_threads(sdp);
1256         if (error) {
1257             gfs2_withdraw_delayed(sdp);
1258             goto fail_per_node;
1259         }
1260     }
1261 
1262     error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
1263     if (error)
1264         goto fail_per_node;
1265 
1266     if (!sb_rdonly(sb))
1267         error = gfs2_make_fs_rw(sdp);
1268 
1269     gfs2_freeze_unlock(&freeze_gh);
1270     if (error) {
1271         if (sdp->sd_quotad_process)
1272             kthread_stop(sdp->sd_quotad_process);
1273         sdp->sd_quotad_process = NULL;
1274         if (sdp->sd_logd_process)
1275             kthread_stop(sdp->sd_logd_process);
1276         sdp->sd_logd_process = NULL;
1277         fs_err(sdp, "can't make FS RW: %d\n", error);
1278         goto fail_per_node;
1279     }
1280     gfs2_glock_dq_uninit(&mount_gh);
1281     gfs2_online_uevent(sdp);
1282     return 0;
1283 
1284 fail_per_node:
1285     init_per_node(sdp, UNDO);
1286 fail_inodes:
1287     init_inodes(sdp, UNDO);
1288 fail_sb:
1289     if (sdp->sd_root_dir)
1290         dput(sdp->sd_root_dir);
1291     if (sdp->sd_master_dir)
1292         dput(sdp->sd_master_dir);
1293     if (sb->s_root)
1294         dput(sb->s_root);
1295     sb->s_root = NULL;
1296 fail_locking:
1297     init_locking(sdp, &mount_gh, UNDO);
1298 fail_lm:
1299     complete_all(&sdp->sd_journal_ready);
1300     gfs2_gl_hash_clear(sdp);
1301     gfs2_lm_unmount(sdp);
1302 fail_debug:
1303     gfs2_delete_debugfs_file(sdp);
1304     gfs2_sys_fs_del(sdp);
1305 fail_free:
1306     free_sbd(sdp);
1307     sb->s_fs_info = NULL;
1308     return error;
1309 }
1310 
1311 /**
1312  * gfs2_get_tree - Get the GFS2 superblock and root directory
1313  * @fc: The filesystem context
1314  *
1315  * Returns: 0 or -errno on error
1316  */
1317 static int gfs2_get_tree(struct fs_context *fc)
1318 {
1319     struct gfs2_args *args = fc->fs_private;
1320     struct gfs2_sbd *sdp;
1321     int error;
1322 
1323     error = get_tree_bdev(fc, gfs2_fill_super);
1324     if (error)
1325         return error;
1326 
1327     sdp = fc->root->d_sb->s_fs_info;
1328     dput(fc->root);
1329     if (args->ar_meta)
1330         fc->root = dget(sdp->sd_master_dir);
1331     else
1332         fc->root = dget(sdp->sd_root_dir);
1333     return 0;
1334 }
1335 
1336 static void gfs2_fc_free(struct fs_context *fc)
1337 {
1338     struct gfs2_args *args = fc->fs_private;
1339 
1340     kfree(args);
1341 }
1342 
1343 enum gfs2_param {
1344     Opt_lockproto,
1345     Opt_locktable,
1346     Opt_hostdata,
1347     Opt_spectator,
1348     Opt_ignore_local_fs,
1349     Opt_localflocks,
1350     Opt_localcaching,
1351     Opt_debug,
1352     Opt_upgrade,
1353     Opt_acl,
1354     Opt_quota,
1355     Opt_quota_flag,
1356     Opt_suiddir,
1357     Opt_data,
1358     Opt_meta,
1359     Opt_discard,
1360     Opt_commit,
1361     Opt_errors,
1362     Opt_statfs_quantum,
1363     Opt_statfs_percent,
1364     Opt_quota_quantum,
1365     Opt_barrier,
1366     Opt_rgrplvb,
1367     Opt_loccookie,
1368 };
1369 
1370 static const struct constant_table gfs2_param_quota[] = {
1371     {"off",        GFS2_QUOTA_OFF},
1372     {"account",    GFS2_QUOTA_ACCOUNT},
1373     {"on",         GFS2_QUOTA_ON},
1374     {}
1375 };
1376 
1377 enum opt_data {
1378     Opt_data_writeback = GFS2_DATA_WRITEBACK,
1379     Opt_data_ordered   = GFS2_DATA_ORDERED,
1380 };
1381 
1382 static const struct constant_table gfs2_param_data[] = {
1383     {"writeback",  Opt_data_writeback },
1384     {"ordered",    Opt_data_ordered },
1385     {}
1386 };
1387 
1388 enum opt_errors {
1389     Opt_errors_withdraw = GFS2_ERRORS_WITHDRAW,
1390     Opt_errors_panic    = GFS2_ERRORS_PANIC,
1391 };
1392 
1393 static const struct constant_table gfs2_param_errors[] = {
1394     {"withdraw",   Opt_errors_withdraw },
1395     {"panic",      Opt_errors_panic },
1396     {}
1397 };
1398 
1399 static const struct fs_parameter_spec gfs2_fs_parameters[] = {
1400     fsparam_string ("lockproto",          Opt_lockproto),
1401     fsparam_string ("locktable",          Opt_locktable),
1402     fsparam_string ("hostdata",           Opt_hostdata),
1403     fsparam_flag   ("spectator",          Opt_spectator),
1404     fsparam_flag   ("norecovery",         Opt_spectator),
1405     fsparam_flag   ("ignore_local_fs",    Opt_ignore_local_fs),
1406     fsparam_flag   ("localflocks",        Opt_localflocks),
1407     fsparam_flag   ("localcaching",       Opt_localcaching),
1408     fsparam_flag_no("debug",              Opt_debug),
1409     fsparam_flag   ("upgrade",            Opt_upgrade),
1410     fsparam_flag_no("acl",                Opt_acl),
1411     fsparam_flag_no("suiddir",            Opt_suiddir),
1412     fsparam_enum   ("data",               Opt_data, gfs2_param_data),
1413     fsparam_flag   ("meta",               Opt_meta),
1414     fsparam_flag_no("discard",            Opt_discard),
1415     fsparam_s32    ("commit",             Opt_commit),
1416     fsparam_enum   ("errors",             Opt_errors, gfs2_param_errors),
1417     fsparam_s32    ("statfs_quantum",     Opt_statfs_quantum),
1418     fsparam_s32    ("statfs_percent",     Opt_statfs_percent),
1419     fsparam_s32    ("quota_quantum",      Opt_quota_quantum),
1420     fsparam_flag_no("barrier",            Opt_barrier),
1421     fsparam_flag_no("rgrplvb",            Opt_rgrplvb),
1422     fsparam_flag_no("loccookie",          Opt_loccookie),
1423     /* quota can be a flag or an enum so it gets special treatment */
1424     fsparam_flag_no("quota",          Opt_quota_flag),
1425     fsparam_enum("quota",             Opt_quota, gfs2_param_quota),
1426     {}
1427 };
1428 
1429 /* Parse a single mount parameter */
1430 static int gfs2_parse_param(struct fs_context *fc, struct fs_parameter *param)
1431 {
1432     struct gfs2_args *args = fc->fs_private;
1433     struct fs_parse_result result;
1434     int o;
1435 
1436     o = fs_parse(fc, gfs2_fs_parameters, param, &result);
1437     if (o < 0)
1438         return o;
1439 
1440     switch (o) {
1441     case Opt_lockproto:
1442         strlcpy(args->ar_lockproto, param->string, GFS2_LOCKNAME_LEN);
1443         break;
1444     case Opt_locktable:
1445         strlcpy(args->ar_locktable, param->string, GFS2_LOCKNAME_LEN);
1446         break;
1447     case Opt_hostdata:
1448         strlcpy(args->ar_hostdata, param->string, GFS2_LOCKNAME_LEN);
1449         break;
1450     case Opt_spectator:
1451         args->ar_spectator = 1;
1452         break;
1453     case Opt_ignore_local_fs:
1454         /* Retained for backwards compat only */
1455         break;
1456     case Opt_localflocks:
1457         args->ar_localflocks = 1;
1458         break;
1459     case Opt_localcaching:
1460         /* Retained for backwards compat only */
1461         break;
1462     case Opt_debug:
1463         if (result.boolean && args->ar_errors == GFS2_ERRORS_PANIC)
1464             return invalfc(fc, "-o debug and -o errors=panic are mutually exclusive");
1465         args->ar_debug = result.boolean;
1466         break;
1467     case Opt_upgrade:
1468         /* Retained for backwards compat only */
1469         break;
1470     case Opt_acl:
1471         args->ar_posix_acl = result.boolean;
1472         break;
1473     case Opt_quota_flag:
1474         args->ar_quota = result.negated ? GFS2_QUOTA_OFF : GFS2_QUOTA_ON;
1475         break;
1476     case Opt_quota:
1477         args->ar_quota = result.int_32;
1478         break;
1479     case Opt_suiddir:
1480         args->ar_suiddir = result.boolean;
1481         break;
1482     case Opt_data:
1483         /* The uint_32 result maps directly to GFS2_DATA_* */
1484         args->ar_data = result.uint_32;
1485         break;
1486     case Opt_meta:
1487         args->ar_meta = 1;
1488         break;
1489     case Opt_discard:
1490         args->ar_discard = result.boolean;
1491         break;
1492     case Opt_commit:
1493         if (result.int_32 <= 0)
1494             return invalfc(fc, "commit mount option requires a positive numeric argument");
1495         args->ar_commit = result.int_32;
1496         break;
1497     case Opt_statfs_quantum:
1498         if (result.int_32 < 0)
1499             return invalfc(fc, "statfs_quantum mount option requires a non-negative numeric argument");
1500         args->ar_statfs_quantum = result.int_32;
1501         break;
1502     case Opt_quota_quantum:
1503         if (result.int_32 <= 0)
1504             return invalfc(fc, "quota_quantum mount option requires a positive numeric argument");
1505         args->ar_quota_quantum = result.int_32;
1506         break;
1507     case Opt_statfs_percent:
1508         if (result.int_32 < 0 || result.int_32 > 100)
1509             return invalfc(fc, "statfs_percent mount option requires a numeric argument between 0 and 100");
1510         args->ar_statfs_percent = result.int_32;
1511         break;
1512     case Opt_errors:
1513         if (args->ar_debug && result.uint_32 == GFS2_ERRORS_PANIC)
1514             return invalfc(fc, "-o debug and -o errors=panic are mutually exclusive");
1515         args->ar_errors = result.uint_32;
1516         break;
1517     case Opt_barrier:
1518         args->ar_nobarrier = result.boolean;
1519         break;
1520     case Opt_rgrplvb:
1521         args->ar_rgrplvb = result.boolean;
1522         args->ar_got_rgrplvb = 1;
1523         break;
1524     case Opt_loccookie:
1525         args->ar_loccookie = result.boolean;
1526         break;
1527     default:
1528         return invalfc(fc, "invalid mount option: %s", param->key);
1529     }
1530     return 0;
1531 }
1532 
1533 static int gfs2_reconfigure(struct fs_context *fc)
1534 {
1535     struct super_block *sb = fc->root->d_sb;
1536     struct gfs2_sbd *sdp = sb->s_fs_info;
1537     struct gfs2_args *oldargs = &sdp->sd_args;
1538     struct gfs2_args *newargs = fc->fs_private;
1539     struct gfs2_tune *gt = &sdp->sd_tune;
1540     int error = 0;
1541 
1542     sync_filesystem(sb);
1543 
1544     spin_lock(&gt->gt_spin);
1545     oldargs->ar_commit = gt->gt_logd_secs;
1546     oldargs->ar_quota_quantum = gt->gt_quota_quantum;
1547     if (gt->gt_statfs_slow)
1548         oldargs->ar_statfs_quantum = 0;
1549     else
1550         oldargs->ar_statfs_quantum = gt->gt_statfs_quantum;
1551     spin_unlock(&gt->gt_spin);
1552 
1553     if (strcmp(newargs->ar_lockproto, oldargs->ar_lockproto)) {
1554         errorfc(fc, "reconfiguration of locking protocol not allowed");
1555         return -EINVAL;
1556     }
1557     if (strcmp(newargs->ar_locktable, oldargs->ar_locktable)) {
1558         errorfc(fc, "reconfiguration of lock table not allowed");
1559         return -EINVAL;
1560     }
1561     if (strcmp(newargs->ar_hostdata, oldargs->ar_hostdata)) {
1562         errorfc(fc, "reconfiguration of host data not allowed");
1563         return -EINVAL;
1564     }
1565     if (newargs->ar_spectator != oldargs->ar_spectator) {
1566         errorfc(fc, "reconfiguration of spectator mode not allowed");
1567         return -EINVAL;
1568     }
1569     if (newargs->ar_localflocks != oldargs->ar_localflocks) {
1570         errorfc(fc, "reconfiguration of localflocks not allowed");
1571         return -EINVAL;
1572     }
1573     if (newargs->ar_meta != oldargs->ar_meta) {
1574         errorfc(fc, "switching between gfs2 and gfs2meta not allowed");
1575         return -EINVAL;
1576     }
1577     if (oldargs->ar_spectator)
1578         fc->sb_flags |= SB_RDONLY;
1579 
1580     if ((sb->s_flags ^ fc->sb_flags) & SB_RDONLY) {
1581         struct gfs2_holder freeze_gh;
1582 
1583         error = gfs2_freeze_lock(sdp, &freeze_gh, 0);
1584         if (error)
1585             return -EINVAL;
1586 
1587         if (fc->sb_flags & SB_RDONLY) {
1588             gfs2_make_fs_ro(sdp);
1589         } else {
1590             error = gfs2_make_fs_rw(sdp);
1591             if (error)
1592                 errorfc(fc, "unable to remount read-write");
1593         }
1594         gfs2_freeze_unlock(&freeze_gh);
1595     }
1596     sdp->sd_args = *newargs;
1597 
1598     if (sdp->sd_args.ar_posix_acl)
1599         sb->s_flags |= SB_POSIXACL;
1600     else
1601         sb->s_flags &= ~SB_POSIXACL;
1602     if (sdp->sd_args.ar_nobarrier)
1603         set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1604     else
1605         clear_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1606     spin_lock(&gt->gt_spin);
1607     gt->gt_logd_secs = newargs->ar_commit;
1608     gt->gt_quota_quantum = newargs->ar_quota_quantum;
1609     if (newargs->ar_statfs_quantum) {
1610         gt->gt_statfs_slow = 0;
1611         gt->gt_statfs_quantum = newargs->ar_statfs_quantum;
1612     }
1613     else {
1614         gt->gt_statfs_slow = 1;
1615         gt->gt_statfs_quantum = 30;
1616     }
1617     spin_unlock(&gt->gt_spin);
1618 
1619     gfs2_online_uevent(sdp);
1620     return error;
1621 }
1622 
1623 static const struct fs_context_operations gfs2_context_ops = {
1624     .free        = gfs2_fc_free,
1625     .parse_param = gfs2_parse_param,
1626     .get_tree    = gfs2_get_tree,
1627     .reconfigure = gfs2_reconfigure,
1628 };
1629 
1630 /* Set up the filesystem mount context */
1631 static int gfs2_init_fs_context(struct fs_context *fc)
1632 {
1633     struct gfs2_args *args;
1634 
1635     args = kmalloc(sizeof(*args), GFP_KERNEL);
1636     if (args == NULL)
1637         return -ENOMEM;
1638 
1639     if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
1640         struct gfs2_sbd *sdp = fc->root->d_sb->s_fs_info;
1641 
1642         *args = sdp->sd_args;
1643     } else {
1644         memset(args, 0, sizeof(*args));
1645         args->ar_quota = GFS2_QUOTA_DEFAULT;
1646         args->ar_data = GFS2_DATA_DEFAULT;
1647         args->ar_commit = 30;
1648         args->ar_statfs_quantum = 30;
1649         args->ar_quota_quantum = 60;
1650         args->ar_errors = GFS2_ERRORS_DEFAULT;
1651     }
1652     fc->fs_private = args;
1653     fc->ops = &gfs2_context_ops;
1654     return 0;
1655 }
1656 
1657 static int set_meta_super(struct super_block *s, struct fs_context *fc)
1658 {
1659     return -EINVAL;
1660 }
1661 
1662 static int test_meta_super(struct super_block *s, struct fs_context *fc)
1663 {
1664     return (fc->sget_key == s->s_bdev);
1665 }
1666 
1667 static int gfs2_meta_get_tree(struct fs_context *fc)
1668 {
1669     struct super_block *s;
1670     struct gfs2_sbd *sdp;
1671     struct path path;
1672     int error;
1673 
1674     if (!fc->source || !*fc->source)
1675         return -EINVAL;
1676 
1677     error = kern_path(fc->source, LOOKUP_FOLLOW, &path);
1678     if (error) {
1679         pr_warn("path_lookup on %s returned error %d\n",
1680                 fc->source, error);
1681         return error;
1682     }
1683     fc->fs_type = &gfs2_fs_type;
1684     fc->sget_key = path.dentry->d_sb->s_bdev;
1685     s = sget_fc(fc, test_meta_super, set_meta_super);
1686     path_put(&path);
1687     if (IS_ERR(s)) {
1688         pr_warn("gfs2 mount does not exist\n");
1689         return PTR_ERR(s);
1690     }
1691     if ((fc->sb_flags ^ s->s_flags) & SB_RDONLY) {
1692         deactivate_locked_super(s);
1693         return -EBUSY;
1694     }
1695     sdp = s->s_fs_info;
1696     fc->root = dget(sdp->sd_master_dir);
1697     return 0;
1698 }
1699 
1700 static const struct fs_context_operations gfs2_meta_context_ops = {
1701     .free        = gfs2_fc_free,
1702     .get_tree    = gfs2_meta_get_tree,
1703 };
1704 
1705 static int gfs2_meta_init_fs_context(struct fs_context *fc)
1706 {
1707     int ret = gfs2_init_fs_context(fc);
1708 
1709     if (ret)
1710         return ret;
1711 
1712     fc->ops = &gfs2_meta_context_ops;
1713     return 0;
1714 }
1715 
1716 static void gfs2_kill_sb(struct super_block *sb)
1717 {
1718     struct gfs2_sbd *sdp = sb->s_fs_info;
1719 
1720     if (sdp == NULL) {
1721         kill_block_super(sb);
1722         return;
1723     }
1724 
1725     gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_SYNC | GFS2_LFC_KILL_SB);
1726     dput(sdp->sd_root_dir);
1727     dput(sdp->sd_master_dir);
1728     sdp->sd_root_dir = NULL;
1729     sdp->sd_master_dir = NULL;
1730     shrink_dcache_sb(sb);
1731     kill_block_super(sb);
1732 }
1733 
1734 struct file_system_type gfs2_fs_type = {
1735     .name = "gfs2",
1736     .fs_flags = FS_REQUIRES_DEV,
1737     .init_fs_context = gfs2_init_fs_context,
1738     .parameters = gfs2_fs_parameters,
1739     .kill_sb = gfs2_kill_sb,
1740     .owner = THIS_MODULE,
1741 };
1742 MODULE_ALIAS_FS("gfs2");
1743 
1744 struct file_system_type gfs2meta_fs_type = {
1745     .name = "gfs2meta",
1746     .fs_flags = FS_REQUIRES_DEV,
1747     .init_fs_context = gfs2_meta_init_fs_context,
1748     .owner = THIS_MODULE,
1749 };
1750 MODULE_ALIAS_FS("gfs2meta");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!