/*
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
- * Copyright (C) 2004-2005 Red Hat, Inc. 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 v.2.
+ * 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 <asm/semaphore.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_export.h"
+#include "ops_dentry.h"
+#include "ops_fstype.h"
#include "rgrp.h"
+#include "util.h"
-static struct dentry *gfs2_decode_fh(struct super_block *sb,
- __u32 *fh,
- int fh_len,
- int fh_type,
- int (*acceptable)(void *context,
- struct dentry *dentry),
- void *context)
-{
- struct gfs2_inum this, parent;
-
- atomic_inc(&get_v2sdp(sb)->sd_ops_export);
-
- if (fh_type != fh_len)
- return NULL;
-
- memset(&parent, 0, sizeof(struct gfs2_inum));
-
- switch (fh_type) {
- case 8:
- parent.no_formal_ino = ((uint64_t)be32_to_cpu(fh[4])) << 32;
- parent.no_formal_ino |= be32_to_cpu(fh[5]);
- parent.no_addr = ((uint64_t)be32_to_cpu(fh[6])) << 32;
- parent.no_addr |= be32_to_cpu(fh[7]);
- case 4:
- this.no_formal_ino = ((uint64_t)be32_to_cpu(fh[0])) << 32;
- this.no_formal_ino |= be32_to_cpu(fh[1]);
- this.no_addr = ((uint64_t)be32_to_cpu(fh[2])) << 32;
- this.no_addr |= be32_to_cpu(fh[3]);
- break;
- default:
- return NULL;
- }
-
- return gfs2_export_ops.find_exported_dentry(sb, &this, &parent,
- acceptable, context);
-}
+#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 *fh, int *len,
+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 gfs2_inode *ip = get_v2ip(inode);
- struct gfs2_sbd *sdp = ip->i_sbd;
+ struct super_block *sb = inode->i_sb;
+ struct gfs2_inode *ip = GFS2_I(inode);
- atomic_inc(&sdp->sd_ops_export);
-
- if (*len < 4 || (connectable && *len < 8))
+ if (*len < GFS2_SMALL_FH_SIZE ||
+ (connectable && *len < GFS2_LARGE_FH_SIZE))
return 255;
- fh[0] = ip->i_num.no_formal_ino >> 32;
- fh[0] = cpu_to_be32(fh[0]);
- fh[1] = ip->i_num.no_formal_ino & 0xFFFFFFFF;
- fh[1] = cpu_to_be32(fh[1]);
- fh[2] = ip->i_num.no_addr >> 32;
- fh[2] = cpu_to_be32(fh[2]);
- fh[3] = ip->i_num.no_addr & 0xFFFFFFFF;
- fh[3] = cpu_to_be32(fh[3]);
- *len = 4;
-
- if (!connectable || ip == sdp->sd_root_dir)
+ 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 = get_v2ip(inode);
- gfs2_inode_hold(ip);
+ ip = GFS2_I(inode);
+ igrab(inode);
spin_unlock(&dentry->d_lock);
- fh[4] = ip->i_num.no_formal_ino >> 32;
- fh[4] = cpu_to_be32(fh[4]);
- fh[5] = ip->i_num.no_formal_ino & 0xFFFFFFFF;
- fh[5] = cpu_to_be32(fh[5]);
- fh[6] = ip->i_num.no_addr >> 32;
- fh[6] = cpu_to_be32(fh[6]);
- fh[7] = ip->i_num.no_addr & 0xFFFFFFFF;
- fh[7] = cpu_to_be32(fh[7]);
- *len = 8;
+ 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;
- gfs2_inode_put(ip);
+ iput(inode);
return *len;
}
struct get_name_filldir {
- struct gfs2_inum inum;
+ struct gfs2_inum_host inum;
char *name;
};
-static int get_name_filldir(void *opaque, const char *name, unsigned int length,
- uint64_t offset, struct gfs2_inum *inum,
- unsigned int type)
+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 = (struct get_name_filldir *)opaque;
+ struct get_name_filldir *gnfd = opaque;
- if (!gfs2_inum_equal(inum, &gnfd->inum))
+ if (inum != gnfd->inum.no_addr)
return 0;
memcpy(gnfd->name, name, length);
struct gfs2_inode *dip, *ip;
struct get_name_filldir gnfd;
struct gfs2_holder gh;
- uint64_t offset = 0;
+ u64 offset = 0;
int error;
if (!dir)
return -EINVAL;
- atomic_inc(&get_v2sdp(dir->i_sb)->sd_ops_export);
-
if (!S_ISDIR(dir->i_mode) || !inode)
return -EINVAL;
- dip = get_v2ip(dir);
- ip = get_v2ip(inode);
+ dip = GFS2_I(dir);
+ ip = GFS2_I(inode);
*name = 0;
- gnfd.inum = ip->i_num;
+ 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(dip, &offset, &gnfd, get_name_filldir);
+ error = gfs2_dir_read(dir, &offset, &gnfd, get_name_filldir);
gfs2_glock_dq_uninit(&gh);
static struct dentry *gfs2_get_parent(struct dentry *child)
{
- struct gfs2_inode *dip = get_v2ip(child->d_inode);
- struct qstr dotdot = { .name = "..", .len = 2 };
- struct gfs2_inode *ip;
+ struct qstr dotdot;
struct inode *inode;
struct dentry *dentry;
- int error;
-
- atomic_inc(&dip->i_sbd->sd_ops_export);
-
- error = gfs2_lookupi(dip, &dotdot, 1, &ip);
- if (error)
- return ERR_PTR(error);
- inode = gfs2_ip2v(ip);
- gfs2_inode_put(ip);
+ gfs2_str2qstr(&dotdot, "..");
+ inode = gfs2_lookupi(child->d_inode, &dotdot, 1, NULL);
if (!inode)
- return ERR_PTR(-ENOMEM);
+ return ERR_PTR(-ENOENT);
+ /*
+ * In case of an error, @inode carries the error value, and we
+ * have to return that as a(n invalid) pointer to dentry.
+ */
+ if (IS_ERR(inode))
+ return ERR_CAST(inode);
dentry = d_alloc_anon(inode);
if (!dentry) {
return ERR_PTR(-ENOMEM);
}
+ dentry->d_op = &gfs2_dops;
return dentry;
}
-static struct dentry *gfs2_get_dentry(struct super_block *sb, void *inum_p)
+static struct dentry *gfs2_get_dentry(struct super_block *sb,
+ struct gfs2_inum_host *inum)
{
- struct gfs2_sbd *sdp = get_v2sdp(sb);
- struct gfs2_inum *inum = (struct gfs2_inum *)inum_p;
+ struct gfs2_sbd *sdp = sb->s_fs_info;
struct gfs2_holder i_gh, ri_gh, rgd_gh;
struct gfs2_rgrpd *rgd;
- struct gfs2_inode *ip;
struct inode *inode;
struct dentry *dentry;
int error;
- atomic_inc(&sdp->sd_ops_export);
-
/* System files? */
- inode = gfs2_iget(sb, inum);
+ inode = gfs2_ilookup(sb, inum->no_addr);
if (inode) {
- ip = get_v2ip(inode);
- if (ip->i_num.no_formal_ino != inum->no_formal_ino) {
+ 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 | GL_LOCAL_EXCL,
- &i_gh);
+ 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_inode_get(i_gh.gh_gl, inum, NO_CREATE, &ip);
- if (error)
- goto fail;
- if (ip)
- goto out_ip;
-
error = gfs2_rindex_hold(sdp, &ri_gh);
if (error)
goto fail;
gfs2_glock_dq_uninit(&rgd_gh);
gfs2_glock_dq_uninit(&ri_gh);
- error = gfs2_inode_get(i_gh.gh_gl, inum, CREATE, &ip);
- if (error)
+ 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(ip);
+ error = gfs2_inode_refresh(GFS2_I(inode));
if (error) {
- gfs2_inode_put(ip);
+ iput(inode);
goto fail;
}
- atomic_inc(&sdp->sd_fh2dentry_misses);
+ /* 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;
+ }
- out_ip:
error = -EIO;
- if (ip->i_di.di_flags & GFS2_DIF_SYSTEM) {
- gfs2_inode_put(ip);
+ if (GFS2_I(inode)->i_di.di_flags & GFS2_DIF_SYSTEM) {
+ iput(inode);
goto fail;
}
gfs2_glock_dq_uninit(&i_gh);
- inode = gfs2_ip2v(ip);
- gfs2_inode_put(ip);
-
- if (!inode)
- return ERR_PTR(-ENOMEM);
-
- out_inode:
+out_inode:
dentry = d_alloc_anon(inode);
if (!dentry) {
iput(inode);
return ERR_PTR(-ENOMEM);
}
+ dentry->d_op = &gfs2_dops;
return dentry;
- fail_rgd:
+fail_rgd:
gfs2_glock_dq_uninit(&rgd_gh);
- fail_rindex:
+fail_rindex:
gfs2_glock_dq_uninit(&ri_gh);
- fail:
+fail:
gfs2_glock_dq_uninit(&i_gh);
return ERR_PTR(error);
}
-struct export_operations gfs2_export_ops = {
- .decode_fh = gfs2_decode_fh,
+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,
- .get_dentry = gfs2_get_dentry,
};
git://ftp.safe.ca / safe / jmp / linux-2.6 / blobdiff