Hi,
GFS2 changes look good to me:
Acked-by: Steven Whitehouse <swhiteho@xxxxxxxxxx>
Steve.
On Fri, 2011-12-30 at 06:27 +0000, Al Viro wrote:
> a) cleancache is abusing ->encode_fh(). Badly. In particular,
> on-stack(!) struct dentry is a lousy idea.
>
> b) ceph is _also_ abusing ->encode_fh(). For one thing, it
> gets fhandle that depends on object name if you give it a large enough
> buffer to put result into. This is absolutely broken - having cross-directory
> renames break opened files is bad enough, but having that happen on rename()
> _inside_ a directory... Besides, the only thing that ought to depend on
> max_len passed to ->encode_fh() should be "do I tell the caller to come
> back with bigger one?".
>
> c) cleancache relies on (unguaranteed) property of ->encode_fh() -
> if the last argument is 0, most of the instances do not look at anything
> other than dentry->d_inode. Guess what happens with ceph? Right, we
> end up doing spin_lock(&d.d_lock) and dget(d.d_parent). Even though
> struct dentry d is auto, has no initializer and the only thing done to
> it is assignment to d.d_inode. IOW, that spinlock has undefined contents
> and in case if you happen to pass that spin_lock(), dget(random_pointer)
> will get you an increment of value in memory at random address. Fun...
> Moreover, on FAT we get dereference (read-only, but still it's at least an
> oops) of uninitialized pointer - d.d_parent->d_inode is followed.
>
> d) after a look through ->encode_fh() instances:
> * all of them care about dentry->d_inode (d'oh)
> * most of them look at anything else only if that inode is a directory and
> the last argument is non-zero; in that case dentry->d_lock is grabbed and
> (usually) some properties of dentry->d_parent->d_inode are looked at.
> * most of them never do anything blocking. Exceptions:
> * ceph doing dget()/dput() on parent. For no good reason, since
> everything it does with that parent could've been done before dropping
> dentry->d_lock (and we don't do anything else that might've blocked)
> * gfs2 - same, but it does igrab() on parent's inode instead.
> Again, for no good reason whatsoever.
>
> e) in case of default encode_fh, cleancache gets one difference from
> exportfs_encode_fh() behaviour - it ignores ->i_generation. Note that for
> non-default encode_fh() i_generation is *not* ignored.
>
> f) in case of _no_ export operations being present, cleancache is
> basically praying for inumbers being stable for some unknown reason. Which
> is about as efficient as prayers tend to be...
>
> One kinda-sorta solution (besides kicking cleancache out of tree)
> would be to modify ->encode_fh() API - instead of dentry + connectable
> pass it inode + NULL-or-parent-inode, with ->d_lock held by caller. And
> demand it to be non-blocking, obviously... It would obviously break
> ceph ->encode_fh(), since that sucker apparently wants the name of last
> component anyway. OTOH, that's broken for reasons mentioned above.
> OTTH, fhandle encoding is bloody close to user-visible ABI ;-/
>
> _Absolutely_ untested patch along those lines follows; it definitely
> breaks ceph, it does nothing for (e) and (f), it might be broken in all kinds
> of dumb ways, etc. Comments are welcome...
>
> diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
> index 5f77166..e60dbe1 100644
> --- a/fs/btrfs/export.c
> +++ b/fs/btrfs/export.c
> @@ -13,15 +13,14 @@
> parent_root_objectid) / 4)
> #define BTRFS_FID_SIZE_CONNECTABLE_ROOT (sizeof(struct btrfs_fid) / 4)
>
> -static int btrfs_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
> - int connectable)
> +static int btrfs_encode_fh(struct inode *inode, u32 *fh, int *max_len,
> + struct inode *parent)
> {
> struct btrfs_fid *fid = (struct btrfs_fid *)fh;
> - struct inode *inode = dentry->d_inode;
> int len = *max_len;
> int type;
>
> - if (connectable && (len < BTRFS_FID_SIZE_CONNECTABLE)) {
> + if (parent && (len < BTRFS_FID_SIZE_CONNECTABLE)) {
> *max_len = BTRFS_FID_SIZE_CONNECTABLE;
> return 255;
> } else if (len < BTRFS_FID_SIZE_NON_CONNECTABLE) {
> @@ -36,19 +35,13 @@ static int btrfs_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
> fid->root_objectid = BTRFS_I(inode)->root->objectid;
> fid->gen = inode->i_generation;
>
> - if (connectable && !S_ISDIR(inode->i_mode)) {
> - struct inode *parent;
> + if (parent) {
> u64 parent_root_id;
>
> - spin_lock(&dentry->d_lock);
> -
> - parent = dentry->d_parent->d_inode;
> fid->parent_objectid = BTRFS_I(parent)->location.objectid;
> fid->parent_gen = parent->i_generation;
> parent_root_id = BTRFS_I(parent)->root->objectid;
>
> - spin_unlock(&dentry->d_lock);
> -
> if (parent_root_id != fid->root_objectid) {
> fid->parent_root_objectid = parent_root_id;
> len = BTRFS_FID_SIZE_CONNECTABLE_ROOT;
> diff --git a/fs/ceph/export.c b/fs/ceph/export.c
> index 9fbcdec..bcaca95 100644
> --- a/fs/ceph/export.c
> +++ b/fs/ceph/export.c
> @@ -249,7 +249,9 @@ static struct dentry *ceph_fh_to_parent(struct super_block *sb,
> }
>
> const struct export_operations ceph_export_ops = {
> +#ifdef BROKEN
> .encode_fh = ceph_encode_fh,
> +#endif
> .fh_to_dentry = ceph_fh_to_dentry,
> .fh_to_parent = ceph_fh_to_parent,
> };
> diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
> index b05acb7..f8f7029 100644
> --- a/fs/exportfs/expfs.c
> +++ b/fs/exportfs/expfs.c
> @@ -304,24 +304,23 @@ out:
>
> /**
> * export_encode_fh - default export_operations->encode_fh function
> - * @dentry: the dentry to encode
> + * @inode: the object to encode
> * @fh: where to store the file handle fragment
> * @max_len: maximum length to store there
> - * @connectable: whether to store parent information
> + * @parent: parent directory inode, if wanted
> *
> * This default encode_fh function assumes that the 32 inode number
> * is suitable for locating an inode, and that the generation number
> * can be used to check that it is still valid. It places them in the
> * filehandle fragment where export_decode_fh expects to find them.
> */
> -static int export_encode_fh(struct dentry *dentry, struct fid *fid,
> - int *max_len, int connectable)
> +static int export_encode_fh(struct inode *inode, struct fid *fid,
> + int *max_len, struct inode *parent)
> {
> - struct inode * inode = dentry->d_inode;
> int len = *max_len;
> int type = FILEID_INO32_GEN;
>
> - if (connectable && (len < 4)) {
> + if (parent && (len < 4)) {
> *max_len = 4;
> return 255;
> } else if (len < 2) {
> @@ -332,14 +331,9 @@ static int export_encode_fh(struct dentry *dentry, struct fid *fid,
> len = 2;
> fid->i32.ino = inode->i_ino;
> fid->i32.gen = inode->i_generation;
> - if (connectable && !S_ISDIR(inode->i_mode)) {
> - struct inode *parent;
> -
> - spin_lock(&dentry->d_lock);
> - parent = dentry->d_parent->d_inode;
> + if (parent) {
> fid->i32.parent_ino = parent->i_ino;
> fid->i32.parent_gen = parent->i_generation;
> - spin_unlock(&dentry->d_lock);
> len = 4;
> type = FILEID_INO32_GEN_PARENT;
> }
> @@ -352,11 +346,19 @@ int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
> {
> const struct export_operations *nop = dentry->d_sb->s_export_op;
> int error;
> + struct inode *inode = dentry->d_inode, *parent = NULL;
>
> + if (connectable && !S_ISDIR(inode->i_mode)) {
> + spin_lock(&dentry->d_lock);
> + parent = dentry->d_parent->d_inode;
> + BUG_ON(!parent);
> + }
> if (nop->encode_fh)
> - error = nop->encode_fh(dentry, fid->raw, max_len, connectable);
> + error = nop->encode_fh(inode, fid->raw, max_len, parent);
> else
> - error = export_encode_fh(dentry, fid, max_len, connectable);
> + error = export_encode_fh(inode, fid, max_len, parent);
> + if (parent)
> + spin_unlock(&dentry->d_lock);
>
> return error;
> }
> diff --git a/fs/fat/inode.c b/fs/fat/inode.c
> index 7873797..0813c70 100644
> --- a/fs/fat/inode.c
> +++ b/fs/fat/inode.c
> @@ -752,10 +752,9 @@ static struct dentry *fat_fh_to_dentry(struct super_block *sb,
> }
>
> static int
> -fat_encode_fh(struct dentry *de, __u32 *fh, int *lenp, int connectable)
> +fat_encode_fh(struct inode *inode, __u32 *fh, int *lenp, struct inode *parent)
> {
> int len = *lenp;
> - struct inode *inode = de->d_inode;
> u32 ipos_h, ipos_m, ipos_l;
>
> if (len < 5) {
> @@ -771,9 +770,9 @@ fat_encode_fh(struct dentry *de, __u32 *fh, int *lenp, int connectable)
> fh[1] = inode->i_generation;
> fh[2] = ipos_h;
> fh[3] = ipos_m | MSDOS_I(inode)->i_logstart;
> - spin_lock(&de->d_lock);
> - fh[4] = ipos_l | MSDOS_I(de->d_parent->d_inode)->i_logstart;
> - spin_unlock(&de->d_lock);
> + fh[4] = ipos_l;
> + if (parent)
> + fh[4] |= MSDOS_I(parent)->i_logstart;
> return 3;
> }
>
> diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
> index 64cf8d0..25ca731 100644
> --- a/fs/fuse/inode.c
> +++ b/fs/fuse/inode.c
> @@ -627,12 +627,10 @@ static struct dentry *fuse_get_dentry(struct super_block *sb,
> return ERR_PTR(err);
> }
>
> -static int fuse_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
> - int connectable)
> +static int fuse_encode_fh(struct inode *inode, u32 *fh, int *max_len,
> + struct inode *parent)
> {
> - struct inode *inode = dentry->d_inode;
> - bool encode_parent = connectable && !S_ISDIR(inode->i_mode);
> - int len = encode_parent ? 6 : 3;
> + int len = parent ? 6 : 3;
> u64 nodeid;
> u32 generation;
>
> @@ -648,14 +646,9 @@ static int fuse_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
> fh[1] = (u32)(nodeid & 0xffffffff);
> fh[2] = generation;
>
> - if (encode_parent) {
> - struct inode *parent;
> -
> - spin_lock(&dentry->d_lock);
> - parent = dentry->d_parent->d_inode;
> + if (parent) {
> nodeid = get_fuse_inode(parent)->nodeid;
> generation = parent->i_generation;
> - spin_unlock(&dentry->d_lock);
>
> fh[3] = (u32)(nodeid >> 32);
> fh[4] = (u32)(nodeid & 0xffffffff);
> @@ -663,7 +656,7 @@ static int fuse_encode_fh(struct dentry *dentry, u32 *fh, int *max_len,
> }
>
> *max_len = len;
> - return encode_parent ? 0x82 : 0x81;
> + return parent ? 0x82 : 0x81;
> }
>
> static struct dentry *fuse_fh_to_dentry(struct super_block *sb,
> diff --git a/fs/gfs2/export.c b/fs/gfs2/export.c
> index fe9945f..faa7916 100644
> --- a/fs/gfs2/export.c
> +++ b/fs/gfs2/export.c
> @@ -28,15 +28,14 @@
> #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)
> +static int gfs2_encode_fh(struct inode *inode, __u32 *p, int *len,
> + struct inode *parent)
> {
> __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 (connectable && (*len < GFS2_LARGE_FH_SIZE)) {
> + if (parent && (*len < GFS2_LARGE_FH_SIZE)) {
> *len = GFS2_LARGE_FH_SIZE;
> return 255;
> } else if (*len < GFS2_SMALL_FH_SIZE) {
> @@ -50,14 +49,10 @@ static int gfs2_encode_fh(struct dentry *dentry, __u32 *p, int *len,
> fh[3] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF);
> *len = GFS2_SMALL_FH_SIZE;
>
> - if (!connectable || inode == sb->s_root->d_inode)
> + if (!parent || 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);
> + ip = GFS2_I(parent);
>
> fh[4] = cpu_to_be32(ip->i_no_formal_ino >> 32);
> fh[5] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF);
> @@ -65,8 +60,6 @@ static int gfs2_encode_fh(struct dentry *dentry, __u32 *p, int *len,
> fh[7] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF);
> *len = GFS2_LARGE_FH_SIZE;
>
> - iput(inode);
> -
> return *len;
> }
>
> diff --git a/fs/isofs/export.c b/fs/isofs/export.c
> index dd4687f..aa4356d 100644
> --- a/fs/isofs/export.c
> +++ b/fs/isofs/export.c
> @@ -107,12 +107,11 @@ static struct dentry *isofs_export_get_parent(struct dentry *child)
> }
>
> static int
> -isofs_export_encode_fh(struct dentry *dentry,
> +isofs_export_encode_fh(struct inode *inode,
> __u32 *fh32,
> int *max_len,
> - int connectable)
> + struct inode *parent)
> {
> - struct inode * inode = dentry->d_inode;
> struct iso_inode_info * ei = ISOFS_I(inode);
> int len = *max_len;
> int type = 1;
> @@ -124,7 +123,7 @@ isofs_export_encode_fh(struct dentry *dentry,
> * offset of the inode and the upper 16 bits of fh32[1] to
> * hold the offset of the parent.
> */
> - if (connectable && (len < 5)) {
> + if (parent && (len < 5)) {
> *max_len = 5;
> return 255;
> } else if (len < 3) {
> @@ -136,16 +135,12 @@ isofs_export_encode_fh(struct dentry *dentry,
> fh32[0] = ei->i_iget5_block;
> fh16[2] = (__u16)ei->i_iget5_offset; /* fh16 [sic] */
> fh32[2] = inode->i_generation;
> - if (connectable && !S_ISDIR(inode->i_mode)) {
> - struct inode *parent;
> + if (parent) {
> struct iso_inode_info *eparent;
> - spin_lock(&dentry->d_lock);
> - parent = dentry->d_parent->d_inode;
> eparent = ISOFS_I(parent);
> fh32[3] = eparent->i_iget5_block;
> fh16[3] = (__u16)eparent->i_iget5_offset; /* fh16 [sic] */
> fh32[4] = parent->i_generation;
> - spin_unlock(&dentry->d_lock);
> len = 5;
> type = 2;
> }
> diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
> index 1cd3f62..958e1cb 100644
> --- a/fs/nilfs2/namei.c
> +++ b/fs/nilfs2/namei.c
> @@ -519,31 +519,24 @@ static struct dentry *nilfs_fh_to_parent(struct super_block *sb, struct fid *fh,
> return nilfs_get_dentry(sb, fid->cno, fid->parent_ino, fid->parent_gen);
> }
>
> -static int nilfs_encode_fh(struct dentry *dentry, __u32 *fh, int *lenp,
> - int connectable)
> +static int nilfs_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
> + struct inode *parent)
> {
> struct nilfs_fid *fid = (struct nilfs_fid *)fh;
> - struct inode *inode = dentry->d_inode;
> struct nilfs_root *root = NILFS_I(inode)->i_root;
> int type;
>
> if (*lenp < NILFS_FID_SIZE_NON_CONNECTABLE ||
> - (connectable && *lenp < NILFS_FID_SIZE_CONNECTABLE))
> + (parent && *lenp < NILFS_FID_SIZE_CONNECTABLE))
> return 255;
>
> fid->cno = root->cno;
> fid->ino = inode->i_ino;
> fid->gen = inode->i_generation;
>
> - if (connectable && !S_ISDIR(inode->i_mode)) {
> - struct inode *parent;
> -
> - spin_lock(&dentry->d_lock);
> - parent = dentry->d_parent->d_inode;
> + if (parent) {
> fid->parent_ino = parent->i_ino;
> fid->parent_gen = parent->i_generation;
> - spin_unlock(&dentry->d_lock);
> -
> type = FILEID_NILFS_WITH_PARENT;
> *lenp = NILFS_FID_SIZE_CONNECTABLE;
> } else {
> diff --git a/fs/ocfs2/export.c b/fs/ocfs2/export.c
> index 745db42..322216a 100644
> --- a/fs/ocfs2/export.c
> +++ b/fs/ocfs2/export.c
> @@ -177,21 +177,23 @@ bail:
> return parent;
> }
>
> -static int ocfs2_encode_fh(struct dentry *dentry, u32 *fh_in, int *max_len,
> - int connectable)
> +static int ocfs2_encode_fh(struct inode *inode, u32 *fh_in, int *max_len,
> + struct inode *parent)
> {
> - struct inode *inode = dentry->d_inode;
> int len = *max_len;
> int type = 1;
> u64 blkno;
> u32 generation;
> __le32 *fh = (__force __le32 *) fh_in;
>
> +#ifdef TRACE_HOOKS_ARE_NOT_BRAINDEAD_IN_YOUR_OPINION
> +#error "You go ahead and fix that mess, then. Somehow"
> trace_ocfs2_encode_fh_begin(dentry, dentry->d_name.len,
> dentry->d_name.name,
> fh, len, connectable);
> +#endif
>
> - if (connectable && (len < 6)) {
> + if (parent && (len < 6)) {
> *max_len = 6;
> type = 255;
> goto bail;
> @@ -211,12 +213,7 @@ static int ocfs2_encode_fh(struct dentry *dentry, u32 *fh_in, int *max_len,
> fh[1] = cpu_to_le32((u32)(blkno & 0xffffffff));
> fh[2] = cpu_to_le32(generation);
>
> - if (connectable && !S_ISDIR(inode->i_mode)) {
> - struct inode *parent;
> -
> - spin_lock(&dentry->d_lock);
> -
> - parent = dentry->d_parent->d_inode;
> + if (parent) {
> blkno = OCFS2_I(parent)->ip_blkno;
> generation = parent->i_generation;
>
> @@ -224,8 +221,6 @@ static int ocfs2_encode_fh(struct dentry *dentry, u32 *fh_in, int *max_len,
> fh[4] = cpu_to_le32((u32)(blkno & 0xffffffff));
> fh[5] = cpu_to_le32(generation);
>
> - spin_unlock(&dentry->d_lock);
> -
> len = 6;
> type = 2;
>
> diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
> index 9e8cd5a..0095740 100644
> --- a/fs/reiserfs/inode.c
> +++ b/fs/reiserfs/inode.c
> @@ -1592,13 +1592,12 @@ struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid,
> (fh_type == 6) ? fid->raw[5] : 0);
> }
>
> -int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
> - int need_parent)
> +int reiserfs_encode_fh(struct inode *inode, __u32 * data, int *lenp,
> + struct inode *parent)
> {
> - struct inode *inode = dentry->d_inode;
> int maxlen = *lenp;
>
> - if (need_parent && (maxlen < 5)) {
> + if (parent && (maxlen < 5)) {
> *lenp = 5;
> return 255;
> } else if (maxlen < 3) {
> @@ -1611,19 +1610,16 @@ int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
> data[2] = inode->i_generation;
> *lenp = 3;
> /* no room for directory info? return what we've stored so far */
> - if (maxlen < 5 || !need_parent)
> + if (maxlen < 5 || !parent)
> return 3;
>
> - spin_lock(&dentry->d_lock);
> - inode = dentry->d_parent->d_inode;
> - data[3] = inode->i_ino;
> - data[4] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);
> + data[3] = parent->i_ino;
> + data[4] = le32_to_cpu(INODE_PKEY(parent)->k_dir_id);
> *lenp = 5;
> if (maxlen >= 6) {
> - data[5] = inode->i_generation;
> + data[5] = parent->i_generation;
> *lenp = 6;
> }
> - spin_unlock(&dentry->d_lock);
> return *lenp;
> }
>
> diff --git a/fs/udf/namei.c b/fs/udf/namei.c
> index 08bf46e..6b9b526 100644
> --- a/fs/udf/namei.c
> +++ b/fs/udf/namei.c
> @@ -1273,16 +1273,15 @@ static struct dentry *udf_fh_to_parent(struct super_block *sb,
> fid->udf.parent_partref,
> fid->udf.parent_generation);
> }
> -static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp,
> - int connectable)
> +static int udf_encode_fh(struct inode *inode, __u32 *fh, int *lenp,
> + struct inode *parent)
> {
> int len = *lenp;
> - struct inode *inode = de->d_inode;
> struct kernel_lb_addr location = UDF_I(inode)->i_location;
> struct fid *fid = (struct fid *)fh;
> int type = FILEID_UDF_WITHOUT_PARENT;
>
> - if (connectable && (len < 5)) {
> + if (parent && (len < 5)) {
> *lenp = 5;
> return 255;
> } else if (len < 3) {
> @@ -1295,14 +1294,11 @@ static int udf_encode_fh(struct dentry *de, __u32 *fh, int *lenp,
> fid->udf.partref = location.partitionReferenceNum;
> fid->udf.generation = inode->i_generation;
>
> - if (connectable && !S_ISDIR(inode->i_mode)) {
> - spin_lock(&de->d_lock);
> - inode = de->d_parent->d_inode;
> - location = UDF_I(inode)->i_location;
> + if (parent) {
> + location = UDF_I(parent)->i_location;
> fid->udf.parent_block = location.logicalBlockNum;
> fid->udf.parent_partref = location.partitionReferenceNum;
> fid->udf.parent_generation = inode->i_generation;
> - spin_unlock(&de->d_lock);
> *lenp = 5;
> type = FILEID_UDF_WITH_PARENT;
> }
> diff --git a/fs/xfs/xfs_export.c b/fs/xfs/xfs_export.c
> index 558910f..1a2adfc 100644
> --- a/fs/xfs/xfs_export.c
> +++ b/fs/xfs/xfs_export.c
> @@ -53,19 +53,18 @@ static int xfs_fileid_length(int fileid_type)
>
> STATIC int
> xfs_fs_encode_fh(
> - struct dentry *dentry,
> - __u32 *fh,
> - int *max_len,
> - int connectable)
> + struct inode *inode,
> + __u32 *fh,
> + int *max_len,
> + struct inode *parent)
> {
> struct fid *fid = (struct fid *)fh;
> struct xfs_fid64 *fid64 = (struct xfs_fid64 *)fh;
> - struct inode *inode = dentry->d_inode;
> int fileid_type;
> int len;
>
> /* Directories don't need their parent encoded, they have ".." */
> - if (S_ISDIR(inode->i_mode) || !connectable)
> + if (!parent)
> fileid_type = FILEID_INO32_GEN;
> else
> fileid_type = FILEID_INO32_GEN_PARENT;
> @@ -97,20 +96,16 @@ xfs_fs_encode_fh(
>
> switch (fileid_type) {
> case FILEID_INO32_GEN_PARENT:
> - spin_lock(&dentry->d_lock);
> - fid->i32.parent_ino = XFS_I(dentry->d_parent->d_inode)->i_ino;
> - fid->i32.parent_gen = dentry->d_parent->d_inode->i_generation;
> - spin_unlock(&dentry->d_lock);
> + fid->i32.parent_ino = XFS_I(parent)->i_ino;
> + fid->i32.parent_gen = parent->i_generation;
> /*FALLTHRU*/
> case FILEID_INO32_GEN:
> fid->i32.ino = XFS_I(inode)->i_ino;
> fid->i32.gen = inode->i_generation;
> break;
> case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG:
> - spin_lock(&dentry->d_lock);
> - fid64->parent_ino = XFS_I(dentry->d_parent->d_inode)->i_ino;
> - fid64->parent_gen = dentry->d_parent->d_inode->i_generation;
> - spin_unlock(&dentry->d_lock);
> + fid64->parent_ino = XFS_I(parent)->i_ino;
> + fid64->parent_gen = parent->i_generation;
> /*FALLTHRU*/
> case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG:
> fid64->ino = XFS_I(inode)->i_ino;
> diff --git a/include/linux/exportfs.h b/include/linux/exportfs.h
> index 3a4cef5..12291a7 100644
> --- a/include/linux/exportfs.h
> +++ b/include/linux/exportfs.h
> @@ -165,8 +165,8 @@ struct fid {
> */
>
> struct export_operations {
> - int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
> - int connectable);
> + int (*encode_fh)(struct inode *inode, __u32 *fh, int *max_len,
> + struct inode *parent);
> struct dentry * (*fh_to_dentry)(struct super_block *sb, struct fid *fid,
> int fh_len, int fh_type);
> struct dentry * (*fh_to_parent)(struct super_block *sb, struct fid *fid,
> diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
> index 26be28f..5e31164 100644
> --- a/include/linux/reiserfs_fs.h
> +++ b/include/linux/reiserfs_fs.h
> @@ -2043,8 +2043,8 @@ struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
> int fh_len, int fh_type);
> struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid,
> int fh_len, int fh_type);
> -int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
> - int connectable);
> +int reiserfs_encode_fh(struct inode *inode, __u32 * data, int *lenp,
> + struct inode *parent);
>
> int reiserfs_truncate_file(struct inode *, int update_timestamps);
> void make_cpu_key(struct cpu_key *cpu_key, struct inode *inode, loff_t offset,
> diff --git a/mm/cleancache.c b/mm/cleancache.c
> index bcaae4c..668c74f 100644
> --- a/mm/cleancache.c
> +++ b/mm/cleancache.c
> @@ -75,7 +75,7 @@ EXPORT_SYMBOL(__cleancache_init_shared_fs);
> static int cleancache_get_key(struct inode *inode,
> struct cleancache_filekey *key)
> {
> - int (*fhfn)(struct dentry *, __u32 *fh, int *, int);
> + int (*fhfn)(struct inode *, __u32 *fh, int *, struct inode *);
> int len = 0, maxlen = CLEANCACHE_KEY_MAX;
> struct super_block *sb = inode->i_sb;
>
> @@ -83,9 +83,7 @@ static int cleancache_get_key(struct inode *inode,
> if (sb->s_export_op != NULL) {
> fhfn = sb->s_export_op->encode_fh;
> if (fhfn) {
> - struct dentry d;
> - d.d_inode = inode;
> - len = (*fhfn)(&d, &key->u.fh[0], &maxlen, 0);
> + len = (*fhfn)(inode, &key->u.fh[0], &maxlen, NULL);
> if (len <= 0 || len == 255)
> return -1;
> if (maxlen > CLEANCACHE_KEY_MAX)
> diff --git a/mm/shmem.c b/mm/shmem.c
> index 82d13f3..e438e24 100644
> --- a/mm/shmem.c
> +++ b/mm/shmem.c
> @@ -1952,11 +1952,9 @@ static struct dentry *shmem_fh_to_dentry(struct super_block *sb,
> return dentry;
> }
>
> -static int shmem_encode_fh(struct dentry *dentry, __u32 *fh, int *len,
> - int connectable)
> +static int shmem_encode_fh(struct inode *inode, __u32 *fh, int *len,
> + struct inode *parent)
> {
> - struct inode *inode = dentry->d_inode;
> -
> if (*len < 3) {
> *len = 3;
> return 255;
> --
> To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
