2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
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.
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/exportfs.h>
15 #include <linux/gfs2_ondisk.h>
16 #include <linux/crc32.h>
17 #include <linux/lm_interface.h>
25 #include "ops_dentry.h"
26 #include "ops_export.h"
30 static int gfs2_encode_fh(struct dentry
*dentry
, __u32
*p
, int *len
,
33 __be32
*fh
= (__force __be32
*)p
;
34 struct inode
*inode
= dentry
->d_inode
;
35 struct super_block
*sb
= inode
->i_sb
;
36 struct gfs2_inode
*ip
= GFS2_I(inode
);
38 if (*len
< GFS2_SMALL_FH_SIZE
||
39 (connectable
&& *len
< GFS2_LARGE_FH_SIZE
))
42 fh
[0] = cpu_to_be32(ip
->i_num
.no_formal_ino
>> 32);
43 fh
[1] = cpu_to_be32(ip
->i_num
.no_formal_ino
& 0xFFFFFFFF);
44 fh
[2] = cpu_to_be32(ip
->i_num
.no_addr
>> 32);
45 fh
[3] = cpu_to_be32(ip
->i_num
.no_addr
& 0xFFFFFFFF);
46 *len
= GFS2_SMALL_FH_SIZE
;
48 if (!connectable
|| inode
== sb
->s_root
->d_inode
)
51 spin_lock(&dentry
->d_lock
);
52 inode
= dentry
->d_parent
->d_inode
;
55 spin_unlock(&dentry
->d_lock
);
57 fh
[4] = cpu_to_be32(ip
->i_num
.no_formal_ino
>> 32);
58 fh
[5] = cpu_to_be32(ip
->i_num
.no_formal_ino
& 0xFFFFFFFF);
59 fh
[6] = cpu_to_be32(ip
->i_num
.no_addr
>> 32);
60 fh
[7] = cpu_to_be32(ip
->i_num
.no_addr
& 0xFFFFFFFF);
62 fh
[8] = cpu_to_be32(inode
->i_mode
);
63 fh
[9] = 0; /* pad to double word */
64 *len
= GFS2_LARGE_FH_SIZE
;
71 struct get_name_filldir
{
72 struct gfs2_inum_host inum
;
76 static int get_name_filldir(void *opaque
, const char *name
, int length
,
77 loff_t offset
, u64 inum
, unsigned int type
)
79 struct get_name_filldir
*gnfd
= opaque
;
81 if (inum
!= gnfd
->inum
.no_addr
)
84 memcpy(gnfd
->name
, name
, length
);
85 gnfd
->name
[length
] = 0;
90 static int gfs2_get_name(struct dentry
*parent
, char *name
,
93 struct inode
*dir
= parent
->d_inode
;
94 struct inode
*inode
= child
->d_inode
;
95 struct gfs2_inode
*dip
, *ip
;
96 struct get_name_filldir gnfd
;
97 struct gfs2_holder gh
;
104 if (!S_ISDIR(dir
->i_mode
) || !inode
)
111 gnfd
.inum
= ip
->i_num
;
114 error
= gfs2_glock_nq_init(dip
->i_gl
, LM_ST_SHARED
, 0, &gh
);
118 error
= gfs2_dir_read(dir
, &offset
, &gnfd
, get_name_filldir
);
120 gfs2_glock_dq_uninit(&gh
);
122 if (!error
&& !*name
)
128 static struct dentry
*gfs2_get_parent(struct dentry
*child
)
132 struct dentry
*dentry
;
134 gfs2_str2qstr(&dotdot
, "..");
135 inode
= gfs2_lookupi(child
->d_inode
, &dotdot
, 1, NULL
);
138 return ERR_PTR(-ENOENT
);
140 * In case of an error, @inode carries the error value, and we
141 * have to return that as a(n invalid) pointer to dentry.
144 return ERR_PTR(PTR_ERR(inode
));
146 dentry
= d_alloc_anon(inode
);
149 return ERR_PTR(-ENOMEM
);
152 dentry
->d_op
= &gfs2_dops
;
156 static struct dentry
*gfs2_get_dentry(struct super_block
*sb
,
157 struct gfs2_inum_host
*inum
)
159 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
160 struct gfs2_fh_obj
*fh_obj
= (struct gfs2_fh_obj
*)inum_obj
;
161 struct gfs2_holder i_gh
, ri_gh
, rgd_gh
;
162 struct gfs2_rgrpd
*rgd
;
164 struct dentry
*dentry
;
169 inode
= gfs2_ilookup(sb
, inum
);
171 if (GFS2_I(inode
)->i_num
.no_formal_ino
!= inum
->no_formal_ino
) {
173 return ERR_PTR(-ESTALE
);
178 error
= gfs2_glock_nq_num(sdp
, inum
->no_addr
, &gfs2_inode_glops
,
179 LM_ST_SHARED
, LM_FLAG_ANY
, &i_gh
);
181 return ERR_PTR(error
);
183 error
= gfs2_rindex_hold(sdp
, &ri_gh
);
188 rgd
= gfs2_blk2rgrpd(sdp
, inum
->no_addr
);
192 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_SHARED
, 0, &rgd_gh
);
197 if (gfs2_get_block_type(rgd
, inum
->no_addr
) != GFS2_BLKST_DINODE
)
200 gfs2_glock_dq_uninit(&rgd_gh
);
201 gfs2_glock_dq_uninit(&ri_gh
);
203 inode
= gfs2_inode_lookup(sb
, inum
, fh_obj
->imode
);
207 error
= PTR_ERR(inode
);
211 error
= gfs2_inode_refresh(GFS2_I(inode
));
218 if (GFS2_I(inode
)->i_di
.di_flags
& GFS2_DIF_SYSTEM
) {
223 gfs2_glock_dq_uninit(&i_gh
);
226 dentry
= d_alloc_anon(inode
);
229 return ERR_PTR(-ENOMEM
);
232 dentry
->d_op
= &gfs2_dops
;
236 gfs2_glock_dq_uninit(&rgd_gh
);
239 gfs2_glock_dq_uninit(&ri_gh
);
242 gfs2_glock_dq_uninit(&i_gh
);
243 return ERR_PTR(error
);
246 static struct dentry
*gfs2_fh_to_dentry(struct super_block
*sb
, struct fid
*fid
,
247 int fh_len
, int fh_type
)
249 struct gfs2_inum_host
this;
250 __be32
*fh
= (__force __be32
*)fid
->raw
;
253 case GFS2_SMALL_FH_SIZE
:
254 case GFS2_LARGE_FH_SIZE
:
255 case GFS2_OLD_FH_SIZE
:
256 this.no_formal_ino
= ((u64
)be32_to_cpu(fh
[0])) << 32;
257 this.no_formal_ino
|= be32_to_cpu(fh
[1]);
258 this.no_addr
= ((u64
)be32_to_cpu(fh
[2])) << 32;
259 this.no_addr
|= be32_to_cpu(fh
[3]);
260 return gfs2_get_dentry(sb
, &this);
266 static struct dentry
*gfs2_fh_to_parent(struct super_block
*sb
, struct fid
*fid
,
267 int fh_len
, int fh_type
)
269 struct gfs2_inum_host parent
;
270 __be32
*fh
= (__force __be32
*)fid
->raw
;
273 case GFS2_LARGE_FH_SIZE
:
274 case GFS2_OLD_FH_SIZE
:
275 parent
.no_formal_ino
= ((u64
)be32_to_cpu(fh
[4])) << 32;
276 parent
.no_formal_ino
|= be32_to_cpu(fh
[5]);
277 parent
.no_addr
= ((u64
)be32_to_cpu(fh
[6])) << 32;
278 parent
.no_addr
|= be32_to_cpu(fh
[7]);
279 return gfs2_get_dentry(sb
, &parent
);
285 const struct export_operations gfs2_export_ops
= {
286 .encode_fh
= gfs2_encode_fh
,
287 .fh_to_dentry
= gfs2_fh_to_dentry
,
288 .fh_to_parent
= gfs2_fh_to_parent
,
289 .get_name
= gfs2_get_name
,
290 .get_parent
= gfs2_get_parent
,