2006-01-16 23:50:04 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2006-05-19 02:09:15 +07:00
|
|
|
* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
|
2006-01-16 23:50:04 +07:00
|
|
|
*
|
|
|
|
* This copyrighted material is made available to anyone wishing to use,
|
|
|
|
* modify, copy, or redistribute it subject to the terms and conditions
|
2006-09-01 22:05:15 +07:00
|
|
|
* of the GNU General Public License version 2.
|
2006-01-16 23:50:04 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/buffer_head.h>
|
2007-07-17 18:04:28 +07:00
|
|
|
#include <linux/exportfs.h>
|
2006-02-28 05:23:27 +07:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2006-03-29 02:14:04 +07:00
|
|
|
#include <linux/crc32.h>
|
2006-09-19 12:56:29 +07:00
|
|
|
#include <linux/lm_interface.h>
|
2006-01-16 23:50:04 +07:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-28 05:23:27 +07:00
|
|
|
#include "incore.h"
|
2006-01-16 23:50:04 +07:00
|
|
|
#include "dir.h"
|
|
|
|
#include "glock.h"
|
|
|
|
#include "glops.h"
|
|
|
|
#include "inode.h"
|
2007-01-12 02:25:00 +07:00
|
|
|
#include "ops_dentry.h"
|
2007-06-01 20:11:58 +07:00
|
|
|
#include "ops_fstype.h"
|
2006-01-16 23:50:04 +07:00
|
|
|
#include "rgrp.h"
|
2006-03-21 00:30:04 +07:00
|
|
|
#include "util.h"
|
2006-01-16 23:50:04 +07:00
|
|
|
|
2007-06-01 20:11:58 +07:00
|
|
|
#define GFS2_SMALL_FH_SIZE 4
|
2007-06-28 04:07:53 +07:00
|
|
|
#define GFS2_LARGE_FH_SIZE 8
|
2007-07-10 18:28:27 +07:00
|
|
|
#define GFS2_OLD_FH_SIZE 10
|
2007-06-01 20:11:58 +07:00
|
|
|
|
2006-10-14 21:46:30 +07:00
|
|
|
static int gfs2_encode_fh(struct dentry *dentry, __u32 *p, int *len,
|
2006-01-16 23:50:04 +07:00
|
|
|
int connectable)
|
|
|
|
{
|
2006-10-14 21:46:30 +07:00
|
|
|
__be32 *fh = (__force __be32 *)p;
|
2006-01-16 23:50:04 +07:00
|
|
|
struct inode *inode = dentry->d_inode;
|
2006-03-02 03:31:02 +07:00
|
|
|
struct super_block *sb = inode->i_sb;
|
2006-06-15 02:32:57 +07:00
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-01-16 23:50:04 +07:00
|
|
|
|
2006-09-05 03:16:45 +07:00
|
|
|
if (*len < GFS2_SMALL_FH_SIZE ||
|
|
|
|
(connectable && *len < GFS2_LARGE_FH_SIZE))
|
2006-01-16 23:50:04 +07:00
|
|
|
return 255;
|
|
|
|
|
2007-05-15 21:37:50 +07:00
|
|
|
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);
|
2006-09-05 03:16:45 +07:00
|
|
|
*len = GFS2_SMALL_FH_SIZE;
|
2006-01-16 23:50:04 +07:00
|
|
|
|
2006-03-02 03:31:02 +07:00
|
|
|
if (!connectable || inode == sb->s_root->d_inode)
|
2006-01-16 23:50:04 +07:00
|
|
|
return *len;
|
|
|
|
|
|
|
|
spin_lock(&dentry->d_lock);
|
|
|
|
inode = dentry->d_parent->d_inode;
|
2006-06-15 02:32:57 +07:00
|
|
|
ip = GFS2_I(inode);
|
|
|
|
igrab(inode);
|
2006-01-16 23:50:04 +07:00
|
|
|
spin_unlock(&dentry->d_lock);
|
|
|
|
|
2007-05-15 21:37:50 +07:00
|
|
|
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);
|
2006-09-05 03:16:45 +07:00
|
|
|
*len = GFS2_LARGE_FH_SIZE;
|
2006-01-16 23:50:04 +07:00
|
|
|
|
2006-06-15 02:32:57 +07:00
|
|
|
iput(inode);
|
2006-01-16 23:50:04 +07:00
|
|
|
|
|
|
|
return *len;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct get_name_filldir {
|
2006-10-14 09:51:24 +07:00
|
|
|
struct gfs2_inum_host inum;
|
2006-01-16 23:50:04 +07:00
|
|
|
char *name;
|
|
|
|
};
|
|
|
|
|
2007-01-17 22:09:20 +07:00
|
|
|
static int get_name_filldir(void *opaque, const char *name, int length,
|
|
|
|
loff_t offset, u64 inum, unsigned int type)
|
2006-01-16 23:50:04 +07:00
|
|
|
{
|
2007-01-17 22:09:20 +07:00
|
|
|
struct get_name_filldir *gnfd = opaque;
|
2006-01-16 23:50:04 +07:00
|
|
|
|
2007-01-17 22:09:20 +07:00
|
|
|
if (inum != gnfd->inum.no_addr)
|
2006-01-16 23:50:04 +07:00
|
|
|
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;
|
2006-09-04 23:49:07 +07:00
|
|
|
u64 offset = 0;
|
2006-01-16 23:50:04 +07:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (!dir)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!S_ISDIR(dir->i_mode) || !inode)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-06-15 02:32:57 +07:00
|
|
|
dip = GFS2_I(dir);
|
|
|
|
ip = GFS2_I(inode);
|
2006-01-16 23:50:04 +07:00
|
|
|
|
|
|
|
*name = 0;
|
2007-05-15 21:37:50 +07:00
|
|
|
gnfd.inum.no_addr = ip->i_no_addr;
|
|
|
|
gnfd.inum.no_formal_ino = ip->i_no_formal_ino;
|
2006-01-16 23:50:04 +07:00
|
|
|
gnfd.name = name;
|
|
|
|
|
|
|
|
error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-03-29 02:14:04 +07:00
|
|
|
error = gfs2_dir_read(dir, &offset, &gnfd, get_name_filldir);
|
2006-01-16 23:50:04 +07:00
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&gh);
|
|
|
|
|
|
|
|
if (!error && !*name)
|
|
|
|
error = -ENOENT;
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *gfs2_get_parent(struct dentry *child)
|
|
|
|
{
|
2006-03-29 02:14:04 +07:00
|
|
|
struct qstr dotdot;
|
2006-01-16 23:50:04 +07:00
|
|
|
struct inode *inode;
|
|
|
|
struct dentry *dentry;
|
|
|
|
|
2006-03-29 02:14:04 +07:00
|
|
|
gfs2_str2qstr(&dotdot, "..");
|
2008-07-24 01:42:05 +07:00
|
|
|
inode = gfs2_lookupi(child->d_inode, &dotdot, 1);
|
2006-03-21 00:30:04 +07:00
|
|
|
|
|
|
|
if (!inode)
|
|
|
|
return ERR_PTR(-ENOENT);
|
2006-09-06 02:56:17 +07:00
|
|
|
/*
|
|
|
|
* In case of an error, @inode carries the error value, and we
|
|
|
|
* have to return that as a(n invalid) pointer to dentry.
|
|
|
|
*/
|
2006-03-21 00:30:04 +07:00
|
|
|
if (IS_ERR(inode))
|
2008-02-07 15:15:26 +07:00
|
|
|
return ERR_CAST(inode);
|
2006-01-16 23:50:04 +07:00
|
|
|
|
|
|
|
dentry = d_alloc_anon(inode);
|
|
|
|
if (!dentry) {
|
|
|
|
iput(inode);
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
2007-01-12 02:25:00 +07:00
|
|
|
dentry->d_op = &gfs2_dops;
|
2006-01-16 23:50:04 +07:00
|
|
|
return dentry;
|
|
|
|
}
|
|
|
|
|
2007-10-22 06:42:14 +07:00
|
|
|
static struct dentry *gfs2_get_dentry(struct super_block *sb,
|
|
|
|
struct gfs2_inum_host *inum)
|
2006-01-16 23:50:04 +07:00
|
|
|
{
|
2006-02-28 05:23:27 +07:00
|
|
|
struct gfs2_sbd *sdp = sb->s_fs_info;
|
2006-01-16 23:50:04 +07:00
|
|
|
struct gfs2_holder i_gh, ri_gh, rgd_gh;
|
|
|
|
struct gfs2_rgrpd *rgd;
|
|
|
|
struct inode *inode;
|
|
|
|
struct dentry *dentry;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* System files? */
|
|
|
|
|
2007-05-15 21:37:50 +07:00
|
|
|
inode = gfs2_ilookup(sb, inum->no_addr);
|
2006-01-16 23:50:04 +07:00
|
|
|
if (inode) {
|
2007-05-15 21:37:50 +07:00
|
|
|
if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) {
|
2006-01-16 23:50:04 +07:00
|
|
|
iput(inode);
|
|
|
|
return ERR_PTR(-ESTALE);
|
|
|
|
}
|
|
|
|
goto out_inode;
|
|
|
|
}
|
|
|
|
|
2006-06-15 02:32:57 +07:00
|
|
|
error = gfs2_glock_nq_num(sdp, inum->no_addr, &gfs2_inode_glops,
|
2007-01-23 00:10:39 +07:00
|
|
|
LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
|
2006-01-16 23:50:04 +07:00
|
|
|
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);
|
|
|
|
|
2007-06-28 04:07:53 +07:00
|
|
|
inode = gfs2_inode_lookup(sb, DT_UNKNOWN,
|
2007-06-28 04:07:08 +07:00
|
|
|
inum->no_addr,
|
[GFS2] Alternate gfs2_iget to avoid looking up inodes being freed
There is a possible deadlock between two processes on the same node, where one
process is deleting an inode, and another process is looking for allocated but
unused inodes to delete in order to create more space.
process A does an iput() on inode X, and it's i_count drops to 0. This causes
iput_final() to be called, which puts an inode into state I_FREEING at
generic_delete_inode(). There no point between when iput_final() is called, and
when I_FREEING is set where GFS2 could acquire any glocks. Once I_FREEING is
set, no other process on that node can successfully look up that inode until
the delete finishes.
process B locks the the resource group for the same inode in get_local_rgrp(),
which is called by gfs2_inplace_reserve_i()
process A tries to lock the resource group for the inode in
gfs2_dinode_dealloc(), but it's already locked by process B
process B waits in find_inode for the inode to have the I_FREEING state cleared.
Deadlock.
This patch solves the problem by adding an alternative to gfs2_iget(),
gfs2_iget_skip(), that simply skips any inodes that are in the I_FREEING
state.o The alternate test function is just like the original one, except that
it fails if the inode is being freed, and sets a skipped flag. The alternate
set function is just like the original, except that it fails if the skipped
flag is set. Only try_rgrp_unlink() calls gfs2_iget_skip() instead of
gfs2_iget().
Signed-off-by: Benjamin E. Marzinski <bmarzins@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
2007-09-19 01:33:18 +07:00
|
|
|
0, 0);
|
2006-06-15 02:32:57 +07:00
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
error = PTR_ERR(inode);
|
2006-01-16 23:50:04 +07:00
|
|
|
goto fail;
|
2006-06-15 02:32:57 +07:00
|
|
|
}
|
2006-01-16 23:50:04 +07:00
|
|
|
|
2006-06-15 02:32:57 +07:00
|
|
|
error = gfs2_inode_refresh(GFS2_I(inode));
|
2006-01-16 23:50:04 +07:00
|
|
|
if (error) {
|
2006-06-15 02:32:57 +07:00
|
|
|
iput(inode);
|
2006-01-16 23:50:04 +07:00
|
|
|
goto fail;
|
|
|
|
}
|
2007-06-28 04:07:53 +07:00
|
|
|
|
|
|
|
/* Pick up the works we bypass in gfs2_inode_lookup */
|
|
|
|
if (inode->i_state & I_NEW)
|
|
|
|
gfs2_set_iop(inode);
|
|
|
|
|
2007-05-15 21:37:50 +07:00
|
|
|
if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) {
|
|
|
|
iput(inode);
|
|
|
|
goto fail;
|
|
|
|
}
|
2006-01-16 23:50:04 +07:00
|
|
|
|
|
|
|
error = -EIO;
|
2006-06-15 02:32:57 +07:00
|
|
|
if (GFS2_I(inode)->i_di.di_flags & GFS2_DIF_SYSTEM) {
|
|
|
|
iput(inode);
|
2006-01-16 23:50:04 +07:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
|
2006-06-15 02:32:57 +07:00
|
|
|
out_inode:
|
2006-01-16 23:50:04 +07:00
|
|
|
dentry = d_alloc_anon(inode);
|
|
|
|
if (!dentry) {
|
|
|
|
iput(inode);
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
2007-01-12 02:25:00 +07:00
|
|
|
dentry->d_op = &gfs2_dops;
|
2006-01-16 23:50:04 +07:00
|
|
|
return dentry;
|
|
|
|
|
2006-06-15 02:32:57 +07:00
|
|
|
fail_rgd:
|
2006-01-16 23:50:04 +07:00
|
|
|
gfs2_glock_dq_uninit(&rgd_gh);
|
|
|
|
|
2006-06-15 02:32:57 +07:00
|
|
|
fail_rindex:
|
2006-01-16 23:50:04 +07:00
|
|
|
gfs2_glock_dq_uninit(&ri_gh);
|
|
|
|
|
2006-06-15 02:32:57 +07:00
|
|
|
fail:
|
2006-01-16 23:50:04 +07:00
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
return ERR_PTR(error);
|
|
|
|
}
|
|
|
|
|
2007-10-22 06:42:14 +07:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-22 06:42:17 +07:00
|
|
|
const struct export_operations gfs2_export_ops = {
|
2006-01-16 23:50:04 +07:00
|
|
|
.encode_fh = gfs2_encode_fh,
|
2007-10-22 06:42:14 +07:00
|
|
|
.fh_to_dentry = gfs2_fh_to_dentry,
|
|
|
|
.fh_to_parent = gfs2_fh_to_parent,
|
2006-01-16 23:50:04 +07:00
|
|
|
.get_name = gfs2_get_name,
|
|
|
|
.get_parent = gfs2_get_parent,
|
|
|
|
};
|
|
|
|
|