2006-01-16 16:50:04 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2008-01-31 16:31:39 +00:00
|
|
|
* Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
|
2006-01-16 16:50:04 +00:00
|
|
|
*
|
|
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
2006-09-01 15:05:15 +00:00
|
|
|
* of the GNU General Public License version 2.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/kthread.h>
|
2006-08-25 16:13:37 +00:00
|
|
|
#include <linux/namei.h>
|
|
|
|
#include <linux/mount.h>
|
2006-02-27 22:23:27 +00:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-09-19 05:56:29 +00:00
|
|
|
#include <linux/lm_interface.h>
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "incore.h"
|
2007-12-12 00:49:21 +00:00
|
|
|
#include "bmap.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "daemon.h"
|
|
|
|
#include "glock.h"
|
|
|
|
#include "glops.h"
|
|
|
|
#include "inode.h"
|
|
|
|
#include "mount.h"
|
|
|
|
#include "ops_fstype.h"
|
2007-07-31 10:31:12 +00:00
|
|
|
#include "ops_dentry.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "ops_super.h"
|
|
|
|
#include "recovery.h"
|
|
|
|
#include "rgrp.h"
|
|
|
|
#include "super.h"
|
|
|
|
#include "sys.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "util.h"
|
2007-08-16 15:03:57 +00:00
|
|
|
#include "log.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
#define DO 0
|
|
|
|
#define UNDO 1
|
|
|
|
|
|
|
|
static struct gfs2_sbd *init_sbd(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp;
|
|
|
|
|
2006-09-07 18:40:21 +00:00
|
|
|
sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!sdp)
|
|
|
|
return NULL;
|
|
|
|
|
2006-02-27 22:23:27 +00:00
|
|
|
sb->s_fs_info = sdp;
|
2006-01-16 16:50:04 +00:00
|
|
|
sdp->sd_vfs = sb;
|
|
|
|
|
|
|
|
gfs2_tune_init(&sdp->sd_tune);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_reclaim_list);
|
|
|
|
spin_lock_init(&sdp->sd_reclaim_lock);
|
|
|
|
init_waitqueue_head(&sdp->sd_reclaim_wq);
|
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_init(&sdp->sd_inum_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
spin_lock_init(&sdp->sd_statfs_spin);
|
|
|
|
|
|
|
|
spin_lock_init(&sdp->sd_rindex_spin);
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_init(&sdp->sd_rindex_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
INIT_LIST_HEAD(&sdp->sd_rindex_list);
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_rindex_mru_list);
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_rindex_recent_list);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_jindex_list);
|
|
|
|
spin_lock_init(&sdp->sd_jindex_spin);
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_init(&sdp->sd_jindex_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_quota_list);
|
|
|
|
spin_lock_init(&sdp->sd_quota_spin);
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_init(&sdp->sd_quota_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
spin_lock_init(&sdp->sd_log_lock);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_log_le_buf);
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_log_le_revoke);
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_log_le_rg);
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_log_le_databuf);
|
2007-09-02 09:48:13 +00:00
|
|
|
INIT_LIST_HEAD(&sdp->sd_log_le_ordered);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-03-28 19:14:04 +00:00
|
|
|
mutex_init(&sdp->sd_log_reserve_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
INIT_LIST_HEAD(&sdp->sd_ail1_list);
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_ail2_list);
|
|
|
|
|
2006-03-29 14:12:12 +00:00
|
|
|
init_rwsem(&sdp->sd_log_flush_lock);
|
2007-09-17 09:59:52 +00:00
|
|
|
atomic_set(&sdp->sd_log_in_flight, 0);
|
|
|
|
init_waitqueue_head(&sdp->sd_log_flush_wait);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&sdp->sd_revoke_list);
|
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_init(&sdp->sd_freeze_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
return sdp;
|
|
|
|
}
|
|
|
|
|
2006-03-02 21:33:41 +00:00
|
|
|
static void init_vfs(struct super_block *sb, unsigned noatime)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-03-02 21:33:41 +00:00
|
|
|
struct gfs2_sbd *sdp = sb->s_fs_info;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
sb->s_magic = GFS2_MAGIC;
|
|
|
|
sb->s_op = &gfs2_super_ops;
|
|
|
|
sb->s_export_op = &gfs2_export_ops;
|
2007-06-05 08:39:18 +00:00
|
|
|
sb->s_time_gran = 1;
|
2006-01-16 16:50:04 +00:00
|
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
|
|
|
|
|
|
|
if (sb->s_flags & (MS_NOATIME | MS_NODIRATIME))
|
2006-03-02 21:33:41 +00:00
|
|
|
set_bit(noatime, &sdp->sd_flags);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* Don't let the VFS update atimes. GFS2 handles this itself. */
|
|
|
|
sb->s_flags |= MS_NOATIME | MS_NODIRATIME;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int init_names(struct gfs2_sbd *sdp, int silent)
|
|
|
|
{
|
|
|
|
char *proto, *table;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
proto = sdp->sd_args.ar_lockproto;
|
|
|
|
table = sdp->sd_args.ar_locktable;
|
|
|
|
|
|
|
|
/* Try to autodetect */
|
|
|
|
|
|
|
|
if (!proto[0] || !table[0]) {
|
2007-06-01 13:11:58 +00:00
|
|
|
error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2006-10-02 15:49:41 +00:00
|
|
|
|
|
|
|
error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (!proto[0])
|
2006-10-02 15:49:41 +00:00
|
|
|
proto = sdp->sd_sb.sb_lockproto;
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!table[0])
|
2006-10-02 15:49:41 +00:00
|
|
|
table = sdp->sd_sb.sb_locktable;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!table[0])
|
|
|
|
table = sdp->sd_vfs->s_id;
|
|
|
|
|
|
|
|
snprintf(sdp->sd_proto_name, GFS2_FSNAME_LEN, "%s", proto);
|
|
|
|
snprintf(sdp->sd_table_name, GFS2_FSNAME_LEN, "%s", table);
|
|
|
|
|
2007-08-13 03:01:58 +00:00
|
|
|
table = sdp->sd_table_name;
|
|
|
|
while ((table = strchr(table, '/')))
|
2007-06-07 14:10:01 +00:00
|
|
|
*table = '_';
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
out:
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
|
|
|
|
int undo)
|
|
|
|
{
|
|
|
|
struct task_struct *p;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (undo)
|
|
|
|
goto fail_trans;
|
|
|
|
|
|
|
|
for (sdp->sd_glockd_num = 0;
|
|
|
|
sdp->sd_glockd_num < sdp->sd_args.ar_num_glockd;
|
|
|
|
sdp->sd_glockd_num++) {
|
|
|
|
p = kthread_run(gfs2_glockd, sdp, "gfs2_glockd");
|
|
|
|
error = IS_ERR(p);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't start glockd thread: %d\n", error);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
sdp->sd_glockd_process[sdp->sd_glockd_num] = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_glock_nq_num(sdp,
|
|
|
|
GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
|
|
|
|
LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
|
|
|
|
mount_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't acquire mount glock: %d\n", error);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_glock_nq_num(sdp,
|
|
|
|
GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
|
|
|
|
LM_ST_SHARED,
|
2006-04-26 18:58:26 +00:00
|
|
|
LM_FLAG_NOEXP | GL_EXACT,
|
2006-01-16 16:50:04 +00:00
|
|
|
&sdp->sd_live_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't acquire live glock: %d\n", error);
|
|
|
|
goto fail_mount;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
|
|
|
|
CREATE, &sdp->sd_rename_gl);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't create rename glock: %d\n", error);
|
|
|
|
goto fail_live;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_glock_get(sdp, GFS2_TRANS_LOCK, &gfs2_trans_glops,
|
|
|
|
CREATE, &sdp->sd_trans_gl);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't create transaction glock: %d\n", error);
|
|
|
|
goto fail_rename;
|
|
|
|
}
|
|
|
|
set_bit(GLF_STICKY, &sdp->sd_trans_gl->gl_flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
fail_trans:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_put(sdp->sd_trans_gl);
|
2006-06-14 19:32:57 +00:00
|
|
|
fail_rename:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_put(sdp->sd_rename_gl);
|
2006-06-14 19:32:57 +00:00
|
|
|
fail_live:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&sdp->sd_live_gh);
|
2006-06-14 19:32:57 +00:00
|
|
|
fail_mount:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(mount_gh);
|
2006-06-14 19:32:57 +00:00
|
|
|
fail:
|
2006-01-16 16:50:04 +00:00
|
|
|
while (sdp->sd_glockd_num--)
|
|
|
|
kthread_stop(sdp->sd_glockd_process[sdp->sd_glockd_num]);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-05-15 14:37:50 +00:00
|
|
|
static inline struct inode *gfs2_lookup_root(struct super_block *sb,
|
|
|
|
u64 no_addr)
|
2006-01-30 18:34:10 +00:00
|
|
|
{
|
[GFS2] Alternate gfs2_iget to avoid looking up inodes being freed
There is a possible deadlock between two processes on the same node, where one
process is deleting an inode, and another process is looking for allocated but
unused inodes to delete in order to create more space.
process A does an iput() on inode X, and it's i_count drops to 0. This causes
iput_final() to be called, which puts an inode into state I_FREEING at
generic_delete_inode(). There no point between when iput_final() is called, and
when I_FREEING is set where GFS2 could acquire any glocks. Once I_FREEING is
set, no other process on that node can successfully look up that inode until
the delete finishes.
process B locks the the resource group for the same inode in get_local_rgrp(),
which is called by gfs2_inplace_reserve_i()
process A tries to lock the resource group for the inode in
gfs2_dinode_dealloc(), but it's already locked by process B
process B waits in find_inode for the inode to have the I_FREEING state cleared.
Deadlock.
This patch solves the problem by adding an alternative to gfs2_iget(),
gfs2_iget_skip(), that simply skips any inodes that are in the I_FREEING
state.o The alternate test function is just like the original one, except that
it fails if the inode is being freed, and sets a skipped flag. The alternate
set function is just like the original, except that it fails if the skipped
flag is set. Only try_rgrp_unlink() calls gfs2_iget_skip() instead of
gfs2_iget().
Signed-off-by: Benjamin E. Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-09-18 18:33:18 +00:00
|
|
|
return gfs2_inode_lookup(sb, DT_DIR, no_addr, 0, 0);
|
2006-01-30 18:34:10 +00:00
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
static int init_sb(struct gfs2_sbd *sdp, int silent, int undo)
|
|
|
|
{
|
|
|
|
struct super_block *sb = sdp->sd_vfs;
|
|
|
|
struct gfs2_holder sb_gh;
|
2007-05-15 14:37:50 +00:00
|
|
|
u64 no_addr;
|
2006-01-30 18:34:10 +00:00
|
|
|
struct inode *inode;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (undo) {
|
2006-08-10 16:08:40 +00:00
|
|
|
if (sb->s_root) {
|
|
|
|
dput(sb->s_root);
|
|
|
|
sb->s_root = NULL;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
error = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
|
2006-01-16 16:50:04 +00:00
|
|
|
LM_ST_SHARED, 0, &sb_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't acquire superblock glock: %d\n", error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_read_sb(sdp, sb_gh.gh_gl, silent);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't read superblock: %d\n", error);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up the buffer cache and SB for real */
|
|
|
|
if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) {
|
2006-03-02 21:33:41 +00:00
|
|
|
error = -EINVAL;
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "FS block size (%u) is too small for device "
|
|
|
|
"block size (%u)\n",
|
|
|
|
sdp->sd_sb.sb_bsize, bdev_hardsect_size(sb->s_bdev));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
|
2006-03-02 21:33:41 +00:00
|
|
|
error = -EINVAL;
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "FS block size (%u) is too big for machine "
|
|
|
|
"page size (%u)\n",
|
|
|
|
sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
|
|
|
|
|
2006-01-30 18:34:10 +00:00
|
|
|
/* Get the root inode */
|
2007-05-15 14:37:50 +00:00
|
|
|
no_addr = sdp->sd_sb.sb_root_dir.no_addr;
|
2006-03-02 21:33:41 +00:00
|
|
|
if (sb->s_type == &gfs2meta_fs_type)
|
2007-05-15 14:37:50 +00:00
|
|
|
no_addr = sdp->sd_sb.sb_master_dir.no_addr;
|
|
|
|
inode = gfs2_lookup_root(sb, no_addr);
|
2006-03-01 20:31:02 +00:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
error = PTR_ERR(inode);
|
2006-01-30 18:34:10 +00:00
|
|
|
fs_err(sdp, "can't read in root inode: %d\n", error);
|
|
|
|
goto out;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-01-30 18:34:10 +00:00
|
|
|
sb->s_root = d_alloc_root(inode);
|
|
|
|
if (!sb->s_root) {
|
|
|
|
fs_err(sdp, "can't get root dentry\n");
|
|
|
|
error = -ENOMEM;
|
2006-03-01 20:31:02 +00:00
|
|
|
iput(inode);
|
2007-08-15 15:54:44 +00:00
|
|
|
} else
|
|
|
|
sb->s_root->d_op = &gfs2_dops;
|
|
|
|
|
2006-01-30 18:34:10 +00:00
|
|
|
out:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&sb_gh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-12-12 00:49:21 +00:00
|
|
|
/**
|
|
|
|
* map_journal_extents - create a reusable "extent" mapping from all logical
|
|
|
|
* blocks to all physical blocks for the given journal. This will save
|
|
|
|
* us time when writing journal blocks. Most journals will have only one
|
|
|
|
* extent that maps all their logical blocks. That's because gfs2.mkfs
|
|
|
|
* arranges the journal blocks sequentially to maximize performance.
|
|
|
|
* So the extent would map the first block for the entire file length.
|
|
|
|
* However, gfs2_jadd can happen while file activity is happening, so
|
|
|
|
* those journals may not be sequential. Less likely is the case where
|
|
|
|
* the users created their own journals by mounting the metafs and
|
|
|
|
* laying it out. But it's still possible. These journals might have
|
|
|
|
* several extents.
|
|
|
|
*
|
|
|
|
* TODO: This should be done in bigger chunks rather than one block at a time,
|
|
|
|
* but since it's only done at mount time, I'm not worried about the
|
|
|
|
* time it takes.
|
|
|
|
*/
|
|
|
|
static int map_journal_extents(struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
struct gfs2_jdesc *jd = sdp->sd_jdesc;
|
|
|
|
unsigned int lb;
|
|
|
|
u64 db, prev_db; /* logical block, disk block, prev disk block */
|
|
|
|
struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
|
|
|
|
struct gfs2_journal_extent *jext = NULL;
|
|
|
|
struct buffer_head bh;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
prev_db = 0;
|
|
|
|
|
2007-12-12 23:52:13 +00:00
|
|
|
for (lb = 0; lb < ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift; lb++) {
|
2007-12-12 00:49:21 +00:00
|
|
|
bh.b_state = 0;
|
|
|
|
bh.b_blocknr = 0;
|
|
|
|
bh.b_size = 1 << ip->i_inode.i_blkbits;
|
|
|
|
rc = gfs2_block_map(jd->jd_inode, lb, &bh, 0);
|
|
|
|
db = bh.b_blocknr;
|
|
|
|
if (rc || !db) {
|
|
|
|
printk(KERN_INFO "GFS2 journal mapping error %d: lb="
|
|
|
|
"%u db=%llu\n", rc, lb, (unsigned long long)db);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!prev_db || db != prev_db + 1) {
|
|
|
|
jext = kzalloc(sizeof(struct gfs2_journal_extent),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!jext) {
|
|
|
|
printk(KERN_INFO "GFS2 error: out of memory "
|
|
|
|
"mapping journal extents.\n");
|
|
|
|
rc = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
jext->dblock = db;
|
|
|
|
jext->lblock = lb;
|
|
|
|
jext->blocks = 1;
|
|
|
|
list_add_tail(&jext->extent_list, &jd->extent_list);
|
|
|
|
} else {
|
|
|
|
jext->blocks++;
|
|
|
|
}
|
|
|
|
prev_db = db;
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-01-30 15:34:04 +00:00
|
|
|
static void gfs2_lm_others_may_mount(struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
|
|
|
|
sdp->sd_lockstruct.ls_ops->lm_others_may_mount(
|
|
|
|
sdp->sd_lockstruct.ls_lockspace);
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
static int init_journal(struct gfs2_sbd *sdp, int undo)
|
|
|
|
{
|
|
|
|
struct gfs2_holder ji_gh;
|
|
|
|
struct task_struct *p;
|
2006-02-27 22:23:27 +00:00
|
|
|
struct gfs2_inode *ip;
|
2006-01-16 16:50:04 +00:00
|
|
|
int jindex = 1;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (undo) {
|
|
|
|
jindex = 0;
|
|
|
|
goto fail_recoverd;
|
|
|
|
}
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
sdp->sd_jindex = gfs2_lookup_simple(sdp->sd_master_dir, "jindex");
|
|
|
|
if (IS_ERR(sdp->sd_jindex)) {
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't lookup journal index: %d\n", error);
|
2006-03-20 17:30:04 +00:00
|
|
|
return PTR_ERR(sdp->sd_jindex);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2006-06-14 19:32:57 +00:00
|
|
|
ip = GFS2_I(sdp->sd_jindex);
|
2006-02-27 22:23:27 +00:00
|
|
|
set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* Load in the journal index special file */
|
|
|
|
|
|
|
|
error = gfs2_jindex_hold(sdp, &ji_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't read journal index: %d\n", error);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = -EINVAL;
|
|
|
|
if (!gfs2_jindex_size(sdp)) {
|
|
|
|
fs_err(sdp, "no journals!\n");
|
2006-09-25 13:26:04 +00:00
|
|
|
goto fail_jindex;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sdp->sd_args.ar_spectator) {
|
|
|
|
sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
|
2007-11-08 14:55:03 +00:00
|
|
|
atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
|
2006-01-16 16:50:04 +00:00
|
|
|
} else {
|
|
|
|
if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
|
|
|
|
fs_err(sdp, "can't mount journal #%u\n",
|
|
|
|
sdp->sd_lockstruct.ls_jid);
|
|
|
|
fs_err(sdp, "there are only %u journals (0 - %u)\n",
|
|
|
|
gfs2_jindex_size(sdp),
|
|
|
|
gfs2_jindex_size(sdp) - 1);
|
|
|
|
goto fail_jindex;
|
|
|
|
}
|
|
|
|
sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
|
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
|
2006-01-16 16:50:04 +00:00
|
|
|
&gfs2_journal_glops,
|
|
|
|
LM_ST_EXCLUSIVE, LM_FLAG_NOEXP,
|
|
|
|
&sdp->sd_journal_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't acquire journal glock: %d\n", error);
|
|
|
|
goto fail_jindex;
|
|
|
|
}
|
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
ip = GFS2_I(sdp->sd_jdesc->jd_inode);
|
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
|
2007-08-08 22:08:14 +00:00
|
|
|
LM_FLAG_NOEXP | GL_EXACT | GL_NOCACHE,
|
2006-01-16 16:50:04 +00:00
|
|
|
&sdp->sd_jinode_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't acquire journal inode glock: %d\n",
|
|
|
|
error);
|
|
|
|
goto fail_journal_gh;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_jdesc_check(sdp->sd_jdesc);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "my journal (%u) is bad: %d\n",
|
|
|
|
sdp->sd_jdesc->jd_jid, error);
|
|
|
|
goto fail_jinode_gh;
|
|
|
|
}
|
2007-11-08 14:55:03 +00:00
|
|
|
atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
|
2007-12-12 00:49:21 +00:00
|
|
|
|
|
|
|
/* Map the extents for this journal's blocks */
|
|
|
|
map_journal_extents(sdp);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sdp->sd_lockstruct.ls_first) {
|
|
|
|
unsigned int x;
|
|
|
|
for (x = 0; x < sdp->sd_journals; x++) {
|
2006-04-20 21:03:48 +00:00
|
|
|
error = gfs2_recover_journal(gfs2_jdesc_find(sdp, x));
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "error recovering journal %u: %d\n",
|
|
|
|
x, error);
|
|
|
|
goto fail_jinode_gh;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gfs2_lm_others_may_mount(sdp);
|
|
|
|
} else if (!sdp->sd_args.ar_spectator) {
|
2006-04-20 21:03:48 +00:00
|
|
|
error = gfs2_recover_journal(sdp->sd_jdesc);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "error recovering my journal: %d\n", error);
|
|
|
|
goto fail_jinode_gh;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
|
|
|
|
gfs2_glock_dq_uninit(&ji_gh);
|
|
|
|
jindex = 0;
|
|
|
|
|
|
|
|
p = kthread_run(gfs2_recoverd, sdp, "gfs2_recoverd");
|
|
|
|
error = IS_ERR(p);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't start recoverd thread: %d\n", error);
|
|
|
|
goto fail_jinode_gh;
|
|
|
|
}
|
|
|
|
sdp->sd_recoverd_process = p;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_recoverd:
|
2006-01-16 16:50:04 +00:00
|
|
|
kthread_stop(sdp->sd_recoverd_process);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_jinode_gh:
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!sdp->sd_args.ar_spectator)
|
|
|
|
gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_journal_gh:
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!sdp->sd_args.ar_spectator)
|
|
|
|
gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_jindex:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_jindex_free(sdp);
|
|
|
|
if (jindex)
|
|
|
|
gfs2_glock_dq_uninit(&ji_gh);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2006-01-30 18:34:10 +00:00
|
|
|
iput(sdp->sd_jindex);
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int init_inodes(struct gfs2_sbd *sdp, int undo)
|
|
|
|
{
|
|
|
|
int error = 0;
|
2006-02-27 22:23:27 +00:00
|
|
|
struct gfs2_inode *ip;
|
2006-03-01 20:31:02 +00:00
|
|
|
struct inode *inode;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (undo)
|
2006-01-30 18:34:10 +00:00
|
|
|
goto fail_qinode;
|
|
|
|
|
2007-05-15 14:37:50 +00:00
|
|
|
inode = gfs2_lookup_root(sdp->sd_vfs, sdp->sd_sb.sb_master_dir.no_addr);
|
2006-03-01 20:31:02 +00:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
error = PTR_ERR(inode);
|
2006-01-30 18:34:10 +00:00
|
|
|
fs_err(sdp, "can't read in master directory: %d\n", error);
|
|
|
|
goto fail;
|
|
|
|
}
|
2006-03-01 20:31:02 +00:00
|
|
|
sdp->sd_master_dir = inode;
|
2006-01-30 18:34:10 +00:00
|
|
|
|
|
|
|
error = init_journal(sdp, undo);
|
|
|
|
if (error)
|
|
|
|
goto fail_master;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* Read in the master inode number inode */
|
2006-03-20 17:30:04 +00:00
|
|
|
sdp->sd_inum_inode = gfs2_lookup_simple(sdp->sd_master_dir, "inum");
|
|
|
|
if (IS_ERR(sdp->sd_inum_inode)) {
|
|
|
|
error = PTR_ERR(sdp->sd_inum_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't read in inum inode: %d\n", error);
|
2006-01-30 18:34:10 +00:00
|
|
|
goto fail_journal;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-01-30 18:34:10 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
/* Read in the master statfs inode */
|
2006-03-20 17:30:04 +00:00
|
|
|
sdp->sd_statfs_inode = gfs2_lookup_simple(sdp->sd_master_dir, "statfs");
|
|
|
|
if (IS_ERR(sdp->sd_statfs_inode)) {
|
|
|
|
error = PTR_ERR(sdp->sd_statfs_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't read in statfs inode: %d\n", error);
|
2006-01-30 18:34:10 +00:00
|
|
|
goto fail_inum;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Read in the resource index inode */
|
2006-03-20 17:30:04 +00:00
|
|
|
sdp->sd_rindex = gfs2_lookup_simple(sdp->sd_master_dir, "rindex");
|
|
|
|
if (IS_ERR(sdp->sd_rindex)) {
|
|
|
|
error = PTR_ERR(sdp->sd_rindex);
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't get resource index inode: %d\n", error);
|
|
|
|
goto fail_statfs;
|
|
|
|
}
|
2006-06-14 19:32:57 +00:00
|
|
|
ip = GFS2_I(sdp->sd_rindex);
|
2006-02-27 22:23:27 +00:00
|
|
|
set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
|
2008-01-31 16:31:39 +00:00
|
|
|
sdp->sd_rindex_uptodate = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/* Read in the quota inode */
|
2006-03-20 17:30:04 +00:00
|
|
|
sdp->sd_quota_inode = gfs2_lookup_simple(sdp->sd_master_dir, "quota");
|
|
|
|
if (IS_ERR(sdp->sd_quota_inode)) {
|
|
|
|
error = PTR_ERR(sdp->sd_quota_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't get quota file inode: %d\n", error);
|
|
|
|
goto fail_rindex;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
2006-01-30 18:34:10 +00:00
|
|
|
fail_qinode:
|
|
|
|
iput(sdp->sd_quota_inode);
|
|
|
|
fail_rindex:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_clear_rgrpd(sdp);
|
2006-01-30 18:34:10 +00:00
|
|
|
iput(sdp->sd_rindex);
|
|
|
|
fail_statfs:
|
|
|
|
iput(sdp->sd_statfs_inode);
|
|
|
|
fail_inum:
|
|
|
|
iput(sdp->sd_inum_inode);
|
|
|
|
fail_journal:
|
|
|
|
init_journal(sdp, UNDO);
|
|
|
|
fail_master:
|
|
|
|
iput(sdp->sd_master_dir);
|
|
|
|
fail:
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int init_per_node(struct gfs2_sbd *sdp, int undo)
|
|
|
|
{
|
2006-01-30 18:34:10 +00:00
|
|
|
struct inode *pn = NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
char buf[30];
|
|
|
|
int error = 0;
|
2006-02-27 22:23:27 +00:00
|
|
|
struct gfs2_inode *ip;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (sdp->sd_args.ar_spectator)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (undo)
|
|
|
|
goto fail_qc_gh;
|
|
|
|
|
2006-03-20 17:30:04 +00:00
|
|
|
pn = gfs2_lookup_simple(sdp->sd_master_dir, "per_node");
|
|
|
|
if (IS_ERR(pn)) {
|
|
|
|
error = PTR_ERR(pn);
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't find per_node directory: %d\n", error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
sprintf(buf, "inum_range%u", sdp->sd_jdesc->jd_jid);
|
2006-03-20 17:30:04 +00:00
|
|
|
sdp->sd_ir_inode = gfs2_lookup_simple(pn, buf);
|
|
|
|
if (IS_ERR(sdp->sd_ir_inode)) {
|
|
|
|
error = PTR_ERR(sdp->sd_ir_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't find local \"ir\" file: %d\n", error);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
|
2006-03-20 17:30:04 +00:00
|
|
|
sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
|
|
|
|
if (IS_ERR(sdp->sd_sc_inode)) {
|
|
|
|
error = PTR_ERR(sdp->sd_sc_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't find local \"sc\" file: %d\n", error);
|
|
|
|
goto fail_ir_i;
|
|
|
|
}
|
|
|
|
|
|
|
|
sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
|
2006-03-20 17:30:04 +00:00
|
|
|
sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
|
|
|
|
if (IS_ERR(sdp->sd_qc_inode)) {
|
|
|
|
error = PTR_ERR(sdp->sd_qc_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
|
|
|
|
goto fail_ut_i;
|
|
|
|
}
|
|
|
|
|
2006-01-30 18:34:10 +00:00
|
|
|
iput(pn);
|
2006-01-16 16:50:04 +00:00
|
|
|
pn = NULL;
|
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
ip = GFS2_I(sdp->sd_ir_inode);
|
2006-02-27 22:23:27 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl,
|
2006-04-26 18:58:26 +00:00
|
|
|
LM_ST_EXCLUSIVE, 0,
|
2006-01-16 16:50:04 +00:00
|
|
|
&sdp->sd_ir_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't lock local \"ir\" file: %d\n", error);
|
|
|
|
goto fail_qc_i;
|
|
|
|
}
|
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
ip = GFS2_I(sdp->sd_sc_inode);
|
2006-02-27 22:23:27 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl,
|
2006-04-26 18:58:26 +00:00
|
|
|
LM_ST_EXCLUSIVE, 0,
|
2006-01-16 16:50:04 +00:00
|
|
|
&sdp->sd_sc_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
|
|
|
|
goto fail_ir_gh;
|
|
|
|
}
|
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
ip = GFS2_I(sdp->sd_qc_inode);
|
2006-02-27 22:23:27 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl,
|
2006-04-26 18:58:26 +00:00
|
|
|
LM_ST_EXCLUSIVE, 0,
|
2006-01-16 16:50:04 +00:00
|
|
|
&sdp->sd_qc_gh);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
|
|
|
|
goto fail_ut_gh;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_qc_gh:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_ut_gh:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_ir_gh:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_qc_i:
|
2006-01-30 18:34:10 +00:00
|
|
|
iput(sdp->sd_qc_inode);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_ut_i:
|
2006-01-30 18:34:10 +00:00
|
|
|
iput(sdp->sd_sc_inode);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_ir_i:
|
2006-01-30 18:34:10 +00:00
|
|
|
iput(sdp->sd_ir_inode);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2006-01-16 16:50:04 +00:00
|
|
|
if (pn)
|
2006-01-30 18:34:10 +00:00
|
|
|
iput(pn);
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int init_threads(struct gfs2_sbd *sdp, int undo)
|
|
|
|
{
|
|
|
|
struct task_struct *p;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (undo)
|
2006-06-14 19:32:57 +00:00
|
|
|
goto fail_quotad;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
sdp->sd_log_flush_time = jiffies;
|
|
|
|
sdp->sd_jindex_refresh_time = jiffies;
|
|
|
|
|
|
|
|
p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
|
|
|
|
error = IS_ERR(p);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't start logd thread: %d\n", error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
sdp->sd_logd_process = p;
|
|
|
|
|
|
|
|
sdp->sd_statfs_sync_time = jiffies;
|
|
|
|
sdp->sd_quota_sync_time = jiffies;
|
|
|
|
|
|
|
|
p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
|
|
|
|
error = IS_ERR(p);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't start quotad thread: %d\n", error);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
sdp->sd_quotad_process = p;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
2006-06-14 19:32:57 +00:00
|
|
|
fail_quotad:
|
2006-01-16 16:50:04 +00:00
|
|
|
kthread_stop(sdp->sd_quotad_process);
|
2006-06-14 19:32:57 +00:00
|
|
|
fail:
|
2006-01-16 16:50:04 +00:00
|
|
|
kthread_stop(sdp->sd_logd_process);
|
|
|
|
return error;
|
|
|
|
}
|
2008-01-30 15:34:04 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gfs2_lm_mount - mount a locking protocol
|
|
|
|
* @sdp: the filesystem
|
|
|
|
* @args: mount arguements
|
|
|
|
* @silent: if 1, don't complain if the FS isn't a GFS2 fs
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
|
|
|
|
{
|
|
|
|
char *proto = sdp->sd_proto_name;
|
|
|
|
char *table = sdp->sd_table_name;
|
|
|
|
int flags = 0;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (sdp->sd_args.ar_spectator)
|
|
|
|
flags |= LM_MFLAG_SPECTATOR;
|
|
|
|
|
|
|
|
fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
|
|
|
|
|
|
|
|
error = gfs2_mount_lockproto(proto, table, sdp->sd_args.ar_hostdata,
|
|
|
|
gfs2_glock_cb, sdp,
|
|
|
|
GFS2_MIN_LVB_SIZE, flags,
|
|
|
|
&sdp->sd_lockstruct, &sdp->sd_kobj);
|
|
|
|
if (error) {
|
|
|
|
fs_info(sdp, "can't mount proto=%s, table=%s, hostdata=%s\n",
|
|
|
|
proto, table, sdp->sd_args.ar_hostdata);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lockspace) ||
|
|
|
|
gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_ops) ||
|
|
|
|
gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lvb_size >=
|
|
|
|
GFS2_MIN_LVB_SIZE)) {
|
|
|
|
gfs2_unmount_lockproto(&sdp->sd_lockstruct);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sdp->sd_args.ar_spectator)
|
|
|
|
snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.s", table);
|
|
|
|
else
|
|
|
|
snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.%u", table,
|
|
|
|
sdp->sd_lockstruct.ls_jid);
|
|
|
|
|
|
|
|
fs_info(sdp, "Joined cluster. Now mounting FS...\n");
|
|
|
|
|
|
|
|
if ((sdp->sd_lockstruct.ls_flags & LM_LSFLAG_LOCAL) &&
|
|
|
|
!sdp->sd_args.ar_ignore_local_fs) {
|
|
|
|
sdp->sd_args.ar_localflocks = 1;
|
|
|
|
sdp->sd_args.ar_localcaching = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gfs2_lm_unmount(struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
|
|
|
|
gfs2_unmount_lockproto(&sdp->sd_lockstruct);
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* fill_super - Read in superblock
|
|
|
|
* @sb: The VFS superblock
|
|
|
|
* @data: Mount options
|
|
|
|
* @silent: Don't complain if it's not a GFS2 filesystem
|
|
|
|
*
|
|
|
|
* Returns: errno
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int fill_super(struct super_block *sb, void *data, int silent)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp;
|
|
|
|
struct gfs2_holder mount_gh;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
sdp = init_sbd(sb);
|
|
|
|
if (!sdp) {
|
2006-02-27 15:57:14 +00:00
|
|
|
printk(KERN_WARNING "GFS2: can't alloc struct gfs2_sbd\n");
|
2006-01-16 16:50:04 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_mount_args(sdp, (char *)data, 0);
|
|
|
|
if (error) {
|
2006-02-27 15:57:14 +00:00
|
|
|
printk(KERN_WARNING "GFS2: can't parse mount arguments\n");
|
2006-01-16 16:50:04 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2006-03-02 21:33:41 +00:00
|
|
|
init_vfs(sb, SDF_NOATIME);
|
|
|
|
|
|
|
|
/* Set up the buffer cache and fill in some fake block size values
|
|
|
|
to allow us to read-in the on-disk superblock. */
|
|
|
|
sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
|
|
|
|
sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
|
|
|
|
sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
|
|
|
|
GFS2_BASIC_BLOCK_SHIFT;
|
|
|
|
sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
error = init_names(sdp, silent);
|
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
2007-03-16 10:26:37 +00:00
|
|
|
gfs2_create_debugfs_file(sdp);
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
error = gfs2_sys_fs_add(sdp);
|
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
error = gfs2_lm_mount(sdp, silent);
|
|
|
|
if (error)
|
|
|
|
goto fail_sys;
|
|
|
|
|
|
|
|
error = init_locking(sdp, &mount_gh, DO);
|
|
|
|
if (error)
|
|
|
|
goto fail_lm;
|
|
|
|
|
|
|
|
error = init_sb(sdp, silent, DO);
|
|
|
|
if (error)
|
|
|
|
goto fail_locking;
|
|
|
|
|
|
|
|
error = init_inodes(sdp, DO);
|
|
|
|
if (error)
|
2006-01-30 18:34:10 +00:00
|
|
|
goto fail_sb;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
error = init_per_node(sdp, DO);
|
|
|
|
if (error)
|
|
|
|
goto fail_inodes;
|
|
|
|
|
|
|
|
error = gfs2_statfs_init(sdp);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
|
|
|
|
goto fail_per_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = init_threads(sdp, DO);
|
|
|
|
if (error)
|
|
|
|
goto fail_per_node;
|
|
|
|
|
|
|
|
if (!(sb->s_flags & MS_RDONLY)) {
|
|
|
|
error = gfs2_make_fs_rw(sdp);
|
|
|
|
if (error) {
|
|
|
|
fs_err(sdp, "can't make FS RW: %d\n", error);
|
|
|
|
goto fail_threads;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&mount_gh);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_threads:
|
2006-01-16 16:50:04 +00:00
|
|
|
init_threads(sdp, UNDO);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_per_node:
|
2006-01-16 16:50:04 +00:00
|
|
|
init_per_node(sdp, UNDO);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_inodes:
|
2006-01-16 16:50:04 +00:00
|
|
|
init_inodes(sdp, UNDO);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_sb:
|
2006-01-16 16:50:04 +00:00
|
|
|
init_sb(sdp, 0, UNDO);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_locking:
|
2006-01-16 16:50:04 +00:00
|
|
|
init_locking(sdp, &mount_gh, UNDO);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_lm:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_gl_hash_clear(sdp, WAIT);
|
|
|
|
gfs2_lm_unmount(sdp);
|
|
|
|
while (invalidate_inodes(sb))
|
|
|
|
yield();
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_sys:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_sys_fs_del(sdp);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2007-04-18 16:41:11 +00:00
|
|
|
gfs2_delete_debugfs_file(sdp);
|
2006-09-08 14:13:03 +00:00
|
|
|
kfree(sdp);
|
2006-02-27 22:23:27 +00:00
|
|
|
sb->s_fs_info = NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-06-30 09:16:34 +00:00
|
|
|
static int gfs2_get_sb(struct file_system_type *fs_type, int flags,
|
|
|
|
const char *dev_name, void *data, struct vfsmount *mnt)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-08-25 16:13:37 +00:00
|
|
|
struct super_block *sb;
|
|
|
|
struct gfs2_sbd *sdp;
|
|
|
|
int error = get_sb_bdev(fs_type, flags, dev_name, data, fill_super, mnt);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
sb = mnt->mnt_sb;
|
2006-09-04 19:32:10 +00:00
|
|
|
sdp = sb->s_fs_info;
|
2006-08-25 16:13:37 +00:00
|
|
|
sdp->sd_gfs2mnt = mnt;
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-09-25 13:26:04 +00:00
|
|
|
static int fill_super_meta(struct super_block *sb, struct super_block *new,
|
2006-08-25 16:13:37 +00:00
|
|
|
void *data, int silent)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = sb->s_fs_info;
|
|
|
|
struct inode *inode;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
new->s_fs_info = sdp;
|
|
|
|
sdp->sd_vfs_meta = sb;
|
|
|
|
|
|
|
|
init_vfs(new, SDF_NOATIME);
|
|
|
|
|
|
|
|
/* Get the master inode */
|
|
|
|
inode = igrab(sdp->sd_master_dir);
|
|
|
|
|
|
|
|
new->s_root = d_alloc_root(inode);
|
|
|
|
if (!new->s_root) {
|
|
|
|
fs_err(sdp, "can't get root dentry\n");
|
|
|
|
error = -ENOMEM;
|
|
|
|
iput(inode);
|
2006-10-19 13:27:00 +00:00
|
|
|
} else
|
|
|
|
new->s_root->d_op = &gfs2_dops;
|
2006-08-25 16:13:37 +00:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
2006-09-04 16:04:26 +00:00
|
|
|
|
2006-08-25 16:13:37 +00:00
|
|
|
static int set_bdev_super(struct super_block *s, void *data)
|
|
|
|
{
|
|
|
|
s->s_bdev = data;
|
|
|
|
s->s_dev = s->s_bdev->bd_dev;
|
|
|
|
return 0;
|
|
|
|
}
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2006-08-25 16:13:37 +00:00
|
|
|
static int test_bdev_super(struct super_block *s, void *data)
|
|
|
|
{
|
2006-09-04 19:32:10 +00:00
|
|
|
return s->s_bdev == data;
|
2006-08-25 16:13:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct super_block* get_gfs2_sb(const char *dev_name)
|
|
|
|
{
|
|
|
|
struct kstat stat;
|
|
|
|
struct nameidata nd;
|
|
|
|
struct file_system_type *fstype;
|
|
|
|
struct super_block *sb = NULL, *s;
|
|
|
|
int error;
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2006-08-25 16:13:37 +00:00
|
|
|
error = path_lookup(dev_name, LOOKUP_FOLLOW, &nd);
|
|
|
|
if (error) {
|
2006-09-25 13:26:04 +00:00
|
|
|
printk(KERN_WARNING "GFS2: path_lookup on %s returned error\n",
|
2006-08-25 16:13:37 +00:00
|
|
|
dev_name);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-02-15 03:34:32 +00:00
|
|
|
error = vfs_getattr(nd.path.mnt, nd.path.dentry, &stat);
|
2006-08-25 16:13:37 +00:00
|
|
|
|
|
|
|
fstype = get_fs_type("gfs2");
|
2007-08-11 02:27:07 +00:00
|
|
|
list_for_each_entry(s, &fstype->fs_supers, s_instances) {
|
2006-08-25 16:13:37 +00:00
|
|
|
if ((S_ISBLK(stat.mode) && s->s_dev == stat.rdev) ||
|
2008-02-15 03:34:32 +00:00
|
|
|
(S_ISDIR(stat.mode) &&
|
|
|
|
s == nd.path.dentry->d_inode->i_sb)) {
|
2006-08-25 16:13:37 +00:00
|
|
|
sb = s;
|
|
|
|
goto free_nd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_WARNING "GFS2: Unrecognized block device or "
|
2007-02-17 17:29:15 +00:00
|
|
|
"mount point %s\n", dev_name);
|
2006-08-25 16:13:37 +00:00
|
|
|
|
|
|
|
free_nd:
|
2008-02-15 03:34:35 +00:00
|
|
|
path_put(&nd.path);
|
2006-08-25 16:13:37 +00:00
|
|
|
out:
|
|
|
|
return sb;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gfs2_get_sb_meta(struct file_system_type *fs_type, int flags,
|
|
|
|
const char *dev_name, void *data, struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
struct super_block *sb = NULL, *new;
|
|
|
|
struct gfs2_sbd *sdp;
|
|
|
|
|
|
|
|
sb = get_gfs2_sb(dev_name);
|
|
|
|
if (!sb) {
|
|
|
|
printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n");
|
|
|
|
error = -ENOENT;
|
|
|
|
goto error;
|
|
|
|
}
|
2007-08-11 02:27:08 +00:00
|
|
|
sdp = sb->s_fs_info;
|
2006-08-25 16:13:37 +00:00
|
|
|
if (sdp->sd_vfs_meta) {
|
|
|
|
printk(KERN_WARNING "GFS2: gfs2meta mount already exists\n");
|
|
|
|
error = -EBUSY;
|
|
|
|
goto error;
|
|
|
|
}
|
2007-01-11 07:15:41 +00:00
|
|
|
down(&sb->s_bdev->bd_mount_sem);
|
2006-08-25 16:13:37 +00:00
|
|
|
new = sget(fs_type, test_bdev_super, set_bdev_super, sb->s_bdev);
|
2007-01-11 07:15:41 +00:00
|
|
|
up(&sb->s_bdev->bd_mount_sem);
|
2006-08-25 16:13:37 +00:00
|
|
|
if (IS_ERR(new)) {
|
|
|
|
error = PTR_ERR(new);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
module_put(fs_type->owner);
|
|
|
|
new->s_flags = flags;
|
|
|
|
strlcpy(new->s_id, sb->s_id, sizeof(new->s_id));
|
|
|
|
sb_set_blocksize(new, sb->s_blocksize);
|
|
|
|
error = fill_super_meta(sb, new, data, flags & MS_SILENT ? 1 : 0);
|
|
|
|
if (error) {
|
|
|
|
up_write(&new->s_umount);
|
|
|
|
deactivate_super(new);
|
|
|
|
goto error;
|
|
|
|
}
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2006-08-25 16:13:37 +00:00
|
|
|
new->s_flags |= MS_ACTIVE;
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2006-08-25 16:13:37 +00:00
|
|
|
/* Grab a reference to the gfs2 mount point */
|
|
|
|
atomic_inc(&sdp->sd_gfs2mnt->mnt_count);
|
|
|
|
return simple_set_mnt(mnt, new);
|
|
|
|
error:
|
|
|
|
return error;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-03-02 21:33:41 +00:00
|
|
|
static void gfs2_kill_sb(struct super_block *sb)
|
|
|
|
{
|
2007-08-23 18:33:01 +00:00
|
|
|
if (sb->s_fs_info) {
|
|
|
|
gfs2_delete_debugfs_file(sb->s_fs_info);
|
|
|
|
gfs2_meta_syncfs(sb->s_fs_info);
|
|
|
|
}
|
2006-03-02 21:33:41 +00:00
|
|
|
kill_block_super(sb);
|
|
|
|
}
|
|
|
|
|
2006-08-25 16:13:37 +00:00
|
|
|
static void gfs2_kill_sb_meta(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = sb->s_fs_info;
|
|
|
|
generic_shutdown_super(sb);
|
|
|
|
sdp->sd_vfs_meta = NULL;
|
|
|
|
atomic_dec(&sdp->sd_gfs2mnt->mnt_count);
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
struct file_system_type gfs2_fs_type = {
|
|
|
|
.name = "gfs2",
|
|
|
|
.fs_flags = FS_REQUIRES_DEV,
|
|
|
|
.get_sb = gfs2_get_sb,
|
2006-03-02 21:33:41 +00:00
|
|
|
.kill_sb = gfs2_kill_sb,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct file_system_type gfs2meta_fs_type = {
|
|
|
|
.name = "gfs2meta",
|
|
|
|
.fs_flags = FS_REQUIRES_DEV,
|
2006-08-25 16:13:37 +00:00
|
|
|
.get_sb = gfs2_get_sb_meta,
|
|
|
|
.kill_sb = gfs2_kill_sb_meta,
|
2006-01-16 16:50:04 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|