Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit b276058371f5c2ad92f9f27373a72b219ed580ed

Authored by Steven Whitehouse 2008-10-14 23:05:55 +0800

GFS2: Rationalise header files

Move the contents of some headers which contained very
little into more sensible places, and remove the original
header files. This should make it easier to find things.

Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

Showing 14 changed files with 23 additions and 90 deletions Inline Diff

fs/gfs2/inode.c
fs/gfs2/inode.h
fs/gfs2/main.c
fs/gfs2/ops_dentry.c
fs/gfs2/ops_dentry.h
fs/gfs2/ops_export.c
fs/gfs2/ops_file.c
fs/gfs2/ops_fstype.c
fs/gfs2/ops_fstype.h
fs/gfs2/ops_inode.c
fs/gfs2/ops_inode.h
fs/gfs2/ops_super.c
fs/gfs2/ops_super.h
fs/gfs2/super.h

fs/gfs2/inode.c

Diff comments View file @ b276058

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/posix_acl.h>
 #include <linux/sort.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
 #include <linux/lm_interface.h>
 #include <linux/security.h>
 #include <linux/time.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "acl.h"
 #include "bmap.h"
 #include "dir.h"
 #include "eattr.h"
 #include "glock.h"
 #include "glops.h"
 #include "inode.h"
 #include "log.h"
 #include "meta_io.h"
 #include "ops_address.h"
-#include "ops_inode.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "trans.h"
 #include "util.h"
 struct gfs2_inum_range_host {
 	u64 ir_start;
 	u64 ir_length;
 };
 static int iget_test(struct inode *inode, void *opaque)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	u64 *no_addr = opaque;
 	if (ip->i_no_addr == *no_addr && test_bit(GIF_USER, &ip->i_flags))
 		return 1;
 	return 0;
 }
 static int iget_set(struct inode *inode, void *opaque)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	u64 *no_addr = opaque;
 	inode->i_ino = (unsigned long)*no_addr;
 	ip->i_no_addr = *no_addr;
 	set_bit(GIF_USER, &ip->i_flags);
 	return 0;
 }
 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr)
 {
 	unsigned long hash = (unsigned long)no_addr;
 	return ilookup5(sb, hash, iget_test, &no_addr);
 }
 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr)
 {
 	unsigned long hash = (unsigned long)no_addr;
 	return iget5_locked(sb, hash, iget_test, iget_set, &no_addr);
 }
 struct gfs2_skip_data {
 	u64	no_addr;
 	int	skipped;
 };
 static int iget_skip_test(struct inode *inode, void *opaque)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_skip_data *data = opaque;
 	if (ip->i_no_addr == data->no_addr && test_bit(GIF_USER, &ip->i_flags)){
 		if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)){
 			data->skipped = 1;
 			return 0;
 		}
 		return 1;
 	}
 	return 0;
 }
 static int iget_skip_set(struct inode *inode, void *opaque)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_skip_data *data = opaque;
 	if (data->skipped)
 		return 1;
 	inode->i_ino = (unsigned long)(data->no_addr);
 	ip->i_no_addr = data->no_addr;
 	set_bit(GIF_USER, &ip->i_flags);
 	return 0;
 }
 static struct inode *gfs2_iget_skip(struct super_block *sb,
 				    u64 no_addr)
 {
 	struct gfs2_skip_data data;
 	unsigned long hash = (unsigned long)no_addr;
 	data.no_addr = no_addr;
 	data.skipped = 0;
 	return iget5_locked(sb, hash, iget_skip_test, iget_skip_set, &data);
 }
 /**
  * GFS2 lookup code fills in vfs inode contents based on info obtained
  * from directory entry inside gfs2_inode_lookup(). This has caused issues
  * with NFS code path since its get_dentry routine doesn't have the relevant
  * directory entry when gfs2_inode_lookup() is invoked. Part of the code
  * segment inside gfs2_inode_lookup code needs to get moved around.
  *
  * Clean up I_LOCK and I_NEW as well.
  **/
 void gfs2_set_iop(struct inode *inode)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	umode_t mode = inode->i_mode;
 	if (S_ISREG(mode)) {
 		inode->i_op = &gfs2_file_iops;
 		if (sdp->sd_args.ar_localflocks)
 			inode->i_fop = &gfs2_file_fops_nolock;
 		else
 			inode->i_fop = &gfs2_file_fops;
 	} else if (S_ISDIR(mode)) {
 		inode->i_op = &gfs2_dir_iops;
 		if (sdp->sd_args.ar_localflocks)
 			inode->i_fop = &gfs2_dir_fops_nolock;
 		else
 			inode->i_fop = &gfs2_dir_fops;
 	} else if (S_ISLNK(mode)) {
 		inode->i_op = &gfs2_symlink_iops;
 	} else {
 		inode->i_op = &gfs2_file_iops;
 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
 	}
 	unlock_new_inode(inode);
 }
 /**
  * gfs2_inode_lookup - Lookup an inode
  * @sb: The super block
  * @no_addr: The inode number
  * @type: The type of the inode
  * @skip_freeing: set this not return an inode if it is currently being freed.
  *
  * Returns: A VFS inode, or an error
  */
 struct inode *gfs2_inode_lookup(struct super_block *sb,
 				unsigned int type,
 				u64 no_addr,
 				u64 no_formal_ino, int skip_freeing)
 {
 	struct inode *inode;
 	struct gfs2_inode *ip;
 	struct gfs2_glock *io_gl;
 	int error;
 	if (skip_freeing)
 		inode = gfs2_iget_skip(sb, no_addr);
 	else
 		inode = gfs2_iget(sb, no_addr);
 	ip = GFS2_I(inode);
 	if (!inode)
 		return ERR_PTR(-ENOBUFS);
 	if (inode->i_state & I_NEW) {
 		struct gfs2_sbd *sdp = GFS2_SB(inode);
 		ip->i_no_formal_ino = no_formal_ino;
 		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 		if (unlikely(error))
 			goto fail;
 		ip->i_gl->gl_object = ip;
 		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 		if (unlikely(error))
 			goto fail_put;
 		set_bit(GIF_INVALID, &ip->i_flags);
 		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 		if (unlikely(error))
 			goto fail_iopen;
 		ip->i_iopen_gh.gh_gl->gl_object = ip;
 		gfs2_glock_put(io_gl);
 		if ((type == DT_UNKNOWN) && (no_formal_ino == 0))
 			goto gfs2_nfsbypass;
 		inode->i_mode = DT2IF(type);
 		/*
 		 * We must read the inode in order to work out its type in
 		 * this case. Note that this doesn't happen often as we normally
 		 * know the type beforehand. This code path only occurs during
 		 * unlinked inode recovery (where it is safe to do this glock,
 		 * which is not true in the general case).
 		 */
 		if (type == DT_UNKNOWN) {
 			struct gfs2_holder gh;
 			error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 			if (unlikely(error))
 				goto fail_glock;
 			/* Inode is now uptodate */
 			gfs2_glock_dq_uninit(&gh);
 		}
 		gfs2_set_iop(inode);
 	}
 gfs2_nfsbypass:
 	return inode;
 fail_glock:
 	gfs2_glock_dq(&ip->i_iopen_gh);
 fail_iopen:
 	gfs2_glock_put(io_gl);
 fail_put:
 	ip->i_gl->gl_object = NULL;
 	gfs2_glock_put(ip->i_gl);
 fail:
 	iget_failed(inode);
 	return ERR_PTR(error);
 }
 static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
 {
 	struct gfs2_dinode_host *di = &ip->i_di;
 	const struct gfs2_dinode *str = buf;
 	struct timespec atime;
 	u16 height, depth;
 	if (unlikely(ip->i_no_addr != be64_to_cpu(str->di_num.no_addr)))
 		goto corrupt;
 	ip->i_no_formal_ino = be64_to_cpu(str->di_num.no_formal_ino);
 	ip->i_inode.i_mode = be32_to_cpu(str->di_mode);
 	ip->i_inode.i_rdev = 0;
 	switch (ip->i_inode.i_mode & S_IFMT) {
 	case S_IFBLK:
 	case S_IFCHR:
 		ip->i_inode.i_rdev = MKDEV(be32_to_cpu(str->di_major),
 					   be32_to_cpu(str->di_minor));
 		break;
 	};
 	ip->i_inode.i_uid = be32_to_cpu(str->di_uid);
 	ip->i_inode.i_gid = be32_to_cpu(str->di_gid);
 	/*
 	 * We will need to review setting the nlink count here in the
 	 * light of the forthcoming ro bind mount work. This is a reminder
 	 * to do that.
 	 */
 	ip->i_inode.i_nlink = be32_to_cpu(str->di_nlink);
 	di->di_size = be64_to_cpu(str->di_size);
 	i_size_write(&ip->i_inode, di->di_size);
 	gfs2_set_inode_blocks(&ip->i_inode, be64_to_cpu(str->di_blocks));
 	atime.tv_sec = be64_to_cpu(str->di_atime);
 	atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
 	if (timespec_compare(&ip->i_inode.i_atime, &atime) < 0)
 		ip->i_inode.i_atime = atime;
 	ip->i_inode.i_mtime.tv_sec = be64_to_cpu(str->di_mtime);
 	ip->i_inode.i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec);
 	ip->i_inode.i_ctime.tv_sec = be64_to_cpu(str->di_ctime);
 	ip->i_inode.i_ctime.tv_nsec = be32_to_cpu(str->di_ctime_nsec);
 	ip->i_goal = be64_to_cpu(str->di_goal_meta);
 	di->di_generation = be64_to_cpu(str->di_generation);
 	di->di_flags = be32_to_cpu(str->di_flags);
 	gfs2_set_inode_flags(&ip->i_inode);
 	height = be16_to_cpu(str->di_height);
 	if (unlikely(height > GFS2_MAX_META_HEIGHT))
 		goto corrupt;
 	ip->i_height = (u8)height;
 	depth = be16_to_cpu(str->di_depth);
 	if (unlikely(depth > GFS2_DIR_MAX_DEPTH))
 		goto corrupt;
 	ip->i_depth = (u8)depth;
 	di->di_entries = be32_to_cpu(str->di_entries);
 	di->di_eattr = be64_to_cpu(str->di_eattr);
 	if (S_ISREG(ip->i_inode.i_mode))
 		gfs2_set_aops(&ip->i_inode);
 	return 0;
 corrupt:
 	if (gfs2_consist_inode(ip))
 		gfs2_dinode_print(ip);
 	return -EIO;
 }
 /**
  * gfs2_inode_refresh - Refresh the incore copy of the dinode
  * @ip: The GFS2 inode
  *
  * Returns: errno
  */
 int gfs2_inode_refresh(struct gfs2_inode *ip)
 {
 	struct buffer_head *dibh;
 	int error;
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		return error;
 	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), dibh, GFS2_METATYPE_DI)) {
 		brelse(dibh);
 		return -EIO;
 	}
 	error = gfs2_dinode_in(ip, dibh->b_data);
 	brelse(dibh);
 	clear_bit(GIF_INVALID, &ip->i_flags);
 	return error;
 }
 int gfs2_dinode_dealloc(struct gfs2_inode *ip)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	struct gfs2_alloc *al;
 	struct gfs2_rgrpd *rgd;
 	int error;
 	if (gfs2_get_inode_blocks(&ip->i_inode) != 1) {
 		if (gfs2_consist_inode(ip))
 			gfs2_dinode_print(ip);
 		return -EIO;
 	}
 	al = gfs2_alloc_get(ip);
 	if (!al)
 		return -ENOMEM;
 	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 	if (error)
 		goto out;
 	error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
 	if (error)
 		goto out_qs;
 	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
 	if (!rgd) {
 		gfs2_consist_inode(ip);
 		error = -EIO;
 		goto out_rindex_relse;
 	}
 	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
 				   &al->al_rgd_gh);
 	if (error)
 		goto out_rindex_relse;
 	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 1);
 	if (error)
 		goto out_rg_gunlock;
 	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
 	set_bit(GLF_LFLUSH, &ip->i_gl->gl_flags);
 	gfs2_free_di(rgd, ip);
 	gfs2_trans_end(sdp);
 	clear_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 out_rg_gunlock:
 	gfs2_glock_dq_uninit(&al->al_rgd_gh);
 out_rindex_relse:
 	gfs2_glock_dq_uninit(&al->al_ri_gh);
 out_qs:
 	gfs2_quota_unhold(ip);
 out:
 	gfs2_alloc_put(ip);
 	return error;
 }
 /**
  * gfs2_change_nlink - Change nlink count on inode
  * @ip: The GFS2 inode
  * @diff: The change in the nlink count required
  *
  * Returns: errno
  */
 int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
 {
 	struct buffer_head *dibh;
 	u32 nlink;
 	int error;
 	BUG_ON(diff != 1 && diff != -1);
 	nlink = ip->i_inode.i_nlink + diff;
 	/* If we are reducing the nlink count, but the new value ends up being
 	   bigger than the old one, we must have underflowed. */
 	if (diff < 0 && nlink > ip->i_inode.i_nlink) {
 		if (gfs2_consist_inode(ip))
 			gfs2_dinode_print(ip);
 		return -EIO;
 	}
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		return error;
 	if (diff > 0)
 		inc_nlink(&ip->i_inode);
 	else
 		drop_nlink(&ip->i_inode);
 	ip->i_inode.i_ctime = CURRENT_TIME;
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	gfs2_dinode_out(ip, dibh->b_data);
 	brelse(dibh);
 	mark_inode_dirty(&ip->i_inode);
 	if (ip->i_inode.i_nlink == 0)
 		gfs2_unlink_di(&ip->i_inode); /* mark inode unlinked */
 	return error;
 }
 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
 {
 	struct qstr qstr;
 	struct inode *inode;
 	gfs2_str2qstr(&qstr, name);
 	inode = gfs2_lookupi(dip, &qstr, 1);
 	/* gfs2_lookupi has inconsistent callers: vfs
 	 * related routines expect NULL for no entry found,
 	 * gfs2_lookup_simple callers expect ENOENT
 	 * and do not check for NULL.
 	 */
 	if (inode == NULL)
 		return ERR_PTR(-ENOENT);
 	else
 		return inode;
 }
 /**
  * gfs2_lookupi - Look up a filename in a directory and return its inode
  * @d_gh: An initialized holder for the directory glock
  * @name: The name of the inode to look for
  * @is_root: If 1, ignore the caller's permissions
  * @i_gh: An uninitialized holder for the new inode glock
  *
  * This can be called via the VFS filldir function when NFS is doing
  * a readdirplus and the inode which its intending to stat isn't
  * already in cache. In this case we must not take the directory glock
  * again, since the readdir call will have already taken that lock.
  *
  * Returns: errno
  */
 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 			   int is_root)
 {
 	struct super_block *sb = dir->i_sb;
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_holder d_gh;
 	int error = 0;
 	struct inode *inode = NULL;
 	int unlock = 0;
 	if (!name->len || name->len > GFS2_FNAMESIZE)
 		return ERR_PTR(-ENAMETOOLONG);
 	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
 	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
 	     dir == sb->s_root->d_inode)) {
 		igrab(dir);
 		return dir;
 	}
 	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
 		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 		if (error)
 			return ERR_PTR(error);
 		unlock = 1;
 	}
 	if (!is_root) {
 		error = gfs2_permission(dir, MAY_EXEC);
 		if (error)
 			goto out;
 	}
 	inode = gfs2_dir_search(dir, name);
 	if (IS_ERR(inode))
 		error = PTR_ERR(inode);
 out:
 	if (unlock)
 		gfs2_glock_dq_uninit(&d_gh);
 	if (error == -ENOENT)
 		return NULL;
 	return inode ? inode : ERR_PTR(error);
 }
 static void gfs2_inum_range_in(struct gfs2_inum_range_host *ir, const void *buf)
 {
 	const struct gfs2_inum_range *str = buf;
 	ir->ir_start = be64_to_cpu(str->ir_start);
 	ir->ir_length = be64_to_cpu(str->ir_length);
 }
 static void gfs2_inum_range_out(const struct gfs2_inum_range_host *ir, void *buf)
 {
 	struct gfs2_inum_range *str = buf;
 	str->ir_start = cpu_to_be64(ir->ir_start);
 	str->ir_length = cpu_to_be64(ir->ir_length);
 }
 static int pick_formal_ino_1(struct gfs2_sbd *sdp, u64 *formal_ino)
 {
 	struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
 	struct buffer_head *bh;
 	struct gfs2_inum_range_host ir;
 	int error;
 	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
 	if (error)
 		return error;
 	mutex_lock(&sdp->sd_inum_mutex);
 	error = gfs2_meta_inode_buffer(ip, &bh);
 	if (error) {
 		mutex_unlock(&sdp->sd_inum_mutex);
 		gfs2_trans_end(sdp);
 		return error;
 	}
 	gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 	if (ir.ir_length) {
 		*formal_ino = ir.ir_start++;
 		ir.ir_length--;
 		gfs2_trans_add_bh(ip->i_gl, bh, 1);
 		gfs2_inum_range_out(&ir,
 				    bh->b_data + sizeof(struct gfs2_dinode));
 		brelse(bh);
 		mutex_unlock(&sdp->sd_inum_mutex);
 		gfs2_trans_end(sdp);
 		return 0;
 	}
 	brelse(bh);
 	mutex_unlock(&sdp->sd_inum_mutex);
 	gfs2_trans_end(sdp);
 	return 1;
 }
 static int pick_formal_ino_2(struct gfs2_sbd *sdp, u64 *formal_ino)
 {
 	struct gfs2_inode *ip = GFS2_I(sdp->sd_ir_inode);
 	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_inum_inode);
 	struct gfs2_holder gh;
 	struct buffer_head *bh;
 	struct gfs2_inum_range_host ir;
 	int error;
 	error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 	if (error)
 		return error;
 	error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
 	if (error)
 		goto out;
 	mutex_lock(&sdp->sd_inum_mutex);
 	error = gfs2_meta_inode_buffer(ip, &bh);
 	if (error)
 		goto out_end_trans;
 	gfs2_inum_range_in(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 	if (!ir.ir_length) {
 		struct buffer_head *m_bh;
 		u64 x, y;
 		__be64 z;
 		error = gfs2_meta_inode_buffer(m_ip, &m_bh);
 		if (error)
 			goto out_brelse;
 		z = *(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode));
 		x = y = be64_to_cpu(z);
 		ir.ir_start = x;
 		ir.ir_length = GFS2_INUM_QUANTUM;
 		x += GFS2_INUM_QUANTUM;
 		if (x < y)
 			gfs2_consist_inode(m_ip);
 		z = cpu_to_be64(x);
 		gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
 		*(__be64 *)(m_bh->b_data + sizeof(struct gfs2_dinode)) = z;
 		brelse(m_bh);
 	}
 	*formal_ino = ir.ir_start++;
 	ir.ir_length--;
 	gfs2_trans_add_bh(ip->i_gl, bh, 1);
 	gfs2_inum_range_out(&ir, bh->b_data + sizeof(struct gfs2_dinode));
 out_brelse:
 	brelse(bh);
 out_end_trans:
 	mutex_unlock(&sdp->sd_inum_mutex);
 	gfs2_trans_end(sdp);
 out:
 	gfs2_glock_dq_uninit(&gh);
 	return error;
 }
 static int pick_formal_ino(struct gfs2_sbd *sdp, u64 *inum)
 {
 	int error;
 	error = pick_formal_ino_1(sdp, inum);
 	if (error <= 0)
 		return error;
 	error = pick_formal_ino_2(sdp, inum);
 	return error;
 }
 /**
  * create_ok - OK to create a new on-disk inode here?
  * @dip:  Directory in which dinode is to be created
  * @name:  Name of new dinode
  * @mode:
  *
  * Returns: errno
  */
 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 		     unsigned int mode)
 {
 	int error;
 	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 	if (error)
 		return error;
 	/*  Don't create entries in an unlinked directory  */
 	if (!dip->i_inode.i_nlink)
 		return -EPERM;
 	error = gfs2_dir_check(&dip->i_inode, name, NULL);
 	switch (error) {
 	case -ENOENT:
 		error = 0;
 		break;
 	case 0:
 		return -EEXIST;
 	default:
 		return error;
 	}
 	if (dip->i_di.di_entries == (u32)-1)
 		return -EFBIG;
 	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
 		return -EMLINK;
 	return 0;
 }
 static void munge_mode_uid_gid(struct gfs2_inode *dip, unsigned int *mode,
 			       unsigned int *uid, unsigned int *gid)
 {
 	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
 	    (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
 		if (S_ISDIR(*mode))
 			*mode |= S_ISUID;
 		else if (dip->i_inode.i_uid != current_fsuid())
 			*mode &= ~07111;
 		*uid = dip->i_inode.i_uid;
 	} else
 		*uid = current_fsuid();
 	if (dip->i_inode.i_mode & S_ISGID) {
 		if (S_ISDIR(*mode))
 			*mode |= S_ISGID;
 		*gid = dip->i_inode.i_gid;
 	} else
 		*gid = current_fsgid();
 }
 static int alloc_dinode(struct gfs2_inode *dip, u64 *no_addr, u64 *generation)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	int error;
 	if (gfs2_alloc_get(dip) == NULL)
 		return -ENOMEM;
 	dip->i_alloc->al_requested = RES_DINODE;
 	error = gfs2_inplace_reserve(dip);
 	if (error)
 		goto out;
 	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
 	if (error)
 		goto out_ipreserv;
 	*no_addr = gfs2_alloc_di(dip, generation);
 	gfs2_trans_end(sdp);
 out_ipreserv:
 	gfs2_inplace_release(dip);
 out:
 	gfs2_alloc_put(dip);
 	return error;
 }
 /**
  * init_dinode - Fill in a new dinode structure
  * @dip: the directory this inode is being created in
  * @gl: The glock covering the new inode
  * @inum: the inode number
  * @mode: the file permissions
  * @uid:
  * @gid:
  *
  */
 static void init_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
 			const struct gfs2_inum_host *inum, unsigned int mode,
 			unsigned int uid, unsigned int gid,
 			const u64 *generation, dev_t dev, struct buffer_head **bhp)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	struct gfs2_dinode *di;
 	struct buffer_head *dibh;
 	struct timespec tv = CURRENT_TIME;
 	dibh = gfs2_meta_new(gl, inum->no_addr);
 	gfs2_trans_add_bh(gl, dibh, 1);
 	gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
 	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 	di = (struct gfs2_dinode *)dibh->b_data;
 	di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
 	di->di_num.no_addr = cpu_to_be64(inum->no_addr);
 	di->di_mode = cpu_to_be32(mode);
 	di->di_uid = cpu_to_be32(uid);
 	di->di_gid = cpu_to_be32(gid);
 	di->di_nlink = 0;
 	di->di_size = 0;
 	di->di_blocks = cpu_to_be64(1);
 	di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
 	di->di_major = cpu_to_be32(MAJOR(dev));
 	di->di_minor = cpu_to_be32(MINOR(dev));
 	di->di_goal_meta = di->di_goal_data = cpu_to_be64(inum->no_addr);
 	di->di_generation = cpu_to_be64(*generation);
 	di->di_flags = 0;
 	if (S_ISREG(mode)) {
 		if ((dip->i_di.di_flags & GFS2_DIF_INHERIT_JDATA) ||
 		    gfs2_tune_get(sdp, gt_new_files_jdata))
 			di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 	} else if (S_ISDIR(mode)) {
 		di->di_flags |= cpu_to_be32(dip->i_di.di_flags &
 					    GFS2_DIF_INHERIT_JDATA);
 	}
 	di->__pad1 = 0;
 	di->di_payload_format = cpu_to_be32(S_ISDIR(mode) ? GFS2_FORMAT_DE : 0);
 	di->di_height = 0;
 	di->__pad2 = 0;
 	di->__pad3 = 0;
 	di->di_depth = 0;
 	di->di_entries = 0;
 	memset(&di->__pad4, 0, sizeof(di->__pad4));
 	di->di_eattr = 0;
 	di->di_atime_nsec = cpu_to_be32(tv.tv_nsec);
 	di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
 	di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
 	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
 	set_buffer_uptodate(dibh);
 	*bhp = dibh;
 }
 static int make_dinode(struct gfs2_inode *dip, struct gfs2_glock *gl,
 		       unsigned int mode, const struct gfs2_inum_host *inum,
 		       const u64 *generation, dev_t dev, struct buffer_head **bhp)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	unsigned int uid, gid;
 	int error;
 	munge_mode_uid_gid(dip, &mode, &uid, &gid);
 	if (!gfs2_alloc_get(dip))
 		return -ENOMEM;
 	error = gfs2_quota_lock(dip, uid, gid);
 	if (error)
 		goto out;
 	error = gfs2_quota_check(dip, uid, gid);
 	if (error)
 		goto out_quota;
 	error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
 	if (error)
 		goto out_quota;
 	init_dinode(dip, gl, inum, mode, uid, gid, generation, dev, bhp);
 	gfs2_quota_change(dip, +1, uid, gid);
 	gfs2_trans_end(sdp);
 out_quota:
 	gfs2_quota_unlock(dip);
 out:
 	gfs2_alloc_put(dip);
 	return error;
 }
 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
 		       struct gfs2_inode *ip)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	struct gfs2_alloc *al;
 	int alloc_required;
 	struct buffer_head *dibh;
 	int error;
 	al = gfs2_alloc_get(dip);
 	if (!al)
 		return -ENOMEM;
 	error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 	if (error)
 		goto fail;
 	error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
 	if (alloc_required < 0)
 		goto fail_quota_locks;
 	if (alloc_required) {
 		error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
 		if (error)
 			goto fail_quota_locks;
 		al->al_requested = sdp->sd_max_dirres;
 		error = gfs2_inplace_reserve(dip);
 		if (error)
 			goto fail_quota_locks;
 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 					 al->al_rgd->rd_length +
 					 2 * RES_DINODE +
 					 RES_STATFS + RES_QUOTA, 0);
 		if (error)
 			goto fail_ipreserv;
 	} else {
 		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
 		if (error)
 			goto fail_quota_locks;
 	}
 	error = gfs2_dir_add(&dip->i_inode, name, ip, IF2DT(ip->i_inode.i_mode));
 	if (error)
 		goto fail_end_trans;
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		goto fail_end_trans;
 	ip->i_inode.i_nlink = 1;
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	gfs2_dinode_out(ip, dibh->b_data);
 	brelse(dibh);
 	return 0;
 fail_end_trans:
 	gfs2_trans_end(sdp);
 fail_ipreserv:
 	if (dip->i_alloc->al_rgd)
 		gfs2_inplace_release(dip);
 fail_quota_locks:
 	gfs2_quota_unlock(dip);
 fail:
 	gfs2_alloc_put(dip);
 	return error;
 }
 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip)
 {
 	int err;
 	size_t len;
 	void *value;
 	char *name;
 	struct gfs2_ea_request er;
 	err = security_inode_init_security(&ip->i_inode, &dip->i_inode,
 					   &name, &value, &len);
 	if (err) {
 		if (err == -EOPNOTSUPP)
 			return 0;
 		return err;
 	}
 	memset(&er, 0, sizeof(struct gfs2_ea_request));
 	er.er_type = GFS2_EATYPE_SECURITY;
 	er.er_name = name;
 	er.er_data = value;
 	er.er_name_len = strlen(name);
 	er.er_data_len = len;
 	err = gfs2_ea_set_i(ip, &er);
 	kfree(value);
 	kfree(name);
 	return err;
 }
 /**
  * gfs2_createi - Create a new inode
  * @ghs: An array of two holders
  * @name: The name of the new file
  * @mode: the permissions on the new inode
  *
  * @ghs[0] is an initialized holder for the directory
  * @ghs[1] is the holder for the inode lock
  *
  * If the return value is not NULL, the glocks on both the directory and the new
  * file are held.  A transaction has been started and an inplace reservation
  * is held, as well.
  *
  * Returns: An inode
  */
 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
 			   unsigned int mode, dev_t dev)
 {
 	struct inode *inode = NULL;
 	struct gfs2_inode *dip = ghs->gh_gl->gl_object;
 	struct inode *dir = &dip->i_inode;
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	struct gfs2_inum_host inum = { .no_addr = 0, .no_formal_ino = 0 };
 	int error;
 	u64 generation;
 	struct buffer_head *bh = NULL;
 	if (!name->len || name->len > GFS2_FNAMESIZE)
 		return ERR_PTR(-ENAMETOOLONG);
 	gfs2_holder_reinit(LM_ST_EXCLUSIVE, 0, ghs);
 	error = gfs2_glock_nq(ghs);
 	if (error)
 		goto fail;
 	error = create_ok(dip, name, mode);
 	if (error)
 		goto fail_gunlock;
 	error = pick_formal_ino(sdp, &inum.no_formal_ino);
 	if (error)
 		goto fail_gunlock;
 	error = alloc_dinode(dip, &inum.no_addr, &generation);
 	if (error)
 		goto fail_gunlock;
 	error = gfs2_glock_nq_num(sdp, inum.no_addr, &gfs2_inode_glops,
 				  LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
 	if (error)
 		goto fail_gunlock;
 	error = make_dinode(dip, ghs[1].gh_gl, mode, &inum, &generation, dev, &bh);
 	if (error)
 		goto fail_gunlock2;
 	inode = gfs2_inode_lookup(dir->i_sb, IF2DT(mode),
 					inum.no_addr,
 					inum.no_formal_ino, 0);
 	if (IS_ERR(inode))
 		goto fail_gunlock2;
 	error = gfs2_inode_refresh(GFS2_I(inode));
 	if (error)
 		goto fail_gunlock2;
 	error = gfs2_acl_create(dip, GFS2_I(inode));
 	if (error)
 		goto fail_gunlock2;
 	error = gfs2_security_init(dip, GFS2_I(inode));
 	if (error)
 		goto fail_gunlock2;
 	error = link_dinode(dip, name, GFS2_I(inode));
 	if (error)
 		goto fail_gunlock2;
 	if (bh)
 		brelse(bh);
 	return inode;
 fail_gunlock2:
 	gfs2_glock_dq_uninit(ghs + 1);
 	if (inode && !IS_ERR(inode))
 		iput(inode);
 fail_gunlock:
 	gfs2_glock_dq(ghs);
 fail:
 	if (bh)
 		brelse(bh);
 	return ERR_PTR(error);
 }
 /**
  * gfs2_rmdiri - Remove a directory
  * @dip: The parent directory of the directory to be removed
  * @name: The name of the directory to be removed
  * @ip: The GFS2 inode of the directory to be removed
  *
  * Assumes Glocks on dip and ip are held
  *
  * Returns: errno
  */
 int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
 		struct gfs2_inode *ip)
 {
 	struct qstr dotname;
 	int error;
 	if (ip->i_di.di_entries != 2) {
 		if (gfs2_consist_inode(ip))
 			gfs2_dinode_print(ip);
 		return -EIO;
 	}
 	error = gfs2_dir_del(dip, name);
 	if (error)
 		return error;
 	error = gfs2_change_nlink(dip, -1);
 	if (error)
 		return error;
 	gfs2_str2qstr(&dotname, ".");
 	error = gfs2_dir_del(ip, &dotname);
 	if (error)
 		return error;
 	gfs2_str2qstr(&dotname, "..");
 	error = gfs2_dir_del(ip, &dotname);
 	if (error)
 		return error;
 	/* It looks odd, but it really should be done twice */
 	error = gfs2_change_nlink(ip, -1);
 	if (error)
 		return error;
 	error = gfs2_change_nlink(ip, -1);
 	if (error)
 		return error;
 	return error;
 }
 /*
  * gfs2_unlink_ok - check to see that a inode is still in a directory
  * @dip: the directory
  * @name: the name of the file
  * @ip: the inode
  *
  * Assumes that the lock on (at least) @dip is held.
  *
  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
  */
 int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 		   const struct gfs2_inode *ip)
 {
 	int error;
 	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
 		return -EPERM;
 	if ((dip->i_inode.i_mode & S_ISVTX) &&
 	    dip->i_inode.i_uid != current_fsuid() &&
 	    ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
 		return -EPERM;
 	if (IS_APPEND(&dip->i_inode))
 		return -EPERM;
 	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 	if (error)
 		return error;
 	error = gfs2_dir_check(&dip->i_inode, name, ip);
 	if (error)
 		return error;
 	return 0;
 }
 /**
  * gfs2_readlinki - return the contents of a symlink
  * @ip: the symlink's inode
  * @buf: a pointer to the buffer to be filled
  * @len: a pointer to the length of @buf
  *
  * If @buf is too small, a piece of memory is kmalloc()ed and needs
  * to be freed by the caller.
  *
  * Returns: errno
  */
 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
 {
 	struct gfs2_holder i_gh;
 	struct buffer_head *dibh;
 	unsigned int x;
 	int error;
 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
 	error = gfs2_glock_nq(&i_gh);
 	if (error) {
 		gfs2_holder_uninit(&i_gh);
 		return error;
 	}
 	if (!ip->i_di.di_size) {
 		gfs2_consist_inode(ip);
 		error = -EIO;
 		goto out;
 	}
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		goto out;
 	x = ip->i_di.di_size + 1;
 	if (x > *len) {
 		*buf = kmalloc(x, GFP_NOFS);
 		if (!*buf) {
 			error = -ENOMEM;
 			goto out_brelse;
 		}
 	}
 	memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
 	*len = x;
 out_brelse:
 	brelse(dibh);
 out:
 	gfs2_glock_dq_uninit(&i_gh);
 	return error;
 }
 static int
 __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
 {
 	struct buffer_head *dibh;
 	int error;
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (!error) {
 		error = inode_setattr(&ip->i_inode, attr);
 		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
 		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 		gfs2_dinode_out(ip, dibh->b_data);
 		brelse(dibh);
 	}
 	return error;
 }
 /**
  * gfs2_setattr_simple -
  * @ip:
  * @attr:
  *
  * Called with a reference on the vnode.
  *
  * Returns: errno
  */
 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
 {
 	int error;
 	if (current->journal_info)
 		return __gfs2_setattr_simple(ip, attr);
 	error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE, 0);
 	if (error)
 		return error;
 	error = __gfs2_setattr_simple(ip, attr);
 	gfs2_trans_end(GFS2_SB(&ip->i_inode));
 	return error;
 }
 void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
 {
 	const struct gfs2_dinode_host *di = &ip->i_di;
 	struct gfs2_dinode *str = buf;
 	str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
 	str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
 	str->di_header.__pad0 = 0;
 	str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
 	str->di_header.__pad1 = 0;
 	str->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
 	str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
 	str->di_mode = cpu_to_be32(ip->i_inode.i_mode);
 	str->di_uid = cpu_to_be32(ip->i_inode.i_uid);
 	str->di_gid = cpu_to_be32(ip->i_inode.i_gid);
 	str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink);
 	str->di_size = cpu_to_be64(di->di_size);
 	str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
 	str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec);
 	str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec);
 	str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec);
 	str->di_goal_meta = cpu_to_be64(ip->i_goal);
 	str->di_goal_data = cpu_to_be64(ip->i_goal);
 	str->di_generation = cpu_to_be64(di->di_generation);
 	str->di_flags = cpu_to_be32(di->di_flags);
 	str->di_height = cpu_to_be16(ip->i_height);
 	str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) &&
 					     !(ip->i_di.di_flags & GFS2_DIF_EXHASH) ?
 					     GFS2_FORMAT_DE : 0);
 	str->di_depth = cpu_to_be16(ip->i_depth);
 	str->di_entries = cpu_to_be32(di->di_entries);
 	str->di_eattr = cpu_to_be64(di->di_eattr);
 	str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
 	str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
 	str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
 }
 void gfs2_dinode_print(const struct gfs2_inode *ip)
 {
 	const struct gfs2_dinode_host *di = &ip->i_di;
 	printk(KERN_INFO "  no_formal_ino = %llu\n",
 	       (unsigned long long)ip->i_no_formal_ino);
 	printk(KERN_INFO "  no_addr = %llu\n",
 	       (unsigned long long)ip->i_no_addr);
 	printk(KERN_INFO "  di_size = %llu\n", (unsigned long long)di->di_size);
 	printk(KERN_INFO "  blocks = %llu\n",
 	       (unsigned long long)gfs2_get_inode_blocks(&ip->i_inode));
 	printk(KERN_INFO "  i_goal = %llu\n",
 	       (unsigned long long)ip->i_goal);
 	printk(KERN_INFO "  di_flags = 0x%.8X\n", di->di_flags);
 	printk(KERN_INFO "  i_height = %u\n", ip->i_height);
 	printk(KERN_INFO "  i_depth = %u\n", ip->i_depth);
 	printk(KERN_INFO "  di_entries = %u\n", di->di_entries);
 	printk(KERN_INFO "  di_eattr = %llu\n",
 	       (unsigned long long)di->di_eattr);
 }

fs/gfs2/inode.h

Diff comments View file @ b276058

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #ifndef __INODE_DOT_H__
 #define __INODE_DOT_H__
+#include <linux/fs.h>
 #include "util.h"
 static inline int gfs2_is_stuffed(const struct gfs2_inode *ip)
 {
 	return !ip->i_height;
 }
 static inline int gfs2_is_jdata(const struct gfs2_inode *ip)
 {
 	return ip->i_di.di_flags & GFS2_DIF_JDATA;
 }
 static inline int gfs2_is_writeback(const struct gfs2_inode *ip)
 {
 	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	return (sdp->sd_args.ar_data == GFS2_DATA_WRITEBACK) && !gfs2_is_jdata(ip);
 }
 static inline int gfs2_is_ordered(const struct gfs2_inode *ip)
 {
 	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	return (sdp->sd_args.ar_data == GFS2_DATA_ORDERED) && !gfs2_is_jdata(ip);
 }
 static inline int gfs2_is_dir(const struct gfs2_inode *ip)
 {
 	return S_ISDIR(ip->i_inode.i_mode);
 }
 static inline void gfs2_set_inode_blocks(struct inode *inode, u64 blocks)
 {
 	inode->i_blocks = blocks <<
 		(GFS2_SB(inode)->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT);
 }
 static inline u64 gfs2_get_inode_blocks(const struct inode *inode)
 {
 	return inode->i_blocks >>
 		(GFS2_SB(inode)->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT);
 }
 static inline void gfs2_add_inode_blocks(struct inode *inode, s64 change)
 {
 	gfs2_assert(GFS2_SB(inode), (change >= 0 || inode->i_blocks > -change));
 	change *= (GFS2_SB(inode)->sd_sb.sb_bsize/GFS2_BASIC_BLOCK);
 	inode->i_blocks += change;
 }
 static inline int gfs2_check_inum(const struct gfs2_inode *ip, u64 no_addr,
 				  u64 no_formal_ino)
 {
 	return ip->i_no_addr == no_addr && ip->i_no_formal_ino == no_formal_ino;
 }
 static inline void gfs2_inum_out(const struct gfs2_inode *ip,
 				 struct gfs2_dirent *dent)
 {
 	dent->de_inum.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
 	dent->de_inum.no_addr = cpu_to_be64(ip->i_no_addr);
 }
 void gfs2_set_iop(struct inode *inode);
 struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned type,
 				u64 no_addr, u64 no_formal_ino,
 				int skip_freeing);
 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr);
 int gfs2_inode_refresh(struct gfs2_inode *ip);
 int gfs2_dinode_dealloc(struct gfs2_inode *inode);
 int gfs2_change_nlink(struct gfs2_inode *ip, int diff);
 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 			   int is_root);
 struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
 			   unsigned int mode, dev_t dev);
 int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
 		struct gfs2_inode *ip);
 int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 		   const struct gfs2_inode *ip);
 int gfs2_permission(struct inode *inode, int mask);
 int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len);
 int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr);
 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
 void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf);
 void gfs2_dinode_print(const struct gfs2_inode *ip);
+extern const struct inode_operations gfs2_file_iops;
+extern const struct inode_operations gfs2_dir_iops;
+extern const struct inode_operations gfs2_symlink_iops;
+extern const struct file_operations gfs2_file_fops;
+extern const struct file_operations gfs2_dir_fops;
+extern const struct file_operations gfs2_file_fops_nolock;
+extern const struct file_operations gfs2_dir_fops_nolock;
+extern void gfs2_set_inode_flags(struct inode *inode);
 #endif /* __INODE_DOT_H__ */

fs/gfs2/main.c

Diff comments View file @ b276058

1	/*	1	/*
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*	4	*
5	* This copyrighted material is made available to anyone wishing to use,	5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions	6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.	7	* of the GNU General Public License version 2.
8	*/	8	*/
9		9
10	#include <linux/slab.h>	10	#include <linux/slab.h>
11	#include <linux/spinlock.h>	11	#include <linux/spinlock.h>
12	#include <linux/completion.h>	12	#include <linux/completion.h>
13	#include <linux/buffer_head.h>	13	#include <linux/buffer_head.h>
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/init.h>	15	#include <linux/init.h>
16	#include <linux/gfs2_ondisk.h>	16	#include <linux/gfs2_ondisk.h>
17	#include <linux/lm_interface.h>	17	#include <linux/lm_interface.h>
18	#include <asm/atomic.h>	18	#include <asm/atomic.h>
19		19
20	#include "gfs2.h"	20	#include "gfs2.h"
21	#include "incore.h"	21	#include "incore.h"
22	#include "ops_fstype.h"	22	#include "super.h"
23	#include "sys.h"	23	#include "sys.h"
24	#include "util.h"	24	#include "util.h"
25	#include "glock.h"	25	#include "glock.h"
26		26
27	static void gfs2_init_inode_once(void *foo)	27	static void gfs2_init_inode_once(void *foo)
28	{	28	{
29	struct gfs2_inode *ip = foo;	29	struct gfs2_inode *ip = foo;
30		30
31	inode_init_once(&ip->i_inode);	31	inode_init_once(&ip->i_inode);
32	init_rwsem(&ip->i_rw_mutex);	32	init_rwsem(&ip->i_rw_mutex);
33	ip->i_alloc = NULL;	33	ip->i_alloc = NULL;
34	}	34	}
35		35
36	static void gfs2_init_glock_once(void *foo)	36	static void gfs2_init_glock_once(void *foo)
37	{	37	{
38	struct gfs2_glock *gl = foo;	38	struct gfs2_glock *gl = foo;
39		39
40	INIT_HLIST_NODE(&gl->gl_list);	40	INIT_HLIST_NODE(&gl->gl_list);
41	spin_lock_init(&gl->gl_spin);	41	spin_lock_init(&gl->gl_spin);
42	INIT_LIST_HEAD(&gl->gl_holders);	42	INIT_LIST_HEAD(&gl->gl_holders);
43	gl->gl_lvb = NULL;	43	gl->gl_lvb = NULL;
44	atomic_set(&gl->gl_lvb_count, 0);	44	atomic_set(&gl->gl_lvb_count, 0);
45	INIT_LIST_HEAD(&gl->gl_reclaim);	45	INIT_LIST_HEAD(&gl->gl_reclaim);
46	INIT_LIST_HEAD(&gl->gl_ail_list);	46	INIT_LIST_HEAD(&gl->gl_ail_list);
47	atomic_set(&gl->gl_ail_count, 0);	47	atomic_set(&gl->gl_ail_count, 0);
48	}	48	}
49		49
50	/**	50	/**
51	* init_gfs2_fs - Register GFS2 as a filesystem	51	* init_gfs2_fs - Register GFS2 as a filesystem
52	*	52	*
53	* Returns: 0 on success, error code on failure	53	* Returns: 0 on success, error code on failure
54	*/	54	*/
55		55
56	static int __init init_gfs2_fs(void)	56	static int __init init_gfs2_fs(void)
57	{	57	{
58	int error;	58	int error;
59		59
60	error = gfs2_sys_init();	60	error = gfs2_sys_init();
61	if (error)	61	if (error)
62	return error;	62	return error;
63		63
64	error = gfs2_glock_init();	64	error = gfs2_glock_init();
65	if (error)	65	if (error)
66	goto fail;	66	goto fail;
67		67
68	error = -ENOMEM;	68	error = -ENOMEM;
69	gfs2_glock_cachep = kmem_cache_create("gfs2_glock",	69	gfs2_glock_cachep = kmem_cache_create("gfs2_glock",
70	sizeof(struct gfs2_glock),	70	sizeof(struct gfs2_glock),
71	0, 0,	71	0, 0,
72	gfs2_init_glock_once);	72	gfs2_init_glock_once);
73	if (!gfs2_glock_cachep)	73	if (!gfs2_glock_cachep)
74	goto fail;	74	goto fail;
75		75
76	gfs2_inode_cachep = kmem_cache_create("gfs2_inode",	76	gfs2_inode_cachep = kmem_cache_create("gfs2_inode",
77	sizeof(struct gfs2_inode),	77	sizeof(struct gfs2_inode),
78	0, SLAB_RECLAIM_ACCOUNT\|	78	0, SLAB_RECLAIM_ACCOUNT\|
79	SLAB_MEM_SPREAD,	79	SLAB_MEM_SPREAD,
80	gfs2_init_inode_once);	80	gfs2_init_inode_once);
81	if (!gfs2_inode_cachep)	81	if (!gfs2_inode_cachep)
82	goto fail;	82	goto fail;
83		83
84	gfs2_bufdata_cachep = kmem_cache_create("gfs2_bufdata",	84	gfs2_bufdata_cachep = kmem_cache_create("gfs2_bufdata",
85	sizeof(struct gfs2_bufdata),	85	sizeof(struct gfs2_bufdata),
86	0, 0, NULL);	86	0, 0, NULL);
87	if (!gfs2_bufdata_cachep)	87	if (!gfs2_bufdata_cachep)
88	goto fail;	88	goto fail;
89		89
90	gfs2_rgrpd_cachep = kmem_cache_create("gfs2_rgrpd",	90	gfs2_rgrpd_cachep = kmem_cache_create("gfs2_rgrpd",
91	sizeof(struct gfs2_rgrpd),	91	sizeof(struct gfs2_rgrpd),
92	0, 0, NULL);	92	0, 0, NULL);
93	if (!gfs2_rgrpd_cachep)	93	if (!gfs2_rgrpd_cachep)
94	goto fail;	94	goto fail;
95		95
96	error = register_filesystem(&gfs2_fs_type);	96	error = register_filesystem(&gfs2_fs_type);
97	if (error)	97	if (error)
98	goto fail;	98	goto fail;
99		99
100	error = register_filesystem(&gfs2meta_fs_type);	100	error = register_filesystem(&gfs2meta_fs_type);
101	if (error)	101	if (error)
102	goto fail_unregister;	102	goto fail_unregister;
103		103
104	gfs2_register_debugfs();	104	gfs2_register_debugfs();
105		105
106	printk("GFS2 (built %s %s) installed\n", __DATE__, __TIME__);	106	printk("GFS2 (built %s %s) installed\n", __DATE__, __TIME__);
107		107
108	return 0;	108	return 0;
109		109
110	fail_unregister:	110	fail_unregister:
111	unregister_filesystem(&gfs2_fs_type);	111	unregister_filesystem(&gfs2_fs_type);
112	fail:	112	fail:
113	gfs2_glock_exit();	113	gfs2_glock_exit();
114		114
115	if (gfs2_rgrpd_cachep)	115	if (gfs2_rgrpd_cachep)
116	kmem_cache_destroy(gfs2_rgrpd_cachep);	116	kmem_cache_destroy(gfs2_rgrpd_cachep);
117		117
118	if (gfs2_bufdata_cachep)	118	if (gfs2_bufdata_cachep)
119	kmem_cache_destroy(gfs2_bufdata_cachep);	119	kmem_cache_destroy(gfs2_bufdata_cachep);
120		120
121	if (gfs2_inode_cachep)	121	if (gfs2_inode_cachep)
122	kmem_cache_destroy(gfs2_inode_cachep);	122	kmem_cache_destroy(gfs2_inode_cachep);
123		123
124	if (gfs2_glock_cachep)	124	if (gfs2_glock_cachep)
125	kmem_cache_destroy(gfs2_glock_cachep);	125	kmem_cache_destroy(gfs2_glock_cachep);
126		126
127	gfs2_sys_uninit();	127	gfs2_sys_uninit();
128	return error;	128	return error;
129	}	129	}
130		130
131	/**	131	/**
132	* exit_gfs2_fs - Unregister the file system	132	* exit_gfs2_fs - Unregister the file system
133	*	133	*
134	*/	134	*/
135		135
136	static void __exit exit_gfs2_fs(void)	136	static void __exit exit_gfs2_fs(void)
137	{	137	{
138	gfs2_glock_exit();	138	gfs2_glock_exit();
139	gfs2_unregister_debugfs();	139	gfs2_unregister_debugfs();
140	unregister_filesystem(&gfs2_fs_type);	140	unregister_filesystem(&gfs2_fs_type);
141	unregister_filesystem(&gfs2meta_fs_type);	141	unregister_filesystem(&gfs2meta_fs_type);
142		142
143	kmem_cache_destroy(gfs2_rgrpd_cachep);	143	kmem_cache_destroy(gfs2_rgrpd_cachep);
144	kmem_cache_destroy(gfs2_bufdata_cachep);	144	kmem_cache_destroy(gfs2_bufdata_cachep);
145	kmem_cache_destroy(gfs2_inode_cachep);	145	kmem_cache_destroy(gfs2_inode_cachep);
146	kmem_cache_destroy(gfs2_glock_cachep);	146	kmem_cache_destroy(gfs2_glock_cachep);
147		147
148	gfs2_sys_uninit();	148	gfs2_sys_uninit();
149	}	149	}
150		150
151	MODULE_DESCRIPTION("Global File System");	151	MODULE_DESCRIPTION("Global File System");
152	MODULE_AUTHOR("Red Hat, Inc.");	152	MODULE_AUTHOR("Red Hat, Inc.");
153	MODULE_LICENSE("GPL");	153	MODULE_LICENSE("GPL");
154		154
155	module_init(init_gfs2_fs);	155	module_init(init_gfs2_fs);
156	module_exit(exit_gfs2_fs);	156	module_exit(exit_gfs2_fs);
157		157
158		158

fs/gfs2/ops_dentry.c

Diff comments View file @ b276058

1	/*	1	/*
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*	4	*
5	* This copyrighted material is made available to anyone wishing to use,	5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions	6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.	7	* of the GNU General Public License version 2.
8	*/	8	*/
9		9
10	#include <linux/slab.h>	10	#include <linux/slab.h>
11	#include <linux/spinlock.h>	11	#include <linux/spinlock.h>
12	#include <linux/completion.h>	12	#include <linux/completion.h>
13	#include <linux/buffer_head.h>	13	#include <linux/buffer_head.h>
14	#include <linux/gfs2_ondisk.h>	14	#include <linux/gfs2_ondisk.h>
15	#include <linux/crc32.h>	15	#include <linux/crc32.h>
16	#include <linux/lm_interface.h>	16	#include <linux/lm_interface.h>
17		17
18	#include "gfs2.h"	18	#include "gfs2.h"
19	#include "incore.h"	19	#include "incore.h"
20	#include "dir.h"	20	#include "dir.h"
21	#include "glock.h"	21	#include "glock.h"
22	#include "ops_dentry.h"	22	#include "super.h"
23	#include "util.h"	23	#include "util.h"
24	#include "inode.h"	24	#include "inode.h"
25		25
26	/**	26	/**
27	* gfs2_drevalidate - Check directory lookup consistency	27	* gfs2_drevalidate - Check directory lookup consistency
28	* @dentry: the mapping to check	28	* @dentry: the mapping to check
29	* @nd:	29	* @nd:
30	*	30	*
31	* Check to make sure the lookup necessary to arrive at this inode from its	31	* Check to make sure the lookup necessary to arrive at this inode from its
32	* parent is still good.	32	* parent is still good.
33	*	33	*
34	* Returns: 1 if the dentry is ok, 0 if it isn't	34	* Returns: 1 if the dentry is ok, 0 if it isn't
35	*/	35	*/
36		36
37	static int gfs2_drevalidate(struct dentry dentry, struct nameidata nd)	37	static int gfs2_drevalidate(struct dentry dentry, struct nameidata nd)
38	{	38	{
39	struct dentry *parent = dget_parent(dentry);	39	struct dentry *parent = dget_parent(dentry);
40	struct gfs2_sbd *sdp = GFS2_SB(parent->d_inode);	40	struct gfs2_sbd *sdp = GFS2_SB(parent->d_inode);
41	struct gfs2_inode *dip = GFS2_I(parent->d_inode);	41	struct gfs2_inode *dip = GFS2_I(parent->d_inode);
42	struct inode *inode = dentry->d_inode;	42	struct inode *inode = dentry->d_inode;
43	struct gfs2_holder d_gh;	43	struct gfs2_holder d_gh;
44	struct gfs2_inode *ip = NULL;	44	struct gfs2_inode *ip = NULL;
45	int error;	45	int error;
46	int had_lock = 0;	46	int had_lock = 0;
47		47
48	if (inode) {	48	if (inode) {
49	if (is_bad_inode(inode))	49	if (is_bad_inode(inode))
50	goto invalid;	50	goto invalid;
51	ip = GFS2_I(inode);	51	ip = GFS2_I(inode);
52	}	52	}
53		53
54	if (sdp->sd_args.ar_localcaching)	54	if (sdp->sd_args.ar_localcaching)
55	goto valid;	55	goto valid;
56		56
57	had_lock = (gfs2_glock_is_locked_by_me(dip->i_gl) != NULL);	57	had_lock = (gfs2_glock_is_locked_by_me(dip->i_gl) != NULL);
58	if (!had_lock) {	58	if (!had_lock) {
59	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);	59	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
60	if (error)	60	if (error)
61	goto fail;	61	goto fail;
62	}	62	}
63		63
64	error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip);	64	error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip);
65	switch (error) {	65	switch (error) {
66	case 0:	66	case 0:
67	if (!inode)	67	if (!inode)
68	goto invalid_gunlock;	68	goto invalid_gunlock;
69	break;	69	break;
70	case -ENOENT:	70	case -ENOENT:
71	if (!inode)	71	if (!inode)
72	goto valid_gunlock;	72	goto valid_gunlock;
73	goto invalid_gunlock;	73	goto invalid_gunlock;
74	default:	74	default:
75	goto fail_gunlock;	75	goto fail_gunlock;
76	}	76	}
77		77
78	valid_gunlock:	78	valid_gunlock:
79	if (!had_lock)	79	if (!had_lock)
80	gfs2_glock_dq_uninit(&d_gh);	80	gfs2_glock_dq_uninit(&d_gh);
81	valid:	81	valid:
82	dput(parent);	82	dput(parent);
83	return 1;	83	return 1;
84		84
85	invalid_gunlock:	85	invalid_gunlock:
86	if (!had_lock)	86	if (!had_lock)
87	gfs2_glock_dq_uninit(&d_gh);	87	gfs2_glock_dq_uninit(&d_gh);
88	invalid:	88	invalid:
89	if (inode && S_ISDIR(inode->i_mode)) {	89	if (inode && S_ISDIR(inode->i_mode)) {
90	if (have_submounts(dentry))	90	if (have_submounts(dentry))
91	goto valid;	91	goto valid;
92	shrink_dcache_parent(dentry);	92	shrink_dcache_parent(dentry);
93	}	93	}
94	d_drop(dentry);	94	d_drop(dentry);
95	dput(parent);	95	dput(parent);
96	return 0;	96	return 0;
97		97
98	fail_gunlock:	98	fail_gunlock:
99	gfs2_glock_dq_uninit(&d_gh);	99	gfs2_glock_dq_uninit(&d_gh);
100	fail:	100	fail:
101	dput(parent);	101	dput(parent);
102	return 0;	102	return 0;
103	}	103	}
104		104
105	static int gfs2_dhash(struct dentry dentry, struct qstr str)	105	static int gfs2_dhash(struct dentry dentry, struct qstr str)
106	{	106	{
107	str->hash = gfs2_disk_hash(str->name, str->len);	107	str->hash = gfs2_disk_hash(str->name, str->len);
108	return 0;	108	return 0;
109	}	109	}
110		110
111	struct dentry_operations gfs2_dops = {	111	struct dentry_operations gfs2_dops = {
112	.d_revalidate = gfs2_drevalidate,	112	.d_revalidate = gfs2_drevalidate,
113	.d_hash = gfs2_dhash,	113	.d_hash = gfs2_dhash,
114	};	114	};
115		115
116		116

fs/gfs2/ops_dentry.h

View file @ b276058

1	/*		File was deleted
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*
5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.
8	*/
9
10	#ifndef __OPS_DENTRY_DOT_H__
11	#define __OPS_DENTRY_DOT_H__
12
13	#include <linux/dcache.h>
14
15	extern struct dentry_operations gfs2_dops;
16
17	#endif /* __OPS_DENTRY_DOT_H__ */
18		1	/*

fs/gfs2/ops_export.c

Diff comments View file @ b276058

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/exportfs.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
 #include <linux/lm_interface.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "dir.h"
 #include "glock.h"
 #include "glops.h"
 #include "inode.h"
-#include "ops_dentry.h"
+#include "super.h"
-#include "ops_fstype.h"
 #include "rgrp.h"
 #include "util.h"
 #define GFS2_SMALL_FH_SIZE 4
 #define GFS2_LARGE_FH_SIZE 8
 #define GFS2_OLD_FH_SIZE 10
 static int gfs2_encode_fh(struct dentry *dentry, __u32 *p, int *len,
 			  int connectable)
 {
 	__be32 *fh = (__force __be32 *)p;
 	struct inode *inode = dentry->d_inode;
 	struct super_block *sb = inode->i_sb;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	if (*len < GFS2_SMALL_FH_SIZE ||
 	    (connectable && *len < GFS2_LARGE_FH_SIZE))
 		return 255;
 	fh[0] = cpu_to_be32(ip->i_no_formal_ino >> 32);
 	fh[1] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF);
 	fh[2] = cpu_to_be32(ip->i_no_addr >> 32);
 	fh[3] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF);
 	*len = GFS2_SMALL_FH_SIZE;
 	if (!connectable || inode == sb->s_root->d_inode)
 		return *len;
 	spin_lock(&dentry->d_lock);
 	inode = dentry->d_parent->d_inode;
 	ip = GFS2_I(inode);
 	igrab(inode);
 	spin_unlock(&dentry->d_lock);
 	fh[4] = cpu_to_be32(ip->i_no_formal_ino >> 32);
 	fh[5] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF);
 	fh[6] = cpu_to_be32(ip->i_no_addr >> 32);
 	fh[7] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF);
 	*len = GFS2_LARGE_FH_SIZE;
 	iput(inode);
 	return *len;
 }
 struct get_name_filldir {
 	struct gfs2_inum_host inum;
 	char *name;
 };
 static int get_name_filldir(void *opaque, const char *name, int length,
 			    loff_t offset, u64 inum, unsigned int type)
 {
 	struct get_name_filldir *gnfd = opaque;
 	if (inum != gnfd->inum.no_addr)
 		return 0;
 	memcpy(gnfd->name, name, length);
 	gnfd->name[length] = 0;
 	return 1;
 }
 static int gfs2_get_name(struct dentry *parent, char *name,
 			 struct dentry *child)
 {
 	struct inode *dir = parent->d_inode;
 	struct inode *inode = child->d_inode;
 	struct gfs2_inode *dip, *ip;
 	struct get_name_filldir gnfd;
 	struct gfs2_holder gh;
 	u64 offset = 0;
 	int error;
 	if (!dir)
 		return -EINVAL;
 	if (!S_ISDIR(dir->i_mode) || !inode)
 		return -EINVAL;
 	dip = GFS2_I(dir);
 	ip = GFS2_I(inode);
 	*name = 0;
 	gnfd.inum.no_addr = ip->i_no_addr;
 	gnfd.inum.no_formal_ino = ip->i_no_formal_ino;
 	gnfd.name = name;
 	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh);
 	if (error)
 		return error;
 	error = gfs2_dir_read(dir, &offset, &gnfd, get_name_filldir);
 	gfs2_glock_dq_uninit(&gh);
 	if (!error && !*name)
 		error = -ENOENT;
 	return error;
 }
 static struct dentry *gfs2_get_parent(struct dentry *child)
 {
 	struct qstr dotdot;
 	struct dentry *dentry;
 	/*
 	 * XXX(hch): it would be a good idea to keep this around as a
 	 *	     static variable.
 	 */
 	gfs2_str2qstr(&dotdot, "..");
 	dentry = d_obtain_alias(gfs2_lookupi(child->d_inode, &dotdot, 1));
 	if (!IS_ERR(dentry))
 		dentry->d_op = &gfs2_dops;
 	return dentry;
 }
 static struct dentry *gfs2_get_dentry(struct super_block *sb,
 		struct gfs2_inum_host *inum)
 {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
 	struct gfs2_holder i_gh, ri_gh, rgd_gh;
 	struct gfs2_rgrpd *rgd;
 	struct inode *inode;
 	struct dentry *dentry;
 	int error;
 	/* System files? */
 	inode = gfs2_ilookup(sb, inum->no_addr);
 	if (inode) {
 		if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) {
 			iput(inode);
 			return ERR_PTR(-ESTALE);
 		}
 		goto out_inode;
 	}
 	error = gfs2_glock_nq_num(sdp, inum->no_addr, &gfs2_inode_glops,
 				  LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
 	if (error)
 		return ERR_PTR(error);
 	error = gfs2_rindex_hold(sdp, &ri_gh);
 	if (error)
 		goto fail;
 	error = -EINVAL;
 	rgd = gfs2_blk2rgrpd(sdp, inum->no_addr);
 	if (!rgd)
 		goto fail_rindex;
 	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
 	if (error)
 		goto fail_rindex;
 	error = -ESTALE;
 	if (gfs2_get_block_type(rgd, inum->no_addr) != GFS2_BLKST_DINODE)
 		goto fail_rgd;
 	gfs2_glock_dq_uninit(&rgd_gh);
 	gfs2_glock_dq_uninit(&ri_gh);
 	inode = gfs2_inode_lookup(sb, DT_UNKNOWN,
 					inum->no_addr,
 					0, 0);
 	if (IS_ERR(inode)) {
 		error = PTR_ERR(inode);
 		goto fail;
 	}
 	error = gfs2_inode_refresh(GFS2_I(inode));
 	if (error) {
 		iput(inode);
 		goto fail;
 	}
 	/* Pick up the works we bypass in gfs2_inode_lookup */
 	if (inode->i_state & I_NEW)
 		gfs2_set_iop(inode);
 	if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) {
 		iput(inode);
 		goto fail;
 	}
 	error = -EIO;
 	if (GFS2_I(inode)->i_di.di_flags & GFS2_DIF_SYSTEM) {
 		iput(inode);
 		goto fail;
 	}
 	gfs2_glock_dq_uninit(&i_gh);
 out_inode:
 	dentry = d_obtain_alias(inode);
 	if (!IS_ERR(dentry))
 		dentry->d_op = &gfs2_dops;
 	return dentry;
 fail_rgd:
 	gfs2_glock_dq_uninit(&rgd_gh);
 fail_rindex:
 	gfs2_glock_dq_uninit(&ri_gh);
 fail:
 	gfs2_glock_dq_uninit(&i_gh);
 	return ERR_PTR(error);
 }
 static struct dentry *gfs2_fh_to_dentry(struct super_block *sb, struct fid *fid,
 		int fh_len, int fh_type)
 {
 	struct gfs2_inum_host this;
 	__be32 *fh = (__force __be32 *)fid->raw;
 	switch (fh_type) {
 	case GFS2_SMALL_FH_SIZE:
 	case GFS2_LARGE_FH_SIZE:
 	case GFS2_OLD_FH_SIZE:
 		this.no_formal_ino = ((u64)be32_to_cpu(fh[0])) << 32;
 		this.no_formal_ino |= be32_to_cpu(fh[1]);
 		this.no_addr = ((u64)be32_to_cpu(fh[2])) << 32;
 		this.no_addr |= be32_to_cpu(fh[3]);
 		return gfs2_get_dentry(sb, &this);
 	default:
 		return NULL;
 	}
 }
 static struct dentry *gfs2_fh_to_parent(struct super_block *sb, struct fid *fid,
 		int fh_len, int fh_type)
 {
 	struct gfs2_inum_host parent;
 	__be32 *fh = (__force __be32 *)fid->raw;
 	switch (fh_type) {
 	case GFS2_LARGE_FH_SIZE:
 	case GFS2_OLD_FH_SIZE:
 		parent.no_formal_ino = ((u64)be32_to_cpu(fh[4])) << 32;
 		parent.no_formal_ino |= be32_to_cpu(fh[5]);
 		parent.no_addr = ((u64)be32_to_cpu(fh[6])) << 32;
 		parent.no_addr |= be32_to_cpu(fh[7]);
 		return gfs2_get_dentry(sb, &parent);
 	default:
 		return NULL;
 	}
 }
 const struct export_operations gfs2_export_ops = {
 	.encode_fh = gfs2_encode_fh,
 	.fh_to_dentry = gfs2_fh_to_dentry,
 	.fh_to_parent = gfs2_fh_to_parent,
 	.get_name = gfs2_get_name,
 	.get_parent = gfs2_get_parent,
 };

fs/gfs2/ops_file.c

Diff comments View file @ b276058

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/pagemap.h>
 #include <linux/uio.h>
 #include <linux/blkdev.h>
 #include <linux/mm.h>
 #include <linux/mount.h>
 #include <linux/fs.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/ext2_fs.h>
 #include <linux/crc32.h>
 #include <linux/lm_interface.h>
 #include <linux/writeback.h>
 #include <asm/uaccess.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "bmap.h"
 #include "dir.h"
 #include "glock.h"
 #include "glops.h"
 #include "inode.h"
 #include "log.h"
 #include "meta_io.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "trans.h"
 #include "util.h"
 #include "eaops.h"
 #include "ops_address.h"
-#include "ops_inode.h"
 /**
  * gfs2_llseek - seek to a location in a file
  * @file: the file
  * @offset: the offset
  * @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
  *
  * SEEK_END requires the glock for the file because it references the
  * file's size.
  *
  * Returns: The new offset, or errno
  */
 static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
 {
 	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
 	struct gfs2_holder i_gh;
 	loff_t error;
 	if (origin == 2) {
 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
 					   &i_gh);
 		if (!error) {
 			error = generic_file_llseek_unlocked(file, offset, origin);
 			gfs2_glock_dq_uninit(&i_gh);
 		}
 	} else
 		error = generic_file_llseek_unlocked(file, offset, origin);
 	return error;
 }
 /**
  * gfs2_readdir - Read directory entries from a directory
  * @file: The directory to read from
  * @dirent: Buffer for dirents
  * @filldir: Function used to do the copying
  *
  * Returns: errno
  */
 static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
 {
 	struct inode *dir = file->f_mapping->host;
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_holder d_gh;
 	u64 offset = file->f_pos;
 	int error;
 	gfs2_holder_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 	error = gfs2_glock_nq(&d_gh);
 	if (error) {
 		gfs2_holder_uninit(&d_gh);
 		return error;
 	}
 	error = gfs2_dir_read(dir, &offset, dirent, filldir);
 	gfs2_glock_dq_uninit(&d_gh);
 	file->f_pos = offset;
 	return error;
 }
 /**
  * fsflags_cvt
  * @table: A table of 32 u32 flags
  * @val: a 32 bit value to convert
  *
  * This function can be used to convert between fsflags values and
  * GFS2's own flags values.
  *
  * Returns: the converted flags
  */
 static u32 fsflags_cvt(const u32 *table, u32 val)
 {
 	u32 res = 0;
 	while(val) {
 		if (val & 1)
 			res |= *table;
 		table++;
 		val >>= 1;
 	}
 	return res;
 }
 static const u32 fsflags_to_gfs2[32] = {
 	[3] = GFS2_DIF_SYNC,
 	[4] = GFS2_DIF_IMMUTABLE,
 	[5] = GFS2_DIF_APPENDONLY,
 	[7] = GFS2_DIF_NOATIME,
 	[12] = GFS2_DIF_EXHASH,
 	[14] = GFS2_DIF_INHERIT_JDATA,
 };
 static const u32 gfs2_to_fsflags[32] = {
 	[gfs2fl_Sync] = FS_SYNC_FL,
 	[gfs2fl_Immutable] = FS_IMMUTABLE_FL,
 	[gfs2fl_AppendOnly] = FS_APPEND_FL,
 	[gfs2fl_NoAtime] = FS_NOATIME_FL,
 	[gfs2fl_ExHash] = FS_INDEX_FL,
 	[gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
 };
 static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
 {
 	struct inode *inode = filp->f_path.dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int error;
 	u32 fsflags;
 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
 	error = gfs2_glock_nq(&gh);
 	if (error)
 		return error;
 	fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_di.di_flags);
 	if (!S_ISDIR(inode->i_mode) && ip->i_di.di_flags & GFS2_DIF_JDATA)
 		fsflags |= FS_JOURNAL_DATA_FL;
 	if (put_user(fsflags, ptr))
 		error = -EFAULT;
 	gfs2_glock_dq(&gh);
 	gfs2_holder_uninit(&gh);
 	return error;
 }
 void gfs2_set_inode_flags(struct inode *inode)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_dinode_host *di = &ip->i_di;
 	unsigned int flags = inode->i_flags;
 	flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
 	if (di->di_flags & GFS2_DIF_IMMUTABLE)
 		flags |= S_IMMUTABLE;
 	if (di->di_flags & GFS2_DIF_APPENDONLY)
 		flags |= S_APPEND;
 	if (di->di_flags & GFS2_DIF_NOATIME)
 		flags |= S_NOATIME;
 	if (di->di_flags & GFS2_DIF_SYNC)
 		flags |= S_SYNC;
 	inode->i_flags = flags;
 }
 /* Flags that can be set by user space */
 #define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA|			\
 			     GFS2_DIF_IMMUTABLE|		\
 			     GFS2_DIF_APPENDONLY|		\
 			     GFS2_DIF_NOATIME|			\
 			     GFS2_DIF_SYNC|			\
 			     GFS2_DIF_SYSTEM|			\
 			     GFS2_DIF_INHERIT_JDATA)
 /**
  * gfs2_set_flags - set flags on an inode
  * @inode: The inode
  * @flags: The flags to set
  * @mask: Indicates which flags are valid
  *
  */
 static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
 {
 	struct inode *inode = filp->f_path.dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	struct buffer_head *bh;
 	struct gfs2_holder gh;
 	int error;
 	u32 new_flags, flags;
 	error = mnt_want_write(filp->f_path.mnt);
 	if (error)
 		return error;
 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 	if (error)
 		goto out_drop_write;
 	flags = ip->i_di.di_flags;
 	new_flags = (flags & ~mask) | (reqflags & mask);
 	if ((new_flags ^ flags) == 0)
 		goto out;
 	error = -EINVAL;
 	if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
 		goto out;
 	error = -EPERM;
 	if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
 		goto out;
 	if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
 		goto out;
 	if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
 	    !capable(CAP_LINUX_IMMUTABLE))
 		goto out;
 	if (!IS_IMMUTABLE(inode)) {
 		error = gfs2_permission(inode, MAY_WRITE);
 		if (error)
 			goto out;
 	}
 	if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
 		if (flags & GFS2_DIF_JDATA)
 			gfs2_log_flush(sdp, ip->i_gl);
 		error = filemap_fdatawrite(inode->i_mapping);
 		if (error)
 			goto out;
 		error = filemap_fdatawait(inode->i_mapping);
 		if (error)
 			goto out;
 	}
 	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
 	if (error)
 		goto out;
 	error = gfs2_meta_inode_buffer(ip, &bh);
 	if (error)
 		goto out_trans_end;
 	gfs2_trans_add_bh(ip->i_gl, bh, 1);
 	ip->i_di.di_flags = new_flags;
 	gfs2_dinode_out(ip, bh->b_data);
 	brelse(bh);
 	gfs2_set_inode_flags(inode);
 	gfs2_set_aops(inode);
 out_trans_end:
 	gfs2_trans_end(sdp);
 out:
 	gfs2_glock_dq_uninit(&gh);
 out_drop_write:
 	mnt_drop_write(filp->f_path.mnt);
 	return error;
 }
 static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
 {
 	struct inode *inode = filp->f_path.dentry->d_inode;
 	u32 fsflags, gfsflags;
 	if (get_user(fsflags, ptr))
 		return -EFAULT;
 	gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
 	if (!S_ISDIR(inode->i_mode)) {
 		if (gfsflags & GFS2_DIF_INHERIT_JDATA)
 			gfsflags ^= (GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA);
 		return do_gfs2_set_flags(filp, gfsflags, ~0);
 	}
 	return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA);
 }
 static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
 	switch(cmd) {
 	case FS_IOC_GETFLAGS:
 		return gfs2_get_flags(filp, (u32 __user *)arg);
 	case FS_IOC_SETFLAGS:
 		return gfs2_set_flags(filp, (u32 __user *)arg);
 	}
 	return -ENOTTY;
 }
 /**
  * gfs2_allocate_page_backing - Use bmap to allocate blocks
  * @page: The (locked) page to allocate backing for
  *
  * We try to allocate all the blocks required for the page in
  * one go. This might fail for various reasons, so we keep
  * trying until all the blocks to back this page are allocated.
  * If some of the blocks are already allocated, thats ok too.
  */
 static int gfs2_allocate_page_backing(struct page *page)
 {
 	struct inode *inode = page->mapping->host;
 	struct buffer_head bh;
 	unsigned long size = PAGE_CACHE_SIZE;
 	u64 lblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
 	do {
 		bh.b_state = 0;
 		bh.b_size = size;
 		gfs2_block_map(inode, lblock, &bh, 1);
 		if (!buffer_mapped(&bh))
 			return -EIO;
 		size -= bh.b_size;
 		lblock += (bh.b_size >> inode->i_blkbits);
 	} while(size > 0);
 	return 0;
 }
 /**
  * gfs2_page_mkwrite - Make a shared, mmap()ed, page writable
  * @vma: The virtual memory area
  * @page: The page which is about to become writable
  *
  * When the page becomes writable, we need to ensure that we have
  * blocks allocated on disk to back that page.
  */
 static int gfs2_page_mkwrite(struct vm_area_struct *vma, struct page *page)
 {
 	struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	unsigned long last_index;
 	u64 pos = page->index << (PAGE_CACHE_SIZE - inode->i_blkbits);
 	unsigned int data_blocks, ind_blocks, rblocks;
 	int alloc_required = 0;
 	struct gfs2_holder gh;
 	struct gfs2_alloc *al;
 	int ret;
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 	ret = gfs2_glock_nq(&gh);
 	if (ret)
 		goto out;
 	set_bit(GIF_SW_PAGED, &ip->i_flags);
 	gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks);
 	ret = gfs2_write_alloc_required(ip, pos, PAGE_CACHE_SIZE, &alloc_required);
 	if (ret || !alloc_required)
 		goto out_unlock;
 	ret = -ENOMEM;
 	al = gfs2_alloc_get(ip);
 	if (al == NULL)
 		goto out_unlock;
 	ret = gfs2_quota_lock_check(ip);
 	if (ret)
 		goto out_alloc_put;
 	al->al_requested = data_blocks + ind_blocks;
 	ret = gfs2_inplace_reserve(ip);
 	if (ret)
 		goto out_quota_unlock;
 	rblocks = RES_DINODE + ind_blocks;
 	if (gfs2_is_jdata(ip))
 		rblocks += data_blocks ? data_blocks : 1;
 	if (ind_blocks || data_blocks)
 		rblocks += RES_STATFS + RES_QUOTA;
 	ret = gfs2_trans_begin(sdp, rblocks, 0);
 	if (ret)
 		goto out_trans_fail;
 	lock_page(page);
 	ret = -EINVAL;
 	last_index = ip->i_inode.i_size >> PAGE_CACHE_SHIFT;
 	if (page->index > last_index)
 		goto out_unlock_page;
 	ret = 0;
 	if (!PageUptodate(page) || page->mapping != ip->i_inode.i_mapping)
 		goto out_unlock_page;
 	if (gfs2_is_stuffed(ip)) {
 		ret = gfs2_unstuff_dinode(ip, page);
 		if (ret)
 			goto out_unlock_page;
 	}
 	ret = gfs2_allocate_page_backing(page);
 out_unlock_page:
 	unlock_page(page);
 	gfs2_trans_end(sdp);
 out_trans_fail:
 	gfs2_inplace_release(ip);
 out_quota_unlock:
 	gfs2_quota_unlock(ip);
 out_alloc_put:
 	gfs2_alloc_put(ip);
 out_unlock:
 	gfs2_glock_dq(&gh);
 out:
 	gfs2_holder_uninit(&gh);
 	return ret;
 }
 static struct vm_operations_struct gfs2_vm_ops = {
 	.fault = filemap_fault,
 	.page_mkwrite = gfs2_page_mkwrite,
 };
 /**
  * gfs2_mmap -
  * @file: The file to map
  * @vma: The VMA which described the mapping
  *
  * Returns: 0 or error code
  */
 static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
 	struct gfs2_holder i_gh;
 	int error;
 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
 	error = gfs2_glock_nq(&i_gh);
 	if (error) {
 		gfs2_holder_uninit(&i_gh);
 		return error;
 	}
 	vma->vm_ops = &gfs2_vm_ops;
 	gfs2_glock_dq_uninit(&i_gh);
 	return error;
 }
 /**
  * gfs2_open - open a file
  * @inode: the inode to open
  * @file: the struct file for this opening
  *
  * Returns: errno
  */
 static int gfs2_open(struct inode *inode, struct file *file)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder i_gh;
 	struct gfs2_file *fp;
 	int error;
 	fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
 	if (!fp)
 		return -ENOMEM;
 	mutex_init(&fp->f_fl_mutex);
 	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
 	file->private_data = fp;
 	if (S_ISREG(ip->i_inode.i_mode)) {
 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
 					   &i_gh);
 		if (error)
 			goto fail;
 		if (!(file->f_flags & O_LARGEFILE) &&
 		    ip->i_di.di_size > MAX_NON_LFS) {
 			error = -EOVERFLOW;
 			goto fail_gunlock;
 		}
 		gfs2_glock_dq_uninit(&i_gh);
 	}
 	return 0;
 fail_gunlock:
 	gfs2_glock_dq_uninit(&i_gh);
 fail:
 	file->private_data = NULL;
 	kfree(fp);
 	return error;
 }
 /**
  * gfs2_close - called to close a struct file
  * @inode: the inode the struct file belongs to
  * @file: the struct file being closed
  *
  * Returns: errno
  */
 static int gfs2_close(struct inode *inode, struct file *file)
 {
 	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
 	struct gfs2_file *fp;
 	fp = file->private_data;
 	file->private_data = NULL;
 	if (gfs2_assert_warn(sdp, fp))
 		return -EIO;
 	kfree(fp);
 	return 0;
 }
 /**
  * gfs2_fsync - sync the dirty data for a file (across the cluster)
  * @file: the file that points to the dentry (we ignore this)
  * @dentry: the dentry that points to the inode to sync
  *
  * The VFS will flush "normal" data for us. We only need to worry
  * about metadata here. For journaled data, we just do a log flush
  * as we can't avoid it. Otherwise we can just bale out if datasync
  * is set. For stuffed inodes we must flush the log in order to
  * ensure that all data is on disk.
  *
  * The call to write_inode_now() is there to write back metadata and
  * the inode itself. It does also try and write the data, but thats
  * (hopefully) a no-op due to the VFS having already called filemap_fdatawrite()
  * for us.
  *
  * Returns: errno
  */
 static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
 {
 	struct inode *inode = dentry->d_inode;
 	int sync_state = inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC);
 	int ret = 0;
 	if (gfs2_is_jdata(GFS2_I(inode))) {
 		gfs2_log_flush(GFS2_SB(inode), GFS2_I(inode)->i_gl);
 		return 0;
 	}
 	if (sync_state != 0) {
 		if (!datasync)
 			ret = write_inode_now(inode, 0);
 		if (gfs2_is_stuffed(GFS2_I(inode)))
 			gfs2_log_flush(GFS2_SB(inode), GFS2_I(inode)->i_gl);
 	}
 	return ret;
 }
 /**
  * gfs2_setlease - acquire/release a file lease
  * @file: the file pointer
  * @arg: lease type
  * @fl: file lock
  *
  * Returns: errno
  */
 static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
 	/*
 	 * We don't currently have a way to enforce a lease across the whole
 	 * cluster; until we do, disable leases (by just returning -EINVAL),
 	 * unless the administrator has requested purely local locking.
 	 */
 	if (!sdp->sd_args.ar_localflocks)
 		return -EINVAL;
 	return generic_setlease(file, arg, fl);
 }
 static int gfs2_lm_plock_get(struct gfs2_sbd *sdp, struct lm_lockname *name,
 		      struct file *file, struct file_lock *fl)
 {
 	int error = -EIO;
 	if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 		error = sdp->sd_lockstruct.ls_ops->lm_plock_get(
 				sdp->sd_lockstruct.ls_lockspace, name, file, fl);
 	return error;
 }
 static int gfs2_lm_plock(struct gfs2_sbd *sdp, struct lm_lockname *name,
 		  struct file *file, int cmd, struct file_lock *fl)
 {
 	int error = -EIO;
 	if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 		error = sdp->sd_lockstruct.ls_ops->lm_plock(
 				sdp->sd_lockstruct.ls_lockspace, name, file, cmd, fl);
 	return error;
 }
 static int gfs2_lm_punlock(struct gfs2_sbd *sdp, struct lm_lockname *name,
 		    struct file *file, struct file_lock *fl)
 {
 	int error = -EIO;
 	if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 		error = sdp->sd_lockstruct.ls_ops->lm_punlock(
 				sdp->sd_lockstruct.ls_lockspace, name, file, fl);
 	return error;
 }
 /**
  * gfs2_lock - acquire/release a posix lock on a file
  * @file: the file pointer
  * @cmd: either modify or retrieve lock state, possibly wait
  * @fl: type and range of lock
  *
  * Returns: errno
  */
 static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
 {
 	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
 	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
 	struct lm_lockname name =
 		{ .ln_number = ip->i_no_addr,
 		  .ln_type = LM_TYPE_PLOCK };
 	if (!(fl->fl_flags & FL_POSIX))
 		return -ENOLCK;
 	if (__mandatory_lock(&ip->i_inode))
 		return -ENOLCK;
 	if (cmd == F_CANCELLK) {
 		/* Hack: */
 		cmd = F_SETLK;
 		fl->fl_type = F_UNLCK;
 	}
 	if (IS_GETLK(cmd))
 		return gfs2_lm_plock_get(sdp, &name, file, fl);
 	else if (fl->fl_type == F_UNLCK)
 		return gfs2_lm_punlock(sdp, &name, file, fl);
 	else
 		return gfs2_lm_plock(sdp, &name, file, cmd, fl);
 }
 static int do_flock(struct file *file, int cmd, struct file_lock *fl)
 {
 	struct gfs2_file *fp = file->private_data;
 	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
 	struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
 	struct gfs2_glock *gl;
 	unsigned int state;
 	int flags;
 	int error = 0;
 	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
 	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;
 	mutex_lock(&fp->f_fl_mutex);
 	gl = fl_gh->gh_gl;
 	if (gl) {
 		if (fl_gh->gh_state == state)
 			goto out;
 		flock_lock_file_wait(file,
 				     &(struct file_lock){.fl_type = F_UNLCK});
 		gfs2_glock_dq_wait(fl_gh);
 		gfs2_holder_reinit(state, flags, fl_gh);
 	} else {
 		error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,
 				       &gfs2_flock_glops, CREATE, &gl);
 		if (error)
 			goto out;
 		gfs2_holder_init(gl, state, flags, fl_gh);
 		gfs2_glock_put(gl);
 	}
 	error = gfs2_glock_nq(fl_gh);
 	if (error) {
 		gfs2_holder_uninit(fl_gh);
 		if (error == GLR_TRYFAILED)
 			error = -EAGAIN;
 	} else {
 		error = flock_lock_file_wait(file, fl);
 		gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
 	}
 out:
 	mutex_unlock(&fp->f_fl_mutex);
 	return error;
 }
 static void do_unflock(struct file *file, struct file_lock *fl)
 {
 	struct gfs2_file *fp = file->private_data;
 	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
 	mutex_lock(&fp->f_fl_mutex);
 	flock_lock_file_wait(file, fl);
 	if (fl_gh->gh_gl)
 		gfs2_glock_dq_uninit(fl_gh);
 	mutex_unlock(&fp->f_fl_mutex);
 }
 /**
  * gfs2_flock - acquire/release a flock lock on a file
  * @file: the file pointer
  * @cmd: either modify or retrieve lock state, possibly wait
  * @fl: type and range of lock
  *
  * Returns: errno
  */
 static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
 {
 	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
 	if (!(fl->fl_flags & FL_FLOCK))
 		return -ENOLCK;
 	if (__mandatory_lock(&ip->i_inode))
 		return -ENOLCK;
 	if (fl->fl_type == F_UNLCK) {
 		do_unflock(file, fl);
 		return 0;
 	} else {
 		return do_flock(file, cmd, fl);
 	}
 }
 const struct file_operations gfs2_file_fops = {
 	.llseek		= gfs2_llseek,
 	.read		= do_sync_read,
 	.aio_read	= generic_file_aio_read,
 	.write		= do_sync_write,
 	.aio_write	= generic_file_aio_write,
 	.unlocked_ioctl	= gfs2_ioctl,
 	.mmap		= gfs2_mmap,
 	.open		= gfs2_open,
 	.release	= gfs2_close,
 	.fsync		= gfs2_fsync,
 	.lock		= gfs2_lock,
 	.flock		= gfs2_flock,
 	.splice_read	= generic_file_splice_read,
 	.splice_write	= generic_file_splice_write,
 	.setlease	= gfs2_setlease,
 };
 const struct file_operations gfs2_dir_fops = {
 	.readdir	= gfs2_readdir,
 	.unlocked_ioctl	= gfs2_ioctl,
 	.open		= gfs2_open,
 	.release	= gfs2_close,
 	.fsync		= gfs2_fsync,
 	.lock		= gfs2_lock,
 	.flock		= gfs2_flock,
 };
 const struct file_operations gfs2_file_fops_nolock = {
 	.llseek		= gfs2_llseek,
 	.read		= do_sync_read,
 	.aio_read	= generic_file_aio_read,
 	.write		= do_sync_write,
 	.aio_write	= generic_file_aio_write,
 	.unlocked_ioctl	= gfs2_ioctl,
 	.mmap		= gfs2_mmap,
 	.open		= gfs2_open,
 	.release	= gfs2_close,
 	.fsync		= gfs2_fsync,
 	.splice_read	= generic_file_splice_read,
 	.splice_write	= generic_file_splice_write,
 	.setlease	= gfs2_setlease,
 };
 const struct file_operations gfs2_dir_fops_nolock = {
 	.readdir	= gfs2_readdir,
 	.unlocked_ioctl	= gfs2_ioctl,
 	.open		= gfs2_open,
 	.release	= gfs2_close,
 	.fsync		= gfs2_fsync,
 };

fs/gfs2/ops_fstype.c

Diff comments View file @ b276058

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #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>
 #include <linux/namei.h>
 #include <linux/mount.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/lm_interface.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "bmap.h"
 #include "daemon.h"
 #include "glock.h"
 #include "glops.h"
 #include "inode.h"
 #include "mount.h"
-#include "ops_fstype.h"
-#include "ops_dentry.h"
-#include "ops_super.h"
 #include "recovery.h"
 #include "rgrp.h"
 #include "super.h"
 #include "sys.h"
 #include "util.h"
 #include "log.h"
 #define DO 0
 #define UNDO 1
 static const u32 gfs2_old_fs_formats[] = {
         0
 };
 static const u32 gfs2_old_multihost_formats[] = {
         0
 };
 /**
  * gfs2_tune_init - Fill a gfs2_tune structure with default values
  * @gt: tune
  *
  */
 static void gfs2_tune_init(struct gfs2_tune *gt)
 {
 	spin_lock_init(&gt->gt_spin);
 	gt->gt_demote_secs = 300;
 	gt->gt_incore_log_blocks = 1024;
 	gt->gt_log_flush_secs = 60;
 	gt->gt_recoverd_secs = 60;
 	gt->gt_logd_secs = 1;
 	gt->gt_quotad_secs = 5;
 	gt->gt_quota_simul_sync = 64;
 	gt->gt_quota_warn_period = 10;
 	gt->gt_quota_scale_num = 1;
 	gt->gt_quota_scale_den = 1;
 	gt->gt_quota_cache_secs = 300;
 	gt->gt_quota_quantum = 60;
 	gt->gt_new_files_jdata = 0;
 	gt->gt_max_readahead = 1 << 18;
 	gt->gt_stall_secs = 600;
 	gt->gt_complain_secs = 10;
 	gt->gt_statfs_quantum = 30;
 	gt->gt_statfs_slow = 0;
 }
 static struct gfs2_sbd *init_sbd(struct super_block *sb)
 {
 	struct gfs2_sbd *sdp;
 	sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
 	if (!sdp)
 		return NULL;
 	sb->s_fs_info = sdp;
 	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);
 	mutex_init(&sdp->sd_inum_mutex);
 	spin_lock_init(&sdp->sd_statfs_spin);
 	spin_lock_init(&sdp->sd_rindex_spin);
 	mutex_init(&sdp->sd_rindex_mutex);
 	INIT_LIST_HEAD(&sdp->sd_rindex_list);
 	INIT_LIST_HEAD(&sdp->sd_rindex_mru_list);
 	INIT_LIST_HEAD(&sdp->sd_jindex_list);
 	spin_lock_init(&sdp->sd_jindex_spin);
 	mutex_init(&sdp->sd_jindex_mutex);
 	INIT_LIST_HEAD(&sdp->sd_quota_list);
 	spin_lock_init(&sdp->sd_quota_spin);
 	mutex_init(&sdp->sd_quota_mutex);
 	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);
 	INIT_LIST_HEAD(&sdp->sd_log_le_ordered);
 	mutex_init(&sdp->sd_log_reserve_mutex);
 	INIT_LIST_HEAD(&sdp->sd_ail1_list);
 	INIT_LIST_HEAD(&sdp->sd_ail2_list);
 	init_rwsem(&sdp->sd_log_flush_lock);
 	atomic_set(&sdp->sd_log_in_flight, 0);
 	init_waitqueue_head(&sdp->sd_log_flush_wait);
 	INIT_LIST_HEAD(&sdp->sd_revoke_list);
 	mutex_init(&sdp->sd_freeze_lock);
 	return sdp;
 }
 /**
  * gfs2_check_sb - Check superblock
  * @sdp: the filesystem
  * @sb: The superblock
  * @silent: Don't print a message if the check fails
  *
  * Checks the version code of the FS is one that we understand how to
  * read and that the sizes of the various on-disk structures have not
  * changed.
  */
 static int gfs2_check_sb(struct gfs2_sbd *sdp, struct gfs2_sb_host *sb, int silent)
 {
 	unsigned int x;
 	if (sb->sb_magic != GFS2_MAGIC ||
 	    sb->sb_type != GFS2_METATYPE_SB) {
 		if (!silent)
 			printk(KERN_WARNING "GFS2: not a GFS2 filesystem\n");
 		return -EINVAL;
 	}
 	/*  If format numbers match exactly, we're done.  */
 	if (sb->sb_fs_format == GFS2_FORMAT_FS &&
 	    sb->sb_multihost_format == GFS2_FORMAT_MULTI)
 		return 0;
 	if (sb->sb_fs_format != GFS2_FORMAT_FS) {
 		for (x = 0; gfs2_old_fs_formats[x]; x++)
 			if (gfs2_old_fs_formats[x] == sb->sb_fs_format)
 				break;
 		if (!gfs2_old_fs_formats[x]) {
 			printk(KERN_WARNING
 			       "GFS2: code version (%u, %u) is incompatible "
 			       "with ondisk format (%u, %u)\n",
 			       GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
 			       sb->sb_fs_format, sb->sb_multihost_format);
 			printk(KERN_WARNING
 			       "GFS2: I don't know how to upgrade this FS\n");
 			return -EINVAL;
 		}
 	}
 	if (sb->sb_multihost_format != GFS2_FORMAT_MULTI) {
 		for (x = 0; gfs2_old_multihost_formats[x]; x++)
 			if (gfs2_old_multihost_formats[x] ==
 			    sb->sb_multihost_format)
 				break;
 		if (!gfs2_old_multihost_formats[x]) {
 			printk(KERN_WARNING
 			       "GFS2: code version (%u, %u) is incompatible "
 			       "with ondisk format (%u, %u)\n",
 			       GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
 			       sb->sb_fs_format, sb->sb_multihost_format);
 			printk(KERN_WARNING
 			       "GFS2: I don't know how to upgrade this FS\n");
 			return -EINVAL;
 		}
 	}
 	if (!sdp->sd_args.ar_upgrade) {
 		printk(KERN_WARNING
 		       "GFS2: code version (%u, %u) is incompatible "
 		       "with ondisk format (%u, %u)\n",
 		       GFS2_FORMAT_FS, GFS2_FORMAT_MULTI,
 		       sb->sb_fs_format, sb->sb_multihost_format);
 		printk(KERN_INFO
 		       "GFS2: Use the \"upgrade\" mount option to upgrade "
 		       "the FS\n");
 		printk(KERN_INFO "GFS2: See the manual for more details\n");
 		return -EINVAL;
 	}
 	return 0;
 }
 static void end_bio_io_page(struct bio *bio, int error)
 {
 	struct page *page = bio->bi_private;
 	if (!error)
 		SetPageUptodate(page);
 	else
 		printk(KERN_WARNING "gfs2: error %d reading superblock\n", error);
 	unlock_page(page);
 }
 static void gfs2_sb_in(struct gfs2_sb_host *sb, const void *buf)
 {
 	const struct gfs2_sb *str = buf;
 	sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
 	sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
 	sb->sb_format = be32_to_cpu(str->sb_header.mh_format);
 	sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
 	sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
 	sb->sb_bsize = be32_to_cpu(str->sb_bsize);
 	sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
 	sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
 	sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
 	sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
 	sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
 	memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
 	memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
 }
 /**
  * gfs2_read_super - Read the gfs2 super block from disk
  * @sdp: The GFS2 super block
  * @sector: The location of the super block
  * @error: The error code to return
  *
  * This uses the bio functions to read the super block from disk
  * because we want to be 100% sure that we never read cached data.
  * A super block is read twice only during each GFS2 mount and is
  * never written to by the filesystem. The first time its read no
  * locks are held, and the only details which are looked at are those
  * relating to the locking protocol. Once locking is up and working,
  * the sb is read again under the lock to establish the location of
  * the master directory (contains pointers to journals etc) and the
  * root directory.
  *
  * Returns: 0 on success or error
  */
 static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector)
 {
 	struct super_block *sb = sdp->sd_vfs;
 	struct gfs2_sb *p;
 	struct page *page;
 	struct bio *bio;
 	page = alloc_page(GFP_NOFS);
 	if (unlikely(!page))
 		return -ENOBUFS;
 	ClearPageUptodate(page);
 	ClearPageDirty(page);
 	lock_page(page);
 	bio = bio_alloc(GFP_NOFS, 1);
 	if (unlikely(!bio)) {
 		__free_page(page);
 		return -ENOBUFS;
 	}
 	bio->bi_sector = sector * (sb->s_blocksize >> 9);
 	bio->bi_bdev = sb->s_bdev;
 	bio_add_page(bio, page, PAGE_SIZE, 0);
 	bio->bi_end_io = end_bio_io_page;
 	bio->bi_private = page;
 	submit_bio(READ_SYNC | (1 << BIO_RW_META), bio);
 	wait_on_page_locked(page);
 	bio_put(bio);
 	if (!PageUptodate(page)) {
 		__free_page(page);
 		return -EIO;
 	}
 	p = kmap(page);
 	gfs2_sb_in(&sdp->sd_sb, p);
 	kunmap(page);
 	__free_page(page);
 	return 0;
 }
 /**
  * gfs2_read_sb - Read super block
  * @sdp: The GFS2 superblock
  * @gl: the glock for the superblock (assumed to be held)
  * @silent: Don't print message if mount fails
  *
  */
 static int gfs2_read_sb(struct gfs2_sbd *sdp, struct gfs2_glock *gl, int silent)
 {
 	u32 hash_blocks, ind_blocks, leaf_blocks;
 	u32 tmp_blocks;
 	unsigned int x;
 	int error;
 	error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
 	if (error) {
 		if (!silent)
 			fs_err(sdp, "can't read superblock\n");
 		return error;
 	}
 	error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
 	if (error)
 		return error;
 	sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
 			       GFS2_BASIC_BLOCK_SHIFT;
 	sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
 	sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
 			  sizeof(struct gfs2_dinode)) / sizeof(u64);
 	sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
 			  sizeof(struct gfs2_meta_header)) / sizeof(u64);
 	sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
 	sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
 	sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
 	sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
 	sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
 				sizeof(struct gfs2_meta_header)) /
 			        sizeof(struct gfs2_quota_change);
 	/* Compute maximum reservation required to add a entry to a directory */
 	hash_blocks = DIV_ROUND_UP(sizeof(u64) * (1 << GFS2_DIR_MAX_DEPTH),
 			     sdp->sd_jbsize);
 	ind_blocks = 0;
 	for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
 		tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
 		ind_blocks += tmp_blocks;
 	}
 	leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
 	sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
 	sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
 				sizeof(struct gfs2_dinode);
 	sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
 	for (x = 2;; x++) {
 		u64 space, d;
 		u32 m;
 		space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
 		d = space;
 		m = do_div(d, sdp->sd_inptrs);
 		if (d != sdp->sd_heightsize[x - 1] || m)
 			break;
 		sdp->sd_heightsize[x] = space;
 	}
 	sdp->sd_max_height = x;
 	sdp->sd_heightsize[x] = ~0;
 	gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
 	sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize -
 				 sizeof(struct gfs2_dinode);
 	sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
 	for (x = 2;; x++) {
 		u64 space, d;
 		u32 m;
 		space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
 		d = space;
 		m = do_div(d, sdp->sd_inptrs);
 		if (d != sdp->sd_jheightsize[x - 1] || m)
 			break;
 		sdp->sd_jheightsize[x] = space;
 	}
 	sdp->sd_max_jheight = x;
 	sdp->sd_jheightsize[x] = ~0;
 	gfs2_assert(sdp, sdp->sd_max_jheight <= GFS2_MAX_META_HEIGHT);
 	return 0;
 }
 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]) {
 		error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
 		if (error)
 			return error;
 		error = gfs2_check_sb(sdp, &sdp->sd_sb, silent);
 		if (error)
 			goto out;
 		if (!proto[0])
 			proto = sdp->sd_sb.sb_lockproto;
 		if (!table[0])
 			table = sdp->sd_sb.sb_locktable;
 	}
 	if (!table[0])
 		table = sdp->sd_vfs->s_id;
 	strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
 	strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
 	table = sdp->sd_table_name;
 	while ((table = strchr(table, '/')))
 		*table = '_';
 out:
 	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,
 				  LM_FLAG_NOEXP | GL_EXACT,
 				  &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;
 fail_trans:
 	gfs2_glock_put(sdp->sd_trans_gl);
 fail_rename:
 	gfs2_glock_put(sdp->sd_rename_gl);
 fail_live:
 	gfs2_glock_dq_uninit(&sdp->sd_live_gh);
 fail_mount:
 	gfs2_glock_dq_uninit(mount_gh);
 fail:
 	while (sdp->sd_glockd_num--)
 		kthread_stop(sdp->sd_glockd_process[sdp->sd_glockd_num]);
 	return error;
 }
 static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
 			    u64 no_addr, const char *name)
 {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
 	struct dentry *dentry;
 	struct inode *inode;
 	inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0, 0);
 	if (IS_ERR(inode)) {
 		fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
 		return PTR_ERR(inode);
 	}
 	dentry = d_alloc_root(inode);
 	if (!dentry) {
 		fs_err(sdp, "can't alloc %s dentry\n", name);
 		iput(inode);
 		return -ENOMEM;
 	}
 	dentry->d_op = &gfs2_dops;
 	*dptr = dentry;
 	return 0;
 }
 static int init_sb(struct gfs2_sbd *sdp, int silent)
 {
 	struct super_block *sb = sdp->sd_vfs;
 	struct gfs2_holder sb_gh;
 	u64 no_addr;
 	int ret;
 	ret = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
 				LM_ST_SHARED, 0, &sb_gh);
 	if (ret) {
 		fs_err(sdp, "can't acquire superblock glock: %d\n", ret);
 		return ret;
 	}
 	ret = gfs2_read_sb(sdp, sb_gh.gh_gl, silent);
 	if (ret) {
 		fs_err(sdp, "can't read superblock: %d\n", ret);
 		goto out;
 	}
 	/* Set up the buffer cache and SB for real */
 	if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) {
 		ret = -EINVAL;
 		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) {
 		ret = -EINVAL;
 		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);
 	/* Get the root inode */
 	no_addr = sdp->sd_sb.sb_root_dir.no_addr;
 	ret = gfs2_lookup_root(sb, &sdp->sd_root_dir, no_addr, "root");
 	if (ret)
 		goto out;
 	/* Get the master inode */
 	no_addr = sdp->sd_sb.sb_master_dir.no_addr;
 	ret = gfs2_lookup_root(sb, &sdp->sd_master_dir, no_addr, "master");
 	if (ret) {
 		dput(sdp->sd_root_dir);
 		goto out;
 	}
 	sb->s_root = dget(sdp->sd_args.ar_meta ? sdp->sd_master_dir : sdp->sd_root_dir);
 out:
 	gfs2_glock_dq_uninit(&sb_gh);
 	return ret;
 }
 /**
  * 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;
 	for (lb = 0; lb < ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift; lb++) {
 		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;
 }
 static void gfs2_lm_others_may_mount(struct gfs2_sbd *sdp)
 {
 	if (!sdp->sd_lockstruct.ls_ops->lm_others_may_mount)
 		return;
 	if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 		sdp->sd_lockstruct.ls_ops->lm_others_may_mount(
 					sdp->sd_lockstruct.ls_lockspace);
 }
 static int init_journal(struct gfs2_sbd *sdp, int undo)
 {
 	struct inode *master = sdp->sd_master_dir->d_inode;
 	struct gfs2_holder ji_gh;
 	struct task_struct *p;
 	struct gfs2_inode *ip;
 	int jindex = 1;
 	int error = 0;
 	if (undo) {
 		jindex = 0;
 		goto fail_recoverd;
 	}
 	sdp->sd_jindex = gfs2_lookup_simple(master, "jindex");
 	if (IS_ERR(sdp->sd_jindex)) {
 		fs_err(sdp, "can't lookup journal index: %d\n", error);
 		return PTR_ERR(sdp->sd_jindex);
 	}
 	ip = GFS2_I(sdp->sd_jindex);
 	set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 	/* 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");
 		goto fail_jindex;
 	}
 	if (sdp->sd_args.ar_spectator) {
 		sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
 		atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
 	} 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);
 		error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
 					  &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;
 		}
 		ip = GFS2_I(sdp->sd_jdesc->jd_inode);
 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
 					   LM_FLAG_NOEXP | GL_EXACT | GL_NOCACHE,
 					   &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;
 		}
 		atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
 		/* Map the extents for this journal's blocks */
 		map_journal_extents(sdp);
 	}
 	if (sdp->sd_lockstruct.ls_first) {
 		unsigned int x;
 		for (x = 0; x < sdp->sd_journals; x++) {
 			error = gfs2_recover_journal(gfs2_jdesc_find(sdp, x));
 			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) {
 		error = gfs2_recover_journal(sdp->sd_jdesc);
 		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;
 fail_recoverd:
 	kthread_stop(sdp->sd_recoverd_process);
 fail_jinode_gh:
 	if (!sdp->sd_args.ar_spectator)
 		gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
 fail_journal_gh:
 	if (!sdp->sd_args.ar_spectator)
 		gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
 fail_jindex:
 	gfs2_jindex_free(sdp);
 	if (jindex)
 		gfs2_glock_dq_uninit(&ji_gh);
 fail:
 	iput(sdp->sd_jindex);
 	return error;
 }
 static int init_inodes(struct gfs2_sbd *sdp, int undo)
 {
 	int error = 0;
 	struct gfs2_inode *ip;
 	struct inode *master = sdp->sd_master_dir->d_inode;
 	if (undo)
 		goto fail_qinode;
 	error = init_journal(sdp, undo);
 	if (error)
 		goto fail;
 	/* Read in the master inode number inode */
 	sdp->sd_inum_inode = gfs2_lookup_simple(master, "inum");
 	if (IS_ERR(sdp->sd_inum_inode)) {
 		error = PTR_ERR(sdp->sd_inum_inode);
 		fs_err(sdp, "can't read in inum inode: %d\n", error);
 		goto fail_journal;
 	}
 	/* Read in the master statfs inode */
 	sdp->sd_statfs_inode = gfs2_lookup_simple(master, "statfs");
 	if (IS_ERR(sdp->sd_statfs_inode)) {
 		error = PTR_ERR(sdp->sd_statfs_inode);
 		fs_err(sdp, "can't read in statfs inode: %d\n", error);
 		goto fail_inum;
 	}
 	/* Read in the resource index inode */
 	sdp->sd_rindex = gfs2_lookup_simple(master, "rindex");
 	if (IS_ERR(sdp->sd_rindex)) {
 		error = PTR_ERR(sdp->sd_rindex);
 		fs_err(sdp, "can't get resource index inode: %d\n", error);
 		goto fail_statfs;
 	}
 	ip = GFS2_I(sdp->sd_rindex);
 	set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
 	sdp->sd_rindex_uptodate = 0;
 	/* Read in the quota inode */
 	sdp->sd_quota_inode = gfs2_lookup_simple(master, "quota");
 	if (IS_ERR(sdp->sd_quota_inode)) {
 		error = PTR_ERR(sdp->sd_quota_inode);
 		fs_err(sdp, "can't get quota file inode: %d\n", error);
 		goto fail_rindex;
 	}
 	return 0;
 fail_qinode:
 	iput(sdp->sd_quota_inode);
 fail_rindex:
 	gfs2_clear_rgrpd(sdp);
 	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:
 	return error;
 }
 static int init_per_node(struct gfs2_sbd *sdp, int undo)
 {
 	struct inode *pn = NULL;
 	char buf[30];
 	int error = 0;
 	struct gfs2_inode *ip;
 	struct inode *master = sdp->sd_master_dir->d_inode;
 	if (sdp->sd_args.ar_spectator)
 		return 0;
 	if (undo)
 		goto fail_qc_gh;
 	pn = gfs2_lookup_simple(master, "per_node");
 	if (IS_ERR(pn)) {
 		error = PTR_ERR(pn);
 		fs_err(sdp, "can't find per_node directory: %d\n", error);
 		return error;
 	}
 	sprintf(buf, "inum_range%u", sdp->sd_jdesc->jd_jid);
 	sdp->sd_ir_inode = gfs2_lookup_simple(pn, buf);
 	if (IS_ERR(sdp->sd_ir_inode)) {
 		error = PTR_ERR(sdp->sd_ir_inode);
 		fs_err(sdp, "can't find local \"ir\" file: %d\n", error);
 		goto fail;
 	}
 	sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
 	sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
 	if (IS_ERR(sdp->sd_sc_inode)) {
 		error = PTR_ERR(sdp->sd_sc_inode);
 		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);
 	sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
 	if (IS_ERR(sdp->sd_qc_inode)) {
 		error = PTR_ERR(sdp->sd_qc_inode);
 		fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
 		goto fail_ut_i;
 	}
 	iput(pn);
 	pn = NULL;
 	ip = GFS2_I(sdp->sd_ir_inode);
 	error = gfs2_glock_nq_init(ip->i_gl,
 				   LM_ST_EXCLUSIVE, 0,
 				   &sdp->sd_ir_gh);
 	if (error) {
 		fs_err(sdp, "can't lock local \"ir\" file: %d\n", error);
 		goto fail_qc_i;
 	}
 	ip = GFS2_I(sdp->sd_sc_inode);
 	error = gfs2_glock_nq_init(ip->i_gl,
 				   LM_ST_EXCLUSIVE, 0,
 				   &sdp->sd_sc_gh);
 	if (error) {
 		fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
 		goto fail_ir_gh;
 	}
 	ip = GFS2_I(sdp->sd_qc_inode);
 	error = gfs2_glock_nq_init(ip->i_gl,
 				   LM_ST_EXCLUSIVE, 0,
 				   &sdp->sd_qc_gh);
 	if (error) {
 		fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
 		goto fail_ut_gh;
 	}
 	return 0;
 fail_qc_gh:
 	gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
 fail_ut_gh:
 	gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
 fail_ir_gh:
 	gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
 fail_qc_i:
 	iput(sdp->sd_qc_inode);
 fail_ut_i:
 	iput(sdp->sd_sc_inode);
 fail_ir_i:
 	iput(sdp->sd_ir_inode);
 fail:
 	if (pn)
 		iput(pn);
 	return error;
 }
 static int init_threads(struct gfs2_sbd *sdp, int undo)
 {
 	struct task_struct *p;
 	int error = 0;
 	if (undo)
 		goto fail_quotad;
 	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;
 fail_quotad:
 	kthread_stop(sdp->sd_quotad_process);
 fail:
 	kthread_stop(sdp->sd_logd_process);
 	return error;
 }
 /**
  * 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 = LM_MFLAG_CONV_NODROP;
 	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_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);
 }
 /**
  * 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) {
 		printk(KERN_WARNING "GFS2: can't alloc struct gfs2_sbd\n");
 		return -ENOMEM;
 	}
 	error = gfs2_mount_args(sdp, (char *)data, 0);
 	if (error) {
 		printk(KERN_WARNING "GFS2: can't parse mount arguments\n");
 		goto fail;
 	}
 	sb->s_magic = GFS2_MAGIC;
 	sb->s_op = &gfs2_super_ops;
 	sb->s_export_op = &gfs2_export_ops;
 	sb->s_time_gran = 1;
 	sb->s_maxbytes = MAX_LFS_FILESIZE;
 	/* 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;
 	error = init_names(sdp, silent);
 	if (error)
 		goto fail;
 	gfs2_create_debugfs_file(sdp);
 	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);
 	if (error)
 		goto fail_locking;
 	error = init_inodes(sdp, DO);
 	if (error)
 		goto fail_sb;
 	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;
 fail_threads:
 	init_threads(sdp, UNDO);
 fail_per_node:
 	init_per_node(sdp, UNDO);
 fail_inodes:
 	init_inodes(sdp, UNDO);
 fail_sb:
 	if (sdp->sd_root_dir)
 		dput(sdp->sd_root_dir);
 	if (sdp->sd_master_dir)
 		dput(sdp->sd_master_dir);
 	sb->s_root = NULL;
 fail_locking:
 	init_locking(sdp, &mount_gh, UNDO);
 fail_lm:
 	gfs2_gl_hash_clear(sdp);
 	gfs2_lm_unmount(sdp);
 	while (invalidate_inodes(sb))
 		yield();
 fail_sys:
 	gfs2_sys_fs_del(sdp);
 fail:
 	gfs2_delete_debugfs_file(sdp);
 	kfree(sdp);
 	sb->s_fs_info = NULL;
 	return error;
 }
 static int gfs2_get_sb(struct file_system_type *fs_type, int flags,
 		       const char *dev_name, void *data, struct vfsmount *mnt)
 {
 	return get_sb_bdev(fs_type, flags, dev_name, data, fill_super, mnt);
 }
 static struct super_block *get_gfs2_sb(const char *dev_name)
 {
 	struct super_block *sb;
 	struct nameidata nd;
 	int error;
 	error = path_lookup(dev_name, LOOKUP_FOLLOW, &nd);
 	if (error) {
 		printk(KERN_WARNING "GFS2: path_lookup on %s returned error %d\n",
 		       dev_name, error);
 		return NULL;
 	}
 	sb = nd.path.dentry->d_inode->i_sb;
 	if (sb && (sb->s_type == &gfs2_fs_type))
 		atomic_inc(&sb->s_active);
 	else
 		sb = NULL;
 	path_put(&nd.path);
 	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)
 {
 	struct super_block *sb = NULL;
 	struct gfs2_sbd *sdp;
 	sb = get_gfs2_sb(dev_name);
 	if (!sb) {
 		printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n");
 		return -ENOENT;
 	}
 	sdp = sb->s_fs_info;
 	mnt->mnt_sb = sb;
 	mnt->mnt_root = dget(sdp->sd_master_dir);
 	return 0;
 }
 static void gfs2_kill_sb(struct super_block *sb)
 {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
 	if (sdp) {
 		gfs2_meta_syncfs(sdp);
 		dput(sdp->sd_root_dir);
 		dput(sdp->sd_master_dir);
 		sdp->sd_root_dir = NULL;
 		sdp->sd_master_dir = NULL;
 	}
 	shrink_dcache_sb(sb);
 	kill_block_super(sb);
 	if (sdp)
 		gfs2_delete_debugfs_file(sdp);
 }
 struct file_system_type gfs2_fs_type = {
 	.name = "gfs2",
 	.fs_flags = FS_REQUIRES_DEV,
 	.get_sb = gfs2_get_sb,
 	.kill_sb = gfs2_kill_sb,
 	.owner = THIS_MODULE,
 };
 struct file_system_type gfs2meta_fs_type = {
 	.name = "gfs2meta",
 	.fs_flags = FS_REQUIRES_DEV,
 	.get_sb = gfs2_get_sb_meta,
 	.owner = THIS_MODULE,
 };

fs/gfs2/ops_fstype.h

View file @ b276058

1	/*		File was deleted
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*
5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.
8	*/
9
10	#ifndef __OPS_FSTYPE_DOT_H__
11	#define __OPS_FSTYPE_DOT_H__
12
13	#include <linux/fs.h>
14
15	extern struct file_system_type gfs2_fs_type;
16	extern struct file_system_type gfs2meta_fs_type;
17	extern const struct export_operations gfs2_export_ops;
18
19	#endif /* __OPS_FSTYPE_DOT_H__ */
20		1	/*

fs/gfs2/ops_inode.c

Diff comments View file @ b276058

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/namei.h>
 #include <linux/utsname.h>
 #include <linux/mm.h>
 #include <linux/xattr.h>
 #include <linux/posix_acl.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
 #include <linux/lm_interface.h>
 #include <linux/fiemap.h>
 #include <asm/uaccess.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "acl.h"
 #include "bmap.h"
 #include "dir.h"
 #include "eaops.h"
 #include "eattr.h"
 #include "glock.h"
 #include "inode.h"
 #include "meta_io.h"
-#include "ops_dentry.h"
-#include "ops_inode.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "trans.h"
 #include "util.h"
+#include "super.h"
 /**
  * gfs2_create - Create a file
  * @dir: The directory in which to create the file
  * @dentry: The dentry of the new file
  * @mode: The mode of the new file
  *
  * Returns: errno
  */
 static int gfs2_create(struct inode *dir, struct dentry *dentry,
 		       int mode, struct nameidata *nd)
 {
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct gfs2_holder ghs[2];
 	struct inode *inode;
 	gfs2_holder_init(dip->i_gl, 0, 0, ghs);
 	for (;;) {
 		inode = gfs2_createi(ghs, &dentry->d_name, S_IFREG | mode, 0);
 		if (!IS_ERR(inode)) {
 			gfs2_trans_end(sdp);
 			if (dip->i_alloc->al_rgd)
 				gfs2_inplace_release(dip);
 			gfs2_quota_unlock(dip);
 			gfs2_alloc_put(dip);
 			gfs2_glock_dq_uninit_m(2, ghs);
 			mark_inode_dirty(inode);
 			break;
 		} else if (PTR_ERR(inode) != -EEXIST ||
 			   (nd && nd->flags & LOOKUP_EXCL)) {
 			gfs2_holder_uninit(ghs);
 			return PTR_ERR(inode);
 		}
 		inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 		if (inode) {
 			if (!IS_ERR(inode)) {
 				gfs2_holder_uninit(ghs);
 				break;
 			} else {
 				gfs2_holder_uninit(ghs);
 				return PTR_ERR(inode);
 			}
 		}
 	}
 	d_instantiate(dentry, inode);
 	return 0;
 }
 /**
  * gfs2_lookup - Look up a filename in a directory and return its inode
  * @dir: The directory inode
  * @dentry: The dentry of the new inode
  * @nd: passed from Linux VFS, ignored by us
  *
  * Called by the VFS layer. Lock dir and call gfs2_lookupi()
  *
  * Returns: errno
  */
 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 				  struct nameidata *nd)
 {
 	struct inode *inode = NULL;
 	dentry->d_op = &gfs2_dops;
 	inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 	if (inode && IS_ERR(inode))
 		return ERR_CAST(inode);
 	if (inode) {
 		struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
 		struct gfs2_holder gh;
 		int error;
 		error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 		if (error) {
 			iput(inode);
 			return ERR_PTR(error);
 		}
 		gfs2_glock_dq_uninit(&gh);
 		return d_splice_alias(inode, dentry);
 	}
 	d_add(dentry, inode);
 	return NULL;
 }
 /**
  * gfs2_link - Link to a file
  * @old_dentry: The inode to link
  * @dir: Add link to this directory
  * @dentry: The name of the link
  *
  * Link the inode in "old_dentry" into the directory "dir" with the
  * name in "dentry".
  *
  * Returns: errno
  */
 static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 		     struct dentry *dentry)
 {
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct inode *inode = old_dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder ghs[2];
 	int alloc_required;
 	int error;
 	if (S_ISDIR(inode->i_mode))
 		return -EPERM;
 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
 	error = gfs2_glock_nq(ghs); /* parent */
 	if (error)
 		goto out_parent;
 	error = gfs2_glock_nq(ghs + 1); /* child */
 	if (error)
 		goto out_child;
 	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
 	if (error)
 		goto out_gunlock;
 	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
 	switch (error) {
 	case -ENOENT:
 		break;
 	case 0:
 		error = -EEXIST;
 	default:
 		goto out_gunlock;
 	}
 	error = -EINVAL;
 	if (!dip->i_inode.i_nlink)
 		goto out_gunlock;
 	error = -EFBIG;
 	if (dip->i_di.di_entries == (u32)-1)
 		goto out_gunlock;
 	error = -EPERM;
 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 		goto out_gunlock;
 	error = -EINVAL;
 	if (!ip->i_inode.i_nlink)
 		goto out_gunlock;
 	error = -EMLINK;
 	if (ip->i_inode.i_nlink == (u32)-1)
 		goto out_gunlock;
 	alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
 	if (error < 0)
 		goto out_gunlock;
 	error = 0;
 	if (alloc_required) {
 		struct gfs2_alloc *al = gfs2_alloc_get(dip);
 		if (!al) {
 			error = -ENOMEM;
 			goto out_gunlock;
 		}
 		error = gfs2_quota_lock_check(dip);
 		if (error)
 			goto out_alloc;
 		al->al_requested = sdp->sd_max_dirres;
 		error = gfs2_inplace_reserve(dip);
 		if (error)
 			goto out_gunlock_q;
 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 					 al->al_rgd->rd_length +
 					 2 * RES_DINODE + RES_STATFS +
 					 RES_QUOTA, 0);
 		if (error)
 			goto out_ipres;
 	} else {
 		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
 		if (error)
 			goto out_ipres;
 	}
 	error = gfs2_dir_add(dir, &dentry->d_name, ip, IF2DT(inode->i_mode));
 	if (error)
 		goto out_end_trans;
 	error = gfs2_change_nlink(ip, +1);
 out_end_trans:
 	gfs2_trans_end(sdp);
 out_ipres:
 	if (alloc_required)
 		gfs2_inplace_release(dip);
 out_gunlock_q:
 	if (alloc_required)
 		gfs2_quota_unlock(dip);
 out_alloc:
 	if (alloc_required)
 		gfs2_alloc_put(dip);
 out_gunlock:
 	gfs2_glock_dq(ghs + 1);
 out_child:
 	gfs2_glock_dq(ghs);
 out_parent:
 	gfs2_holder_uninit(ghs);
 	gfs2_holder_uninit(ghs + 1);
 	if (!error) {
 		atomic_inc(&inode->i_count);
 		d_instantiate(dentry, inode);
 		mark_inode_dirty(inode);
 	}
 	return error;
 }
 /**
  * gfs2_unlink - Unlink a file
  * @dir: The inode of the directory containing the file to unlink
  * @dentry: The file itself
  *
  * Unlink a file.  Call gfs2_unlinki()
  *
  * Returns: errno
  */
 static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
 {
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
 	struct gfs2_holder ghs[3];
 	struct gfs2_rgrpd *rgd;
 	struct gfs2_holder ri_gh;
 	int error;
 	error = gfs2_rindex_hold(sdp, &ri_gh);
 	if (error)
 		return error;
 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
 	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
 	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
 	error = gfs2_glock_nq(ghs); /* parent */
 	if (error)
 		goto out_parent;
 	error = gfs2_glock_nq(ghs + 1); /* child */
 	if (error)
 		goto out_child;
 	error = gfs2_glock_nq(ghs + 2); /* rgrp */
 	if (error)
 		goto out_rgrp;
 	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
 	if (error)
 		goto out_gunlock;
 	error = gfs2_trans_begin(sdp, 2*RES_DINODE + RES_LEAF + RES_RG_BIT, 0);
 	if (error)
 		goto out_rgrp;
 	error = gfs2_dir_del(dip, &dentry->d_name);
         if (error)
                 goto out_end_trans;
 	error = gfs2_change_nlink(ip, -1);
 out_end_trans:
 	gfs2_trans_end(sdp);
 out_gunlock:
 	gfs2_glock_dq(ghs + 2);
 out_rgrp:
 	gfs2_holder_uninit(ghs + 2);
 	gfs2_glock_dq(ghs + 1);
 out_child:
 	gfs2_holder_uninit(ghs + 1);
 	gfs2_glock_dq(ghs);
 out_parent:
 	gfs2_holder_uninit(ghs);
 	gfs2_glock_dq_uninit(&ri_gh);
 	return error;
 }
 /**
  * gfs2_symlink - Create a symlink
  * @dir: The directory to create the symlink in
  * @dentry: The dentry to put the symlink in
  * @symname: The thing which the link points to
  *
  * Returns: errno
  */
 static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
 			const char *symname)
 {
 	struct gfs2_inode *dip = GFS2_I(dir), *ip;
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct gfs2_holder ghs[2];
 	struct inode *inode;
 	struct buffer_head *dibh;
 	int size;
 	int error;
 	/* Must be stuffed with a null terminator for gfs2_follow_link() */
 	size = strlen(symname);
 	if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
 		return -ENAMETOOLONG;
 	gfs2_holder_init(dip->i_gl, 0, 0, ghs);
 	inode = gfs2_createi(ghs, &dentry->d_name, S_IFLNK | S_IRWXUGO, 0);
 	if (IS_ERR(inode)) {
 		gfs2_holder_uninit(ghs);
 		return PTR_ERR(inode);
 	}
 	ip = ghs[1].gh_gl->gl_object;
 	ip->i_di.di_size = size;
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (!gfs2_assert_withdraw(sdp, !error)) {
 		gfs2_dinode_out(ip, dibh->b_data);
 		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname,
 		       size);
 		brelse(dibh);
 	}
 	gfs2_trans_end(sdp);
 	if (dip->i_alloc->al_rgd)
 		gfs2_inplace_release(dip);
 	gfs2_quota_unlock(dip);
 	gfs2_alloc_put(dip);
 	gfs2_glock_dq_uninit_m(2, ghs);
 	d_instantiate(dentry, inode);
 	mark_inode_dirty(inode);
 	return 0;
 }
 /**
  * gfs2_mkdir - Make a directory
  * @dir: The parent directory of the new one
  * @dentry: The dentry of the new directory
  * @mode: The mode of the new directory
  *
  * Returns: errno
  */
 static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
 	struct gfs2_inode *dip = GFS2_I(dir), *ip;
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct gfs2_holder ghs[2];
 	struct inode *inode;
 	struct buffer_head *dibh;
 	int error;
 	gfs2_holder_init(dip->i_gl, 0, 0, ghs);
 	inode = gfs2_createi(ghs, &dentry->d_name, S_IFDIR | mode, 0);
 	if (IS_ERR(inode)) {
 		gfs2_holder_uninit(ghs);
 		return PTR_ERR(inode);
 	}
 	ip = ghs[1].gh_gl->gl_object;
 	ip->i_inode.i_nlink = 2;
 	ip->i_di.di_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
 	ip->i_di.di_flags |= GFS2_DIF_JDATA;
 	ip->i_di.di_entries = 2;
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (!gfs2_assert_withdraw(sdp, !error)) {
 		struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
 		struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
 		struct qstr str;
 		gfs2_str2qstr(&str, ".");
 		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 		gfs2_qstr2dirent(&str, GFS2_DIRENT_SIZE(str.len), dent);
 		dent->de_inum = di->di_num; /* already GFS2 endian */
 		dent->de_type = cpu_to_be16(DT_DIR);
 		di->di_entries = cpu_to_be32(1);
 		gfs2_str2qstr(&str, "..");
 		dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
 		gfs2_qstr2dirent(&str, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
 		gfs2_inum_out(dip, dent);
 		dent->de_type = cpu_to_be16(DT_DIR);
 		gfs2_dinode_out(ip, di);
 		brelse(dibh);
 	}
 	error = gfs2_change_nlink(dip, +1);
 	gfs2_assert_withdraw(sdp, !error); /* dip already pinned */
 	gfs2_trans_end(sdp);
 	if (dip->i_alloc->al_rgd)
 		gfs2_inplace_release(dip);
 	gfs2_quota_unlock(dip);
 	gfs2_alloc_put(dip);
 	gfs2_glock_dq_uninit_m(2, ghs);
 	d_instantiate(dentry, inode);
 	mark_inode_dirty(inode);
 	return 0;
 }
 /**
  * gfs2_rmdir - Remove a directory
  * @dir: The parent directory of the directory to be removed
  * @dentry: The dentry of the directory to remove
  *
  * Remove a directory. Call gfs2_rmdiri()
  *
  * Returns: errno
  */
 static int gfs2_rmdir(struct inode *dir, struct dentry *dentry)
 {
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
 	struct gfs2_holder ghs[3];
 	struct gfs2_rgrpd *rgd;
 	struct gfs2_holder ri_gh;
 	int error;
 	error = gfs2_rindex_hold(sdp, &ri_gh);
 	if (error)
 		return error;
 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
 	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr);
 	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
 	error = gfs2_glock_nq(ghs); /* parent */
 	if (error)
 		goto out_parent;
 	error = gfs2_glock_nq(ghs + 1); /* child */
 	if (error)
 		goto out_child;
 	error = gfs2_glock_nq(ghs + 2); /* rgrp */
 	if (error)
 		goto out_rgrp;
 	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
 	if (error)
 		goto out_gunlock;
 	if (ip->i_di.di_entries < 2) {
 		if (gfs2_consist_inode(ip))
 			gfs2_dinode_print(ip);
 		error = -EIO;
 		goto out_gunlock;
 	}
 	if (ip->i_di.di_entries > 2) {
 		error = -ENOTEMPTY;
 		goto out_gunlock;
 	}
 	error = gfs2_trans_begin(sdp, 2 * RES_DINODE + 3 * RES_LEAF + RES_RG_BIT, 0);
 	if (error)
 		goto out_gunlock;
 	error = gfs2_rmdiri(dip, &dentry->d_name, ip);
 	gfs2_trans_end(sdp);
 out_gunlock:
 	gfs2_glock_dq(ghs + 2);
 out_rgrp:
 	gfs2_holder_uninit(ghs + 2);
 	gfs2_glock_dq(ghs + 1);
 out_child:
 	gfs2_holder_uninit(ghs + 1);
 	gfs2_glock_dq(ghs);
 out_parent:
 	gfs2_holder_uninit(ghs);
 	gfs2_glock_dq_uninit(&ri_gh);
 	return error;
 }
 /**
  * gfs2_mknod - Make a special file
  * @dir: The directory in which the special file will reside
  * @dentry: The dentry of the special file
  * @mode: The mode of the special file
  * @rdev: The device specification of the special file
  *
  */
 static int gfs2_mknod(struct inode *dir, struct dentry *dentry, int mode,
 		      dev_t dev)
 {
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct gfs2_holder ghs[2];
 	struct inode *inode;
 	gfs2_holder_init(dip->i_gl, 0, 0, ghs);
 	inode = gfs2_createi(ghs, &dentry->d_name, mode, dev);
 	if (IS_ERR(inode)) {
 		gfs2_holder_uninit(ghs);
 		return PTR_ERR(inode);
 	}
 	gfs2_trans_end(sdp);
 	if (dip->i_alloc->al_rgd)
 		gfs2_inplace_release(dip);
 	gfs2_quota_unlock(dip);
 	gfs2_alloc_put(dip);
 	gfs2_glock_dq_uninit_m(2, ghs);
 	d_instantiate(dentry, inode);
 	mark_inode_dirty(inode);
 	return 0;
 }
 /*
  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
  * @this: move this
  * @to: to here
  *
  * Follow @to back to the root and make sure we don't encounter @this
  * Assumes we already hold the rename lock.
  *
  * Returns: errno
  */
 static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
 {
 	struct inode *dir = &to->i_inode;
 	struct super_block *sb = dir->i_sb;
 	struct inode *tmp;
 	struct qstr dotdot;
 	int error = 0;
 	gfs2_str2qstr(&dotdot, "..");
 	igrab(dir);
 	for (;;) {
 		if (dir == &this->i_inode) {
 			error = -EINVAL;
 			break;
 		}
 		if (dir == sb->s_root->d_inode) {
 			error = 0;
 			break;
 		}
 		tmp = gfs2_lookupi(dir, &dotdot, 1);
 		if (IS_ERR(tmp)) {
 			error = PTR_ERR(tmp);
 			break;
 		}
 		iput(dir);
 		dir = tmp;
 	}
 	iput(dir);
 	return error;
 }
 /**
  * gfs2_rename - Rename a file
  * @odir: Parent directory of old file name
  * @odentry: The old dentry of the file
  * @ndir: Parent directory of new file name
  * @ndentry: The new dentry of the file
  *
  * Returns: errno
  */
 static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 		       struct inode *ndir, struct dentry *ndentry)
 {
 	struct gfs2_inode *odip = GFS2_I(odir);
 	struct gfs2_inode *ndip = GFS2_I(ndir);
 	struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
 	struct gfs2_inode *nip = NULL;
 	struct gfs2_sbd *sdp = GFS2_SB(odir);
 	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
 	struct gfs2_rgrpd *nrgd;
 	unsigned int num_gh;
 	int dir_rename = 0;
 	int alloc_required;
 	unsigned int x;
 	int error;
 	if (ndentry->d_inode) {
 		nip = GFS2_I(ndentry->d_inode);
 		if (ip == nip)
 			return 0;
 	}
 	if (odip != ndip) {
 		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
 					   0, &r_gh);
 		if (error)
 			goto out;
 		if (S_ISDIR(ip->i_inode.i_mode)) {
 			dir_rename = 1;
 			/* don't move a dirctory into it's subdir */
 			error = gfs2_ok_to_move(ip, ndip);
 			if (error)
 				goto out_gunlock_r;
 		}
 	}
 	num_gh = 1;
 	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 	if (odip != ndip) {
 		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 		num_gh++;
 	}
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 	num_gh++;
 	if (nip) {
 		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 		num_gh++;
 		/* grab the resource lock for unlink flag twiddling
 		 * this is the case of the target file already existing
 		 * so we unlink before doing the rename
 		 */
 		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr);
 		if (nrgd)
 			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
 	}
 	for (x = 0; x < num_gh; x++) {
 		error = gfs2_glock_nq(ghs + x);
 		if (error)
 			goto out_gunlock;
 	}
 	/* Check out the old directory */
 	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
 	if (error)
 		goto out_gunlock;
 	/* Check out the new directory */
 	if (nip) {
 		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
 		if (error)
 			goto out_gunlock;
 		if (S_ISDIR(nip->i_inode.i_mode)) {
 			if (nip->i_di.di_entries < 2) {
 				if (gfs2_consist_inode(nip))
 					gfs2_dinode_print(nip);
 				error = -EIO;
 				goto out_gunlock;
 			}
 			if (nip->i_di.di_entries > 2) {
 				error = -ENOTEMPTY;
 				goto out_gunlock;
 			}
 		}
 	} else {
 		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
 		if (error)
 			goto out_gunlock;
 		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
 		switch (error) {
 		case -ENOENT:
 			error = 0;
 			break;
 		case 0:
 			error = -EEXIST;
 		default:
 			goto out_gunlock;
 		};
 		if (odip != ndip) {
 			if (!ndip->i_inode.i_nlink) {
 				error = -EINVAL;
 				goto out_gunlock;
 			}
 			if (ndip->i_di.di_entries == (u32)-1) {
 				error = -EFBIG;
 				goto out_gunlock;
 			}
 			if (S_ISDIR(ip->i_inode.i_mode) &&
 			    ndip->i_inode.i_nlink == (u32)-1) {
 				error = -EMLINK;
 				goto out_gunlock;
 			}
 		}
 	}
 	/* Check out the dir to be renamed */
 	if (dir_rename) {
 		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
 		if (error)
 			goto out_gunlock;
 	}
 	alloc_required = error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
 	if (error < 0)
 		goto out_gunlock;
 	error = 0;
 	if (alloc_required) {
 		struct gfs2_alloc *al = gfs2_alloc_get(ndip);
 		if (!al) {
 			error = -ENOMEM;
 			goto out_gunlock;
 		}
 		error = gfs2_quota_lock_check(ndip);
 		if (error)
 			goto out_alloc;
 		al->al_requested = sdp->sd_max_dirres;
 		error = gfs2_inplace_reserve(ndip);
 		if (error)
 			goto out_gunlock_q;
 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 					 al->al_rgd->rd_length +
 					 4 * RES_DINODE + 4 * RES_LEAF +
 					 RES_STATFS + RES_QUOTA + 4, 0);
 		if (error)
 			goto out_ipreserv;
 	} else {
 		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
 					 5 * RES_LEAF + 4, 0);
 		if (error)
 			goto out_gunlock;
 	}
 	/* Remove the target file, if it exists */
 	if (nip) {
 		if (S_ISDIR(nip->i_inode.i_mode))
 			error = gfs2_rmdiri(ndip, &ndentry->d_name, nip);
 		else {
 			error = gfs2_dir_del(ndip, &ndentry->d_name);
 			if (error)
 				goto out_end_trans;
 			error = gfs2_change_nlink(nip, -1);
 		}
 		if (error)
 			goto out_end_trans;
 	}
 	if (dir_rename) {
 		struct qstr name;
 		gfs2_str2qstr(&name, "..");
 		error = gfs2_change_nlink(ndip, +1);
 		if (error)
 			goto out_end_trans;
 		error = gfs2_change_nlink(odip, -1);
 		if (error)
 			goto out_end_trans;
 		error = gfs2_dir_mvino(ip, &name, ndip, DT_DIR);
 		if (error)
 			goto out_end_trans;
 	} else {
 		struct buffer_head *dibh;
 		error = gfs2_meta_inode_buffer(ip, &dibh);
 		if (error)
 			goto out_end_trans;
 		ip->i_inode.i_ctime = CURRENT_TIME;
 		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 		gfs2_dinode_out(ip, dibh->b_data);
 		brelse(dibh);
 	}
 	error = gfs2_dir_del(odip, &odentry->d_name);
 	if (error)
 		goto out_end_trans;
 	error = gfs2_dir_add(ndir, &ndentry->d_name, ip, IF2DT(ip->i_inode.i_mode));
 	if (error)
 		goto out_end_trans;
 out_end_trans:
 	gfs2_trans_end(sdp);
 out_ipreserv:
 	if (alloc_required)
 		gfs2_inplace_release(ndip);
 out_gunlock_q:
 	if (alloc_required)
 		gfs2_quota_unlock(ndip);
 out_alloc:
 	if (alloc_required)
 		gfs2_alloc_put(ndip);
 out_gunlock:
 	while (x--) {
 		gfs2_glock_dq(ghs + x);
 		gfs2_holder_uninit(ghs + x);
 	}
 out_gunlock_r:
 	if (r_gh.gh_gl)
 		gfs2_glock_dq_uninit(&r_gh);
 out:
 	return error;
 }
 /**
  * gfs2_readlink - Read the value of a symlink
  * @dentry: the symlink
  * @buf: the buffer to read the symlink data into
  * @size: the size of the buffer
  *
  * Returns: errno
  */
 static int gfs2_readlink(struct dentry *dentry, char __user *user_buf,
 			 int user_size)
 {
 	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
 	char array[GFS2_FAST_NAME_SIZE], *buf = array;
 	unsigned int len = GFS2_FAST_NAME_SIZE;
 	int error;
 	error = gfs2_readlinki(ip, &buf, &len);
 	if (error)
 		return error;
 	if (user_size > len - 1)
 		user_size = len - 1;
 	if (copy_to_user(user_buf, buf, user_size))
 		error = -EFAULT;
 	else
 		error = user_size;
 	if (buf != array)
 		kfree(buf);
 	return error;
 }
 /**
  * gfs2_follow_link - Follow a symbolic link
  * @dentry: The dentry of the link
  * @nd: Data that we pass to vfs_follow_link()
  *
  * This can handle symlinks of any size. It is optimised for symlinks
  * under GFS2_FAST_NAME_SIZE.
  *
  * Returns: 0 on success or error code
  */
 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
 	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
 	char array[GFS2_FAST_NAME_SIZE], *buf = array;
 	unsigned int len = GFS2_FAST_NAME_SIZE;
 	int error;
 	error = gfs2_readlinki(ip, &buf, &len);
 	if (!error) {
 		error = vfs_follow_link(nd, buf);
 		if (buf != array)
 			kfree(buf);
 	}
 	return ERR_PTR(error);
 }
 /**
  * gfs2_permission -
  * @inode:
  * @mask:
  * @nd: passed from Linux VFS, ignored by us
  *
  * This may be called from the VFS directly, or from within GFS2 with the
  * inode locked, so we look to see if the glock is already locked and only
  * lock the glock if its not already been done.
  *
  * Returns: errno
  */
 int gfs2_permission(struct inode *inode, int mask)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder i_gh;
 	int error;
 	int unlock = 0;
 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
 		if (error)
 			return error;
 		unlock = 1;
 	}
 	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
 		error = -EACCES;
 	else
 		error = generic_permission(inode, mask, gfs2_check_acl);
 	if (unlock)
 		gfs2_glock_dq_uninit(&i_gh);
 	return error;
 }
 static int setattr_size(struct inode *inode, struct iattr *attr)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	int error;
 	if (attr->ia_size != ip->i_di.di_size) {
 		error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks);
 		if (error)
 			return error;
 		error = vmtruncate(inode, attr->ia_size);
 		gfs2_trans_end(sdp);
 		if (error)
 			return error;
 	}
 	error = gfs2_truncatei(ip, attr->ia_size);
 	if (error && (inode->i_size != ip->i_di.di_size))
 		i_size_write(inode, ip->i_di.di_size);
 	return error;
 }
 static int setattr_chown(struct inode *inode, struct iattr *attr)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	struct buffer_head *dibh;
 	u32 ouid, ogid, nuid, ngid;
 	int error;
 	ouid = inode->i_uid;
 	ogid = inode->i_gid;
 	nuid = attr->ia_uid;
 	ngid = attr->ia_gid;
 	if (!(attr->ia_valid & ATTR_UID) || ouid == nuid)
 		ouid = nuid = NO_QUOTA_CHANGE;
 	if (!(attr->ia_valid & ATTR_GID) || ogid == ngid)
 		ogid = ngid = NO_QUOTA_CHANGE;
 	if (!gfs2_alloc_get(ip))
 		return -ENOMEM;
 	error = gfs2_quota_lock(ip, nuid, ngid);
 	if (error)
 		goto out_alloc;
 	if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
 		error = gfs2_quota_check(ip, nuid, ngid);
 		if (error)
 			goto out_gunlock_q;
 	}
 	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
 	if (error)
 		goto out_gunlock_q;
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		goto out_end_trans;
 	error = inode_setattr(inode, attr);
 	gfs2_assert_warn(sdp, !error);
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	gfs2_dinode_out(ip, dibh->b_data);
 	brelse(dibh);
 	if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
 		u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
 		gfs2_quota_change(ip, -blocks, ouid, ogid);
 		gfs2_quota_change(ip, blocks, nuid, ngid);
 	}
 out_end_trans:
 	gfs2_trans_end(sdp);
 out_gunlock_q:
 	gfs2_quota_unlock(ip);
 out_alloc:
 	gfs2_alloc_put(ip);
 	return error;
 }
 /**
  * gfs2_setattr - Change attributes on an inode
  * @dentry: The dentry which is changing
  * @attr: The structure describing the change
  *
  * The VFS layer wants to change one or more of an inodes attributes.  Write
  * that change out to disk.
  *
  * Returns: errno
  */
 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder i_gh;
 	int error;
 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
 	if (error)
 		return error;
 	error = -EPERM;
 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 		goto out;
 	error = inode_change_ok(inode, attr);
 	if (error)
 		goto out;
 	if (attr->ia_valid & ATTR_SIZE)
 		error = setattr_size(inode, attr);
 	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
 		error = setattr_chown(inode, attr);
 	else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
 		error = gfs2_acl_chmod(ip, attr);
 	else
 		error = gfs2_setattr_simple(ip, attr);
 out:
 	gfs2_glock_dq_uninit(&i_gh);
 	if (!error)
 		mark_inode_dirty(inode);
 	return error;
 }
 /**
  * gfs2_getattr - Read out an inode's attributes
  * @mnt: The vfsmount the inode is being accessed from
  * @dentry: The dentry to stat
  * @stat: The inode's stats
  *
  * This may be called from the VFS directly, or from within GFS2 with the
  * inode locked, so we look to see if the glock is already locked and only
  * lock the glock if its not already been done. Note that its the NFS
  * readdirplus operation which causes this to be called (from filldir)
  * with the glock already held.
  *
  * Returns: errno
  */
 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
 			struct kstat *stat)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int error;
 	int unlock = 0;
 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 		if (error)
 			return error;
 		unlock = 1;
 	}
 	generic_fillattr(inode, stat);
 	if (unlock)
 		gfs2_glock_dq_uninit(&gh);
 	return 0;
 }
 static int gfs2_setxattr(struct dentry *dentry, const char *name,
 			 const void *data, size_t size, int flags)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_ea_request er;
 	memset(&er, 0, sizeof(struct gfs2_ea_request));
 	er.er_type = gfs2_ea_name2type(name, &er.er_name);
 	if (er.er_type == GFS2_EATYPE_UNUSED)
 		return -EOPNOTSUPP;
 	er.er_data = (char *)data;
 	er.er_name_len = strlen(er.er_name);
 	er.er_data_len = size;
 	er.er_flags = flags;
 	gfs2_assert_warn(GFS2_SB(inode), !(er.er_flags & GFS2_ERF_MODE));
 	return gfs2_ea_set(GFS2_I(inode), &er);
 }
 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
 			     void *data, size_t size)
 {
 	struct gfs2_ea_request er;
 	memset(&er, 0, sizeof(struct gfs2_ea_request));
 	er.er_type = gfs2_ea_name2type(name, &er.er_name);
 	if (er.er_type == GFS2_EATYPE_UNUSED)
 		return -EOPNOTSUPP;
 	er.er_data = data;
 	er.er_name_len = strlen(er.er_name);
 	er.er_data_len = size;
 	return gfs2_ea_get(GFS2_I(dentry->d_inode), &er);
 }
 static ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
 {
 	struct gfs2_ea_request er;
 	memset(&er, 0, sizeof(struct gfs2_ea_request));
 	er.er_data = (size) ? buffer : NULL;
 	er.er_data_len = size;
 	return gfs2_ea_list(GFS2_I(dentry->d_inode), &er);
 }
 static int gfs2_removexattr(struct dentry *dentry, const char *name)
 {
 	struct gfs2_ea_request er;
 	memset(&er, 0, sizeof(struct gfs2_ea_request));
 	er.er_type = gfs2_ea_name2type(name, &er.er_name);
 	if (er.er_type == GFS2_EATYPE_UNUSED)
 		return -EOPNOTSUPP;
 	er.er_name_len = strlen(er.er_name);
 	return gfs2_ea_remove(GFS2_I(dentry->d_inode), &er);
 }
 static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 		       u64 start, u64 len)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int ret;
 	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
 	if (ret)
 		return ret;
 	mutex_lock(&inode->i_mutex);
 	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
 	if (ret)
 		goto out;
 	if (gfs2_is_stuffed(ip)) {
 		u64 phys = ip->i_no_addr << inode->i_blkbits;
 		u64 size = i_size_read(inode);
 		u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
 			    FIEMAP_EXTENT_DATA_INLINE;
 		phys += sizeof(struct gfs2_dinode);
 		phys += start;
 		if (start + len > size)
 			len = size - start;
 		if (start < size)
 			ret = fiemap_fill_next_extent(fieinfo, start, phys,
 						      len, flags);
 		if (ret == 1)
 			ret = 0;
 	} else {
 		ret = __generic_block_fiemap(inode, fieinfo, start, len,
 					     gfs2_block_map);
 	}
 	gfs2_glock_dq_uninit(&gh);
 out:
 	mutex_unlock(&inode->i_mutex);
 	return ret;
 }
 const struct inode_operations gfs2_file_iops = {
 	.permission = gfs2_permission,
 	.setattr = gfs2_setattr,
 	.getattr = gfs2_getattr,
 	.setxattr = gfs2_setxattr,
 	.getxattr = gfs2_getxattr,
 	.listxattr = gfs2_listxattr,
 	.removexattr = gfs2_removexattr,
 	.fiemap = gfs2_fiemap,
 };
 const struct inode_operations gfs2_dir_iops = {
 	.create = gfs2_create,
 	.lookup = gfs2_lookup,
 	.link = gfs2_link,
 	.unlink = gfs2_unlink,
 	.symlink = gfs2_symlink,
 	.mkdir = gfs2_mkdir,
 	.rmdir = gfs2_rmdir,
 	.mknod = gfs2_mknod,
 	.rename = gfs2_rename,
 	.permission = gfs2_permission,
 	.setattr = gfs2_setattr,
 	.getattr = gfs2_getattr,
 	.setxattr = gfs2_setxattr,
 	.getxattr = gfs2_getxattr,
 	.listxattr = gfs2_listxattr,
 	.removexattr = gfs2_removexattr,
 	.fiemap = gfs2_fiemap,
 };
 const struct inode_operations gfs2_symlink_iops = {
 	.readlink = gfs2_readlink,
 	.follow_link = gfs2_follow_link,
 	.permission = gfs2_permission,
 	.setattr = gfs2_setattr,
 	.getattr = gfs2_getattr,
 	.setxattr = gfs2_setxattr,
 	.getxattr = gfs2_getxattr,
 	.listxattr = gfs2_listxattr,
 	.removexattr = gfs2_removexattr,
 	.fiemap = gfs2_fiemap,
 };

fs/gfs2/ops_inode.h

View file @ b276058

1	/*		File was deleted
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*
5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.
8	*/
9
10	#ifndef __OPS_INODE_DOT_H__
11	#define __OPS_INODE_DOT_H__
12
13	#include <linux/fs.h>
14
15	extern const struct inode_operations gfs2_file_iops;
16	extern const struct inode_operations gfs2_dir_iops;
17	extern const struct inode_operations gfs2_symlink_iops;
18	extern const struct file_operations gfs2_file_fops;
19	extern const struct file_operations gfs2_dir_fops;
20	extern const struct file_operations gfs2_file_fops_nolock;
21	extern const struct file_operations gfs2_dir_fops_nolock;
22
23	extern void gfs2_set_inode_flags(struct inode *inode);
24
25	#endif /* __OPS_INODE_DOT_H__ */
26		1	/*

fs/gfs2/ops_super.c

Diff comments View file @ b276058

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/statfs.h>
 #include <linux/seq_file.h>
 #include <linux/mount.h>
 #include <linux/kthread.h>
 #include <linux/delay.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
 #include <linux/lm_interface.h>
 #include <linux/time.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "glock.h"
 #include "inode.h"
 #include "log.h"
 #include "mount.h"
-#include "ops_super.h"
 #include "quota.h"
 #include "recovery.h"
 #include "rgrp.h"
 #include "super.h"
 #include "sys.h"
 #include "util.h"
 #include "trans.h"
 #include "dir.h"
 #include "eattr.h"
 #include "bmap.h"
 #include "meta_io.h"
 /**
  * gfs2_write_inode - Make sure the inode is stable on the disk
  * @inode: The inode
  * @sync: synchronous write flag
  *
  * Returns: errno
  */
 static int gfs2_write_inode(struct inode *inode, int sync)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	struct gfs2_holder gh;
 	struct buffer_head *bh;
 	struct timespec atime;
 	struct gfs2_dinode *di;
 	int ret = 0;
 	/* Check this is a "normal" inode, etc */
 	if (!test_bit(GIF_USER, &ip->i_flags) ||
 	    (current->flags & PF_MEMALLOC))
 		return 0;
 	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 	if (ret)
 		goto do_flush;
 	ret = gfs2_trans_begin(sdp, RES_DINODE, 0);
 	if (ret)
 		goto do_unlock;
 	ret = gfs2_meta_inode_buffer(ip, &bh);
 	if (ret == 0) {
 		di = (struct gfs2_dinode *)bh->b_data;
 		atime.tv_sec = be64_to_cpu(di->di_atime);
 		atime.tv_nsec = be32_to_cpu(di->di_atime_nsec);
 		if (timespec_compare(&inode->i_atime, &atime) > 0) {
 			gfs2_trans_add_bh(ip->i_gl, bh, 1);
 			gfs2_dinode_out(ip, bh->b_data);
 		}
 		brelse(bh);
 	}
 	gfs2_trans_end(sdp);
 do_unlock:
 	gfs2_glock_dq_uninit(&gh);
 do_flush:
 	if (sync != 0)
 		gfs2_log_flush(GFS2_SB(inode), ip->i_gl);
 	return ret;
 }
 /**
  * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
  * @sdp: the filesystem
  *
  * Returns: errno
  */
 static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
 {
 	struct gfs2_holder t_gh;
 	int error;
 	gfs2_quota_sync(sdp);
 	gfs2_statfs_sync(sdp);
 	error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, GL_NOCACHE,
 				   &t_gh);
 	if (error && !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
 		return error;
 	gfs2_meta_syncfs(sdp);
 	gfs2_log_shutdown(sdp);
 	clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 	if (t_gh.gh_gl)
 		gfs2_glock_dq_uninit(&t_gh);
 	gfs2_quota_cleanup(sdp);
 	return error;
 }
 /**
  * gfs2_put_super - Unmount the filesystem
  * @sb: The VFS superblock
  *
  */
 static void gfs2_put_super(struct super_block *sb)
 {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
 	int error;
 	/*  Unfreeze the filesystem, if we need to  */
 	mutex_lock(&sdp->sd_freeze_lock);
 	if (sdp->sd_freeze_count)
 		gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
 	mutex_unlock(&sdp->sd_freeze_lock);
 	kthread_stop(sdp->sd_quotad_process);
 	kthread_stop(sdp->sd_logd_process);
 	kthread_stop(sdp->sd_recoverd_process);
 	while (sdp->sd_glockd_num--)
 		kthread_stop(sdp->sd_glockd_process[sdp->sd_glockd_num]);
 	if (!(sb->s_flags & MS_RDONLY)) {
 		error = gfs2_make_fs_ro(sdp);
 		if (error)
 			gfs2_io_error(sdp);
 	}
 	/*  At this point, we're through modifying the disk  */
 	/*  Release stuff  */
 	iput(sdp->sd_jindex);
 	iput(sdp->sd_inum_inode);
 	iput(sdp->sd_statfs_inode);
 	iput(sdp->sd_rindex);
 	iput(sdp->sd_quota_inode);
 	gfs2_glock_put(sdp->sd_rename_gl);
 	gfs2_glock_put(sdp->sd_trans_gl);
 	if (!sdp->sd_args.ar_spectator) {
 		gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
 		gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
 		gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
 		gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
 		gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
 		iput(sdp->sd_ir_inode);
 		iput(sdp->sd_sc_inode);
 		iput(sdp->sd_qc_inode);
 	}
 	gfs2_glock_dq_uninit(&sdp->sd_live_gh);
 	gfs2_clear_rgrpd(sdp);
 	gfs2_jindex_free(sdp);
 	/*  Take apart glock structures and buffer lists  */
 	gfs2_gl_hash_clear(sdp);
 	/*  Unmount the locking protocol  */
 	gfs2_lm_unmount(sdp);
 	/*  At this point, we're through participating in the lockspace  */
 	gfs2_sys_fs_del(sdp);
 	kfree(sdp);
 }
 /**
  * gfs2_write_super
  * @sb: the superblock
  *
  */
 static void gfs2_write_super(struct super_block *sb)
 {
 	sb->s_dirt = 0;
 }
 /**
  * gfs2_sync_fs - sync the filesystem
  * @sb: the superblock
  *
  * Flushes the log to disk.
  */
 static int gfs2_sync_fs(struct super_block *sb, int wait)
 {
 	sb->s_dirt = 0;
 	if (wait && sb->s_fs_info)
 		gfs2_log_flush(sb->s_fs_info, NULL);
 	return 0;
 }
 /**
  * gfs2_write_super_lockfs - prevent further writes to the filesystem
  * @sb: the VFS structure for the filesystem
  *
  */
 static void gfs2_write_super_lockfs(struct super_block *sb)
 {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
 	int error;
 	if (test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
 		return;
 	for (;;) {
 		error = gfs2_freeze_fs(sdp);
 		if (!error)
 			break;
 		switch (error) {
 		case -EBUSY:
 			fs_err(sdp, "waiting for recovery before freeze\n");
 			break;
 		default:
 			fs_err(sdp, "error freezing FS: %d\n", error);
 			break;
 		}
 		fs_err(sdp, "retrying...\n");
 		msleep(1000);
 	}
 }
 /**
  * gfs2_unlockfs - reallow writes to the filesystem
  * @sb: the VFS structure for the filesystem
  *
  */
 static void gfs2_unlockfs(struct super_block *sb)
 {
 	gfs2_unfreeze_fs(sb->s_fs_info);
 }
 /**
  * gfs2_statfs - Gather and return stats about the filesystem
  * @sb: The superblock
  * @statfsbuf: The buffer
  *
  * Returns: 0 on success or error code
  */
 static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
 	struct super_block *sb = dentry->d_inode->i_sb;
 	struct gfs2_sbd *sdp = sb->s_fs_info;
 	struct gfs2_statfs_change_host sc;
 	int error;
 	if (gfs2_tune_get(sdp, gt_statfs_slow))
 		error = gfs2_statfs_slow(sdp, &sc);
 	else
 		error = gfs2_statfs_i(sdp, &sc);
 	if (error)
 		return error;
 	buf->f_type = GFS2_MAGIC;
 	buf->f_bsize = sdp->sd_sb.sb_bsize;
 	buf->f_blocks = sc.sc_total;
 	buf->f_bfree = sc.sc_free;
 	buf->f_bavail = sc.sc_free;
 	buf->f_files = sc.sc_dinodes + sc.sc_free;
 	buf->f_ffree = sc.sc_free;
 	buf->f_namelen = GFS2_FNAMESIZE;
 	return 0;
 }
 /**
  * gfs2_remount_fs - called when the FS is remounted
  * @sb:  the filesystem
  * @flags:  the remount flags
  * @data:  extra data passed in (not used right now)
  *
  * Returns: errno
  */
 static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
 {
 	struct gfs2_sbd *sdp = sb->s_fs_info;
 	int error;
 	error = gfs2_mount_args(sdp, data, 1);
 	if (error)
 		return error;
 	if (sdp->sd_args.ar_spectator)
 		*flags |= MS_RDONLY;
 	else {
 		if (*flags & MS_RDONLY) {
 			if (!(sb->s_flags & MS_RDONLY))
 				error = gfs2_make_fs_ro(sdp);
 		} else if (!(*flags & MS_RDONLY) &&
 			   (sb->s_flags & MS_RDONLY)) {
 			error = gfs2_make_fs_rw(sdp);
 		}
 	}
 	return error;
 }
 /**
  * gfs2_drop_inode - Drop an inode (test for remote unlink)
  * @inode: The inode to drop
  *
  * If we've received a callback on an iopen lock then its because a
  * remote node tried to deallocate the inode but failed due to this node
  * still having the inode open. Here we mark the link count zero
  * since we know that it must have reached zero if the GLF_DEMOTE flag
  * is set on the iopen glock. If we didn't do a disk read since the
  * remote node removed the final link then we might otherwise miss
  * this event. This check ensures that this node will deallocate the
  * inode's blocks, or alternatively pass the baton on to another
  * node for later deallocation.
  */
 static void gfs2_drop_inode(struct inode *inode)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	if (test_bit(GIF_USER, &ip->i_flags) && inode->i_nlink) {
 		struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl;
 		if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags))
 			clear_nlink(inode);
 	}
 	generic_drop_inode(inode);
 }
 /**
  * gfs2_clear_inode - Deallocate an inode when VFS is done with it
  * @inode: The VFS inode
  *
  */
 static void gfs2_clear_inode(struct inode *inode)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	/* This tells us its a "real" inode and not one which only
 	 * serves to contain an address space (see rgrp.c, meta_io.c)
 	 * which therefore doesn't have its own glocks.
 	 */
 	if (test_bit(GIF_USER, &ip->i_flags)) {
 		ip->i_gl->gl_object = NULL;
 		gfs2_glock_schedule_for_reclaim(ip->i_gl);
 		gfs2_glock_put(ip->i_gl);
 		ip->i_gl = NULL;
 		if (ip->i_iopen_gh.gh_gl) {
 			ip->i_iopen_gh.gh_gl->gl_object = NULL;
 			gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 		}
 	}
 }
 static int is_ancestor(const struct dentry *d1, const struct dentry *d2)
 {
 	do {
 		if (d1 == d2)
 			return 1;
 		d1 = d1->d_parent;
 	} while (!IS_ROOT(d1));
 	return 0;
 }
 /**
  * gfs2_show_options - Show mount options for /proc/mounts
  * @s: seq_file structure
  * @mnt: vfsmount
  *
  * Returns: 0 on success or error code
  */
 static int gfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
 {
 	struct gfs2_sbd *sdp = mnt->mnt_sb->s_fs_info;
 	struct gfs2_args *args = &sdp->sd_args;
 	if (is_ancestor(mnt->mnt_root, sdp->sd_master_dir))
 		seq_printf(s, ",meta");
 	if (args->ar_lockproto[0])
 		seq_printf(s, ",lockproto=%s", args->ar_lockproto);
 	if (args->ar_locktable[0])
 		seq_printf(s, ",locktable=%s", args->ar_locktable);
 	if (args->ar_hostdata[0])
 		seq_printf(s, ",hostdata=%s", args->ar_hostdata);
 	if (args->ar_spectator)
 		seq_printf(s, ",spectator");
 	if (args->ar_ignore_local_fs)
 		seq_printf(s, ",ignore_local_fs");
 	if (args->ar_localflocks)
 		seq_printf(s, ",localflocks");
 	if (args->ar_localcaching)
 		seq_printf(s, ",localcaching");
 	if (args->ar_debug)
 		seq_printf(s, ",debug");
 	if (args->ar_upgrade)
 		seq_printf(s, ",upgrade");
 	if (args->ar_num_glockd != GFS2_GLOCKD_DEFAULT)
 		seq_printf(s, ",num_glockd=%u", args->ar_num_glockd);
 	if (args->ar_posix_acl)
 		seq_printf(s, ",acl");
 	if (args->ar_quota != GFS2_QUOTA_DEFAULT) {
 		char *state;
 		switch (args->ar_quota) {
 		case GFS2_QUOTA_OFF:
 			state = "off";
 			break;
 		case GFS2_QUOTA_ACCOUNT:
 			state = "account";
 			break;
 		case GFS2_QUOTA_ON:
 			state = "on";
 			break;
 		default:
 			state = "unknown";
 			break;
 		}
 		seq_printf(s, ",quota=%s", state);
 	}
 	if (args->ar_suiddir)
 		seq_printf(s, ",suiddir");
 	if (args->ar_data != GFS2_DATA_DEFAULT) {
 		char *state;
 		switch (args->ar_data) {
 		case GFS2_DATA_WRITEBACK:
 			state = "writeback";
 			break;
 		case GFS2_DATA_ORDERED:
 			state = "ordered";
 			break;
 		default:
 			state = "unknown";
 			break;
 		}
 		seq_printf(s, ",data=%s", state);
 	}
 	return 0;
 }
 /*
  * We have to (at the moment) hold the inodes main lock to cover
  * the gap between unlocking the shared lock on the iopen lock and
  * taking the exclusive lock. I'd rather do a shared -> exclusive
  * conversion on the iopen lock, but we can change that later. This
  * is safe, just less efficient.
  */
 static void gfs2_delete_inode(struct inode *inode)
 {
 	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int error;
 	if (!test_bit(GIF_USER, &ip->i_flags))
 		goto out;
 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 	if (unlikely(error)) {
 		gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 		goto out;
 	}
 	gfs2_glock_dq_wait(&ip->i_iopen_gh);
 	gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | GL_NOCACHE, &ip->i_iopen_gh);
 	error = gfs2_glock_nq(&ip->i_iopen_gh);
 	if (error)
 		goto out_uninit;
 	if (S_ISDIR(inode->i_mode) &&
 	    (ip->i_di.di_flags & GFS2_DIF_EXHASH)) {
 		error = gfs2_dir_exhash_dealloc(ip);
 		if (error)
 			goto out_unlock;
 	}
 	if (ip->i_di.di_eattr) {
 		error = gfs2_ea_dealloc(ip);
 		if (error)
 			goto out_unlock;
 	}
 	if (!gfs2_is_stuffed(ip)) {
 		error = gfs2_file_dealloc(ip);
 		if (error)
 			goto out_unlock;
 	}
 	error = gfs2_dinode_dealloc(ip);
 	if (error)
 		goto out_unlock;
 	error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks);
 	if (error)
 		goto out_unlock;
 	/* Needs to be done before glock release & also in a transaction */
 	truncate_inode_pages(&inode->i_data, 0);
 	gfs2_trans_end(sdp);
 out_unlock:
 	gfs2_glock_dq(&ip->i_iopen_gh);
 out_uninit:
 	gfs2_holder_uninit(&ip->i_iopen_gh);
 	gfs2_glock_dq_uninit(&gh);
 	if (error && error != GLR_TRYFAILED)
 		fs_warn(sdp, "gfs2_delete_inode: %d\n", error);
 out:
 	truncate_inode_pages(&inode->i_data, 0);
 	clear_inode(inode);
 }
 static struct inode *gfs2_alloc_inode(struct super_block *sb)
 {
 	struct gfs2_inode *ip;
 	ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL);
 	if (ip) {
 		ip->i_flags = 0;
 		ip->i_gl = NULL;
 	}
 	return &ip->i_inode;
 }
 static void gfs2_destroy_inode(struct inode *inode)
 {
 	kmem_cache_free(gfs2_inode_cachep, inode);
 }
 const struct super_operations gfs2_super_ops = {
 	.alloc_inode		= gfs2_alloc_inode,
 	.destroy_inode		= gfs2_destroy_inode,
 	.write_inode		= gfs2_write_inode,
 	.delete_inode		= gfs2_delete_inode,
 	.put_super		= gfs2_put_super,
 	.write_super		= gfs2_write_super,
 	.sync_fs		= gfs2_sync_fs,
 	.write_super_lockfs 	= gfs2_write_super_lockfs,
 	.unlockfs		= gfs2_unlockfs,
 	.statfs			= gfs2_statfs,
 	.remount_fs		= gfs2_remount_fs,
 	.clear_inode		= gfs2_clear_inode,
 	.drop_inode		= gfs2_drop_inode,
 	.show_options		= gfs2_show_options,
 };

fs/gfs2/ops_super.h

View file @ b276058

1	/*		File was deleted
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*
5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.
8	*/
9
10	#ifndef __OPS_SUPER_DOT_H__
11	#define __OPS_SUPER_DOT_H__
12
13	#include <linux/fs.h>
14
15	extern const struct super_operations gfs2_super_ops;
16
17	#endif /* __OPS_SUPER_DOT_H__ */
18		1	/*

fs/gfs2/super.h

Diff comments View file @ b276058

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License version 2.
  */
 #ifndef __SUPER_DOT_H__
 #define __SUPER_DOT_H__
+#include <linux/fs.h>
+#include <linux/dcache.h>
 #include "incore.h"
 void gfs2_lm_unmount(struct gfs2_sbd *sdp);
 static inline unsigned int gfs2_jindex_size(struct gfs2_sbd *sdp)
 {
 	unsigned int x;
 	spin_lock(&sdp->sd_jindex_spin);
 	x = sdp->sd_journals;
 	spin_unlock(&sdp->sd_jindex_spin);
 	return x;
 }
 int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh);
 void gfs2_jindex_free(struct gfs2_sbd *sdp);
 struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid);
 void gfs2_jdesc_make_dirty(struct gfs2_sbd *sdp, unsigned int jid);
 struct gfs2_jdesc *gfs2_jdesc_find_dirty(struct gfs2_sbd *sdp);
 int gfs2_jdesc_check(struct gfs2_jdesc *jd);
 int gfs2_lookup_in_master_dir(struct gfs2_sbd *sdp, char *filename,
 			      struct gfs2_inode **ipp);
 int gfs2_make_fs_rw(struct gfs2_sbd *sdp);
 int gfs2_statfs_init(struct gfs2_sbd *sdp);
 void gfs2_statfs_change(struct gfs2_sbd *sdp,
 			s64 total, s64 free, s64 dinodes);
 int gfs2_statfs_sync(struct gfs2_sbd *sdp);
 int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc);
 int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc);
 int gfs2_freeze_fs(struct gfs2_sbd *sdp);
 void gfs2_unfreeze_fs(struct gfs2_sbd *sdp);
+extern struct file_system_type gfs2_fs_type;
+extern struct file_system_type gfs2meta_fs_type;
+extern const struct export_operations gfs2_export_ops;
+extern const struct super_operations gfs2_super_ops;
+extern struct dentry_operations gfs2_dops;
 #endif /* __SUPER_DOT_H__ */