2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2005 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 v.2.
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <asm/semaphore.h>
22 #include "ops_export.h"
25 static struct dentry
*gfs2_decode_fh(struct super_block
*sb
,
29 int (*acceptable
)(void *context
,
30 struct dentry
*dentry
),
33 struct gfs2_inum
this, parent
;
35 atomic_inc(&get_v2sdp(sb
)->sd_ops_export
);
37 if (fh_type
!= fh_len
)
40 memset(&parent
, 0, sizeof(struct gfs2_inum
));
44 parent
.no_formal_ino
= ((uint64_t)be32_to_cpu(fh
[4])) << 32;
45 parent
.no_formal_ino
|= be32_to_cpu(fh
[5]);
46 parent
.no_addr
= ((uint64_t)be32_to_cpu(fh
[6])) << 32;
47 parent
.no_addr
|= be32_to_cpu(fh
[7]);
49 this.no_formal_ino
= ((uint64_t)be32_to_cpu(fh
[0])) << 32;
50 this.no_formal_ino
|= be32_to_cpu(fh
[1]);
51 this.no_addr
= ((uint64_t)be32_to_cpu(fh
[2])) << 32;
52 this.no_addr
|= be32_to_cpu(fh
[3]);
58 return gfs2_export_ops
.find_exported_dentry(sb
, &this, &parent
,
62 static int gfs2_encode_fh(struct dentry
*dentry
, __u32
*fh
, int *len
,
65 struct inode
*inode
= dentry
->d_inode
;
66 struct gfs2_inode
*ip
= get_v2ip(inode
);
67 struct gfs2_sbd
*sdp
= ip
->i_sbd
;
69 atomic_inc(&sdp
->sd_ops_export
);
71 if (*len
< 4 || (connectable
&& *len
< 8))
74 fh
[0] = ip
->i_num
.no_formal_ino
>> 32;
75 fh
[0] = cpu_to_be32(fh
[0]);
76 fh
[1] = ip
->i_num
.no_formal_ino
& 0xFFFFFFFF;
77 fh
[1] = cpu_to_be32(fh
[1]);
78 fh
[2] = ip
->i_num
.no_addr
>> 32;
79 fh
[2] = cpu_to_be32(fh
[2]);
80 fh
[3] = ip
->i_num
.no_addr
& 0xFFFFFFFF;
81 fh
[3] = cpu_to_be32(fh
[3]);
84 if (!connectable
|| ip
== sdp
->sd_root_dir
)
87 spin_lock(&dentry
->d_lock
);
88 inode
= dentry
->d_parent
->d_inode
;
91 spin_unlock(&dentry
->d_lock
);
93 fh
[4] = ip
->i_num
.no_formal_ino
>> 32;
94 fh
[4] = cpu_to_be32(fh
[4]);
95 fh
[5] = ip
->i_num
.no_formal_ino
& 0xFFFFFFFF;
96 fh
[5] = cpu_to_be32(fh
[5]);
97 fh
[6] = ip
->i_num
.no_addr
>> 32;
98 fh
[6] = cpu_to_be32(fh
[6]);
99 fh
[7] = ip
->i_num
.no_addr
& 0xFFFFFFFF;
100 fh
[7] = cpu_to_be32(fh
[7]);
108 struct get_name_filldir
{
109 struct gfs2_inum inum
;
113 static int get_name_filldir(void *opaque
, const char *name
, unsigned int length
,
114 uint64_t offset
, struct gfs2_inum
*inum
,
117 struct get_name_filldir
*gnfd
= (struct get_name_filldir
*)opaque
;
119 if (!gfs2_inum_equal(inum
, &gnfd
->inum
))
122 memcpy(gnfd
->name
, name
, length
);
123 gnfd
->name
[length
] = 0;
128 static int gfs2_get_name(struct dentry
*parent
, char *name
,
129 struct dentry
*child
)
131 struct inode
*dir
= parent
->d_inode
;
132 struct inode
*inode
= child
->d_inode
;
133 struct gfs2_inode
*dip
, *ip
;
134 struct get_name_filldir gnfd
;
135 struct gfs2_holder gh
;
142 atomic_inc(&get_v2sdp(dir
->i_sb
)->sd_ops_export
);
144 if (!S_ISDIR(dir
->i_mode
) || !inode
)
148 ip
= get_v2ip(inode
);
151 gnfd
.inum
= ip
->i_num
;
154 error
= gfs2_glock_nq_init(dip
->i_gl
, LM_ST_SHARED
, 0, &gh
);
158 error
= gfs2_dir_read(dip
, &offset
, &gnfd
, get_name_filldir
);
160 gfs2_glock_dq_uninit(&gh
);
162 if (!error
&& !*name
)
168 static struct dentry
*gfs2_get_parent(struct dentry
*child
)
170 struct gfs2_inode
*dip
= get_v2ip(child
->d_inode
);
171 struct qstr dotdot
= { .name
= "..", .len
= 2 };
172 struct gfs2_inode
*ip
;
174 struct dentry
*dentry
;
177 atomic_inc(&dip
->i_sbd
->sd_ops_export
);
179 error
= gfs2_lookupi(dip
, &dotdot
, 1, &ip
);
181 return ERR_PTR(error
);
183 inode
= gfs2_ip2v(ip
);
187 return ERR_PTR(-ENOMEM
);
189 dentry
= d_alloc_anon(inode
);
192 return ERR_PTR(-ENOMEM
);
198 static struct dentry
*gfs2_get_dentry(struct super_block
*sb
, void *inum_p
)
200 struct gfs2_sbd
*sdp
= get_v2sdp(sb
);
201 struct gfs2_inum
*inum
= (struct gfs2_inum
*)inum_p
;
202 struct gfs2_holder i_gh
, ri_gh
, rgd_gh
;
203 struct gfs2_rgrpd
*rgd
;
204 struct gfs2_inode
*ip
;
206 struct dentry
*dentry
;
209 atomic_inc(&sdp
->sd_ops_export
);
213 inode
= gfs2_iget(sb
, inum
);
215 ip
= get_v2ip(inode
);
216 if (ip
->i_num
.no_formal_ino
!= inum
->no_formal_ino
) {
218 return ERR_PTR(-ESTALE
);
223 error
= gfs2_glock_nq_num(sdp
,
224 inum
->no_addr
, &gfs2_inode_glops
,
225 LM_ST_SHARED
, LM_FLAG_ANY
| GL_LOCAL_EXCL
,
228 return ERR_PTR(error
);
230 error
= gfs2_inode_get(i_gh
.gh_gl
, inum
, NO_CREATE
, &ip
);
236 error
= gfs2_rindex_hold(sdp
, &ri_gh
);
241 rgd
= gfs2_blk2rgrpd(sdp
, inum
->no_addr
);
245 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_SHARED
, 0, &rgd_gh
);
250 if (gfs2_get_block_type(rgd
, inum
->no_addr
) != GFS2_BLKST_DINODE
)
253 gfs2_glock_dq_uninit(&rgd_gh
);
254 gfs2_glock_dq_uninit(&ri_gh
);
256 error
= gfs2_inode_get(i_gh
.gh_gl
, inum
, CREATE
, &ip
);
260 error
= gfs2_inode_refresh(ip
);
266 atomic_inc(&sdp
->sd_fh2dentry_misses
);
270 if (ip
->i_di
.di_flags
& GFS2_DIF_SYSTEM
) {
275 gfs2_glock_dq_uninit(&i_gh
);
277 inode
= gfs2_ip2v(ip
);
281 return ERR_PTR(-ENOMEM
);
284 dentry
= d_alloc_anon(inode
);
287 return ERR_PTR(-ENOMEM
);
293 gfs2_glock_dq_uninit(&rgd_gh
);
296 gfs2_glock_dq_uninit(&ri_gh
);
299 gfs2_glock_dq_uninit(&i_gh
);
300 return ERR_PTR(error
);
303 struct export_operations gfs2_export_ops
= {
304 .decode_fh
= gfs2_decode_fh
,
305 .encode_fh
= gfs2_encode_fh
,
306 .get_name
= gfs2_get_name
,
307 .get_parent
= gfs2_get_parent
,
308 .get_dentry
= gfs2_get_dentry
,