diff options
Diffstat (limited to 'fs/gfs2/ops_export.c')
-rw-r--r-- | fs/gfs2/ops_export.c | 298 |
1 files changed, 298 insertions, 0 deletions
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c new file mode 100644 index 000000000000..86127d93bd35 --- /dev/null +++ b/fs/gfs2/ops_export.c | |||
@@ -0,0 +1,298 @@ | |||
1 | /* | ||
2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | ||
3 | * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. | ||
4 | * | ||
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. | ||
8 | */ | ||
9 | |||
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> | ||
17 | #include <linux/lm_interface.h> | ||
18 | |||
19 | #include "gfs2.h" | ||
20 | #include "incore.h" | ||
21 | #include "dir.h" | ||
22 | #include "glock.h" | ||
23 | #include "glops.h" | ||
24 | #include "inode.h" | ||
25 | #include "ops_export.h" | ||
26 | #include "rgrp.h" | ||
27 | #include "util.h" | ||
28 | |||
29 | static struct dentry *gfs2_decode_fh(struct super_block *sb, | ||
30 | __u32 *fh, | ||
31 | int fh_len, | ||
32 | int fh_type, | ||
33 | int (*acceptable)(void *context, | ||
34 | struct dentry *dentry), | ||
35 | void *context) | ||
36 | { | ||
37 | struct gfs2_fh_obj fh_obj; | ||
38 | struct gfs2_inum *this, parent; | ||
39 | |||
40 | if (fh_type != fh_len) | ||
41 | return NULL; | ||
42 | |||
43 | this = &fh_obj.this; | ||
44 | fh_obj.imode = DT_UNKNOWN; | ||
45 | memset(&parent, 0, sizeof(struct gfs2_inum)); | ||
46 | |||
47 | switch (fh_type) { | ||
48 | case GFS2_LARGE_FH_SIZE: | ||
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]); | ||
54 | case GFS2_SMALL_FH_SIZE: | ||
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]); | ||
59 | break; | ||
60 | default: | ||
61 | return NULL; | ||
62 | } | ||
63 | |||
64 | return gfs2_export_ops.find_exported_dentry(sb, &fh_obj, &parent, | ||
65 | acceptable, context); | ||
66 | } | ||
67 | |||
68 | static int gfs2_encode_fh(struct dentry *dentry, __u32 *fh, int *len, | ||
69 | int connectable) | ||
70 | { | ||
71 | struct inode *inode = dentry->d_inode; | ||
72 | struct super_block *sb = inode->i_sb; | ||
73 | struct gfs2_inode *ip = GFS2_I(inode); | ||
74 | |||
75 | if (*len < GFS2_SMALL_FH_SIZE || | ||
76 | (connectable && *len < GFS2_LARGE_FH_SIZE)) | ||
77 | return 255; | ||
78 | |||
79 | fh[0] = ip->i_num.no_formal_ino >> 32; | ||
80 | fh[0] = cpu_to_be32(fh[0]); | ||
81 | fh[1] = ip->i_num.no_formal_ino & 0xFFFFFFFF; | ||
82 | fh[1] = cpu_to_be32(fh[1]); | ||
83 | fh[2] = ip->i_num.no_addr >> 32; | ||
84 | fh[2] = cpu_to_be32(fh[2]); | ||
85 | fh[3] = ip->i_num.no_addr & 0xFFFFFFFF; | ||
86 | fh[3] = cpu_to_be32(fh[3]); | ||
87 | *len = GFS2_SMALL_FH_SIZE; | ||
88 | |||
89 | if (!connectable || inode == sb->s_root->d_inode) | ||
90 | return *len; | ||
91 | |||
92 | spin_lock(&dentry->d_lock); | ||
93 | inode = dentry->d_parent->d_inode; | ||
94 | ip = GFS2_I(inode); | ||
95 | igrab(inode); | ||
96 | spin_unlock(&dentry->d_lock); | ||
97 | |||
98 | fh[4] = ip->i_num.no_formal_ino >> 32; | ||
99 | fh[4] = cpu_to_be32(fh[4]); | ||
100 | fh[5] = ip->i_num.no_formal_ino & 0xFFFFFFFF; | ||
101 | fh[5] = cpu_to_be32(fh[5]); | ||
102 | fh[6] = ip->i_num.no_addr >> 32; | ||
103 | fh[6] = cpu_to_be32(fh[6]); | ||
104 | fh[7] = ip->i_num.no_addr & 0xFFFFFFFF; | ||
105 | fh[7] = cpu_to_be32(fh[7]); | ||
106 | |||
107 | fh[8] = cpu_to_be32(inode->i_mode); | ||
108 | fh[9] = 0; /* pad to double word */ | ||
109 | *len = GFS2_LARGE_FH_SIZE; | ||
110 | |||
111 | iput(inode); | ||
112 | |||
113 | return *len; | ||
114 | } | ||
115 | |||
116 | struct get_name_filldir { | ||
117 | struct gfs2_inum inum; | ||
118 | char *name; | ||
119 | }; | ||
120 | |||
121 | static int get_name_filldir(void *opaque, const char *name, unsigned int length, | ||
122 | u64 offset, struct gfs2_inum *inum, | ||
123 | unsigned int type) | ||
124 | { | ||
125 | struct get_name_filldir *gnfd = (struct get_name_filldir *)opaque; | ||
126 | |||
127 | if (!gfs2_inum_equal(inum, &gnfd->inum)) | ||
128 | return 0; | ||
129 | |||
130 | memcpy(gnfd->name, name, length); | ||
131 | gnfd->name[length] = 0; | ||
132 | |||
133 | return 1; | ||
134 | } | ||
135 | |||
136 | static int gfs2_get_name(struct dentry *parent, char *name, | ||
137 | struct dentry *child) | ||
138 | { | ||
139 | struct inode *dir = parent->d_inode; | ||
140 | struct inode *inode = child->d_inode; | ||
141 | struct gfs2_inode *dip, *ip; | ||
142 | struct get_name_filldir gnfd; | ||
143 | struct gfs2_holder gh; | ||
144 | u64 offset = 0; | ||
145 | int error; | ||
146 | |||
147 | if (!dir) | ||
148 | return -EINVAL; | ||
149 | |||
150 | if (!S_ISDIR(dir->i_mode) || !inode) | ||
151 | return -EINVAL; | ||
152 | |||
153 | dip = GFS2_I(dir); | ||
154 | ip = GFS2_I(inode); | ||
155 | |||
156 | *name = 0; | ||
157 | gnfd.inum = ip->i_num; | ||
158 | gnfd.name = name; | ||
159 | |||
160 | error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh); | ||
161 | if (error) | ||
162 | return error; | ||
163 | |||
164 | error = gfs2_dir_read(dir, &offset, &gnfd, get_name_filldir); | ||
165 | |||
166 | gfs2_glock_dq_uninit(&gh); | ||
167 | |||
168 | if (!error && !*name) | ||
169 | error = -ENOENT; | ||
170 | |||
171 | return error; | ||
172 | } | ||
173 | |||
174 | static struct dentry *gfs2_get_parent(struct dentry *child) | ||
175 | { | ||
176 | struct qstr dotdot; | ||
177 | struct inode *inode; | ||
178 | struct dentry *dentry; | ||
179 | |||
180 | gfs2_str2qstr(&dotdot, ".."); | ||
181 | inode = gfs2_lookupi(child->d_inode, &dotdot, 1, NULL); | ||
182 | |||
183 | if (!inode) | ||
184 | return ERR_PTR(-ENOENT); | ||
185 | /* | ||
186 | * In case of an error, @inode carries the error value, and we | ||
187 | * have to return that as a(n invalid) pointer to dentry. | ||
188 | */ | ||
189 | if (IS_ERR(inode)) | ||
190 | return ERR_PTR(PTR_ERR(inode)); | ||
191 | |||
192 | dentry = d_alloc_anon(inode); | ||
193 | if (!dentry) { | ||
194 | iput(inode); | ||
195 | return ERR_PTR(-ENOMEM); | ||
196 | } | ||
197 | |||
198 | return dentry; | ||
199 | } | ||
200 | |||
201 | static struct dentry *gfs2_get_dentry(struct super_block *sb, void *inum_obj) | ||
202 | { | ||
203 | struct gfs2_sbd *sdp = sb->s_fs_info; | ||
204 | struct gfs2_fh_obj *fh_obj = (struct gfs2_fh_obj *)inum_obj; | ||
205 | struct gfs2_inum *inum = &fh_obj->this; | ||
206 | struct gfs2_holder i_gh, ri_gh, rgd_gh; | ||
207 | struct gfs2_rgrpd *rgd; | ||
208 | struct inode *inode; | ||
209 | struct dentry *dentry; | ||
210 | int error; | ||
211 | |||
212 | /* System files? */ | ||
213 | |||
214 | inode = gfs2_ilookup(sb, inum); | ||
215 | if (inode) { | ||
216 | if (GFS2_I(inode)->i_num.no_formal_ino != inum->no_formal_ino) { | ||
217 | iput(inode); | ||
218 | return ERR_PTR(-ESTALE); | ||
219 | } | ||
220 | goto out_inode; | ||
221 | } | ||
222 | |||
223 | error = gfs2_glock_nq_num(sdp, inum->no_addr, &gfs2_inode_glops, | ||
224 | LM_ST_SHARED, LM_FLAG_ANY | GL_LOCAL_EXCL, | ||
225 | &i_gh); | ||
226 | if (error) | ||
227 | return ERR_PTR(error); | ||
228 | |||
229 | error = gfs2_rindex_hold(sdp, &ri_gh); | ||
230 | if (error) | ||
231 | goto fail; | ||
232 | |||
233 | error = -EINVAL; | ||
234 | rgd = gfs2_blk2rgrpd(sdp, inum->no_addr); | ||
235 | if (!rgd) | ||
236 | goto fail_rindex; | ||
237 | |||
238 | error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh); | ||
239 | if (error) | ||
240 | goto fail_rindex; | ||
241 | |||
242 | error = -ESTALE; | ||
243 | if (gfs2_get_block_type(rgd, inum->no_addr) != GFS2_BLKST_DINODE) | ||
244 | goto fail_rgd; | ||
245 | |||
246 | gfs2_glock_dq_uninit(&rgd_gh); | ||
247 | gfs2_glock_dq_uninit(&ri_gh); | ||
248 | |||
249 | inode = gfs2_inode_lookup(sb, inum, fh_obj->imode); | ||
250 | if (!inode) | ||
251 | goto fail; | ||
252 | if (IS_ERR(inode)) { | ||
253 | error = PTR_ERR(inode); | ||
254 | goto fail; | ||
255 | } | ||
256 | |||
257 | error = gfs2_inode_refresh(GFS2_I(inode)); | ||
258 | if (error) { | ||
259 | iput(inode); | ||
260 | goto fail; | ||
261 | } | ||
262 | |||
263 | error = -EIO; | ||
264 | if (GFS2_I(inode)->i_di.di_flags & GFS2_DIF_SYSTEM) { | ||
265 | iput(inode); | ||
266 | goto fail; | ||
267 | } | ||
268 | |||
269 | gfs2_glock_dq_uninit(&i_gh); | ||
270 | |||
271 | out_inode: | ||
272 | dentry = d_alloc_anon(inode); | ||
273 | if (!dentry) { | ||
274 | iput(inode); | ||
275 | return ERR_PTR(-ENOMEM); | ||
276 | } | ||
277 | |||
278 | return dentry; | ||
279 | |||
280 | fail_rgd: | ||
281 | gfs2_glock_dq_uninit(&rgd_gh); | ||
282 | |||
283 | fail_rindex: | ||
284 | gfs2_glock_dq_uninit(&ri_gh); | ||
285 | |||
286 | fail: | ||
287 | gfs2_glock_dq_uninit(&i_gh); | ||
288 | return ERR_PTR(error); | ||
289 | } | ||
290 | |||
291 | struct export_operations gfs2_export_ops = { | ||
292 | .decode_fh = gfs2_decode_fh, | ||
293 | .encode_fh = gfs2_encode_fh, | ||
294 | .get_name = gfs2_get_name, | ||
295 | .get_parent = gfs2_get_parent, | ||
296 | .get_dentry = gfs2_get_dentry, | ||
297 | }; | ||
298 | |||