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/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 <linux/gfs2_ondisk.h>
16 #include <linux/crc32.h>
19 #include "lm_interface.h"
25 #include "ops_export.h"
29 static struct dentry
*gfs2_decode_fh(struct super_block
*sb
,
33 int (*acceptable
)(void *context
,
34 struct dentry
*dentry
),
37 struct gfs2_fh_obj fh_obj
;
38 struct gfs2_inum
*this, parent
;
40 if (fh_type
!= fh_len
)
44 fh_obj
.imode
= DT_UNKNOWN
;
45 memset(&parent
, 0, sizeof(struct gfs2_inum
));
49 parent
.no_formal_ino
= ((u64
)be32_to_cpu(fh
[4])) << 32;
50 parent
.no_formal_ino
|= be32_to_cpu(fh
[5]);
51 parent
.no_addr
= ((u64
)be32_to_cpu(fh
[6])) << 32;
52 parent
.no_addr
|= be32_to_cpu(fh
[7]);
53 fh_obj
.imode
= be32_to_cpu(fh
[8]);
55 this->no_formal_ino
= ((u64
)be32_to_cpu(fh
[0])) << 32;
56 this->no_formal_ino
|= be32_to_cpu(fh
[1]);
57 this->no_addr
= ((u64
)be32_to_cpu(fh
[2])) << 32;
58 this->no_addr
|= be32_to_cpu(fh
[3]);
64 return gfs2_export_ops
.find_exported_dentry(sb
, &fh_obj
, &parent
,
68 static int gfs2_encode_fh(struct dentry
*dentry
, __u32
*fh
, int *len
,
71 struct inode
*inode
= dentry
->d_inode
;
72 struct super_block
*sb
= inode
->i_sb
;
73 struct gfs2_inode
*ip
= GFS2_I(inode
);
75 if (*len
< 4 || (connectable
&& *len
< 10))
78 fh
[0] = ip
->i_num
.no_formal_ino
>> 32;
79 fh
[0] = cpu_to_be32(fh
[0]);
80 fh
[1] = ip
->i_num
.no_formal_ino
& 0xFFFFFFFF;
81 fh
[1] = cpu_to_be32(fh
[1]);
82 fh
[2] = ip
->i_num
.no_addr
>> 32;
83 fh
[2] = cpu_to_be32(fh
[2]);
84 fh
[3] = ip
->i_num
.no_addr
& 0xFFFFFFFF;
85 fh
[3] = cpu_to_be32(fh
[3]);
88 if (!connectable
|| inode
== sb
->s_root
->d_inode
)
91 spin_lock(&dentry
->d_lock
);
92 inode
= dentry
->d_parent
->d_inode
;
95 spin_unlock(&dentry
->d_lock
);
97 fh
[4] = ip
->i_num
.no_formal_ino
>> 32;
98 fh
[4] = cpu_to_be32(fh
[4]);
99 fh
[5] = ip
->i_num
.no_formal_ino
& 0xFFFFFFFF;
100 fh
[5] = cpu_to_be32(fh
[5]);
101 fh
[6] = ip
->i_num
.no_addr
>> 32;
102 fh
[6] = cpu_to_be32(fh
[6]);
103 fh
[7] = ip
->i_num
.no_addr
& 0xFFFFFFFF;
104 fh
[7] = cpu_to_be32(fh
[7]);
106 fh
[8] = cpu_to_be32(inode
->i_mode
);
107 fh
[9] = 0; /* pad to double word */
115 struct get_name_filldir
{
116 struct gfs2_inum inum
;
120 static int get_name_filldir(void *opaque
, const char *name
, unsigned int length
,
121 u64 offset
, struct gfs2_inum
*inum
,
124 struct get_name_filldir
*gnfd
= (struct get_name_filldir
*)opaque
;
126 if (!gfs2_inum_equal(inum
, &gnfd
->inum
))
129 memcpy(gnfd
->name
, name
, length
);
130 gnfd
->name
[length
] = 0;
135 static int gfs2_get_name(struct dentry
*parent
, char *name
,
136 struct dentry
*child
)
138 struct inode
*dir
= parent
->d_inode
;
139 struct inode
*inode
= child
->d_inode
;
140 struct gfs2_inode
*dip
, *ip
;
141 struct get_name_filldir gnfd
;
142 struct gfs2_holder gh
;
149 if (!S_ISDIR(dir
->i_mode
) || !inode
)
156 gnfd
.inum
= ip
->i_num
;
159 error
= gfs2_glock_nq_init(dip
->i_gl
, LM_ST_SHARED
, 0, &gh
);
163 error
= gfs2_dir_read(dir
, &offset
, &gnfd
, get_name_filldir
);
165 gfs2_glock_dq_uninit(&gh
);
167 if (!error
&& !*name
)
173 static struct dentry
*gfs2_get_parent(struct dentry
*child
)
177 struct dentry
*dentry
;
179 gfs2_str2qstr(&dotdot
, "..");
180 inode
= gfs2_lookupi(child
->d_inode
, &dotdot
, 1, NULL
);
183 return ERR_PTR(-ENOENT
);
185 return ERR_PTR(PTR_ERR(inode
));
187 dentry
= d_alloc_anon(inode
);
190 return ERR_PTR(-ENOMEM
);
196 static struct dentry
*gfs2_get_dentry(struct super_block
*sb
, void *inum_obj
)
198 struct gfs2_sbd
*sdp
= sb
->s_fs_info
;
199 struct gfs2_fh_obj
*fh_obj
= (struct gfs2_fh_obj
*)inum_obj
;
200 struct gfs2_inum
*inum
= &fh_obj
->this;
201 struct gfs2_holder i_gh
, ri_gh
, rgd_gh
;
202 struct gfs2_rgrpd
*rgd
;
204 struct dentry
*dentry
;
209 inode
= gfs2_ilookup(sb
, inum
);
211 if (GFS2_I(inode
)->i_num
.no_formal_ino
!= inum
->no_formal_ino
) {
213 return ERR_PTR(-ESTALE
);
218 error
= gfs2_glock_nq_num(sdp
, inum
->no_addr
, &gfs2_inode_glops
,
219 LM_ST_SHARED
, LM_FLAG_ANY
| GL_LOCAL_EXCL
,
222 return ERR_PTR(error
);
224 error
= gfs2_rindex_hold(sdp
, &ri_gh
);
229 rgd
= gfs2_blk2rgrpd(sdp
, inum
->no_addr
);
233 error
= gfs2_glock_nq_init(rgd
->rd_gl
, LM_ST_SHARED
, 0, &rgd_gh
);
238 if (gfs2_get_block_type(rgd
, inum
->no_addr
) != GFS2_BLKST_DINODE
)
241 gfs2_glock_dq_uninit(&rgd_gh
);
242 gfs2_glock_dq_uninit(&ri_gh
);
244 inode
= gfs2_inode_lookup(sb
, inum
, fh_obj
->imode
);
248 error
= PTR_ERR(inode
);
252 error
= gfs2_inode_refresh(GFS2_I(inode
));
259 if (GFS2_I(inode
)->i_di
.di_flags
& GFS2_DIF_SYSTEM
) {
264 gfs2_glock_dq_uninit(&i_gh
);
267 dentry
= d_alloc_anon(inode
);
270 return ERR_PTR(-ENOMEM
);
276 gfs2_glock_dq_uninit(&rgd_gh
);
279 gfs2_glock_dq_uninit(&ri_gh
);
282 gfs2_glock_dq_uninit(&i_gh
);
283 return ERR_PTR(error
);
286 struct export_operations gfs2_export_ops
= {
287 .decode_fh
= gfs2_decode_fh
,
288 .encode_fh
= gfs2_encode_fh
,
289 .get_name
= gfs2_get_name
,
290 .get_parent
= gfs2_get_parent
,
291 .get_dentry
= gfs2_get_dentry
,