diff options
author | David Teigland <teigland@redhat.com> | 2006-01-16 11:50:04 -0500 |
---|---|---|
committer | Steven Whitehouse <swhiteho@redhat.com> | 2006-01-16 11:50:04 -0500 |
commit | b3b94faa5fe5968827ba0640ee9fba4b3e7f736e (patch) | |
tree | 70bd6068b050d2c46e338484f8b03fae4365c6c3 /fs/gfs2/ops_export.c | |
parent | f7825dcf8c7301cfd3724eb40c5b443cc85ab7b8 (diff) |
[GFS2] The core of GFS2
This patch contains all the core files for GFS2.
Signed-off-by: David Teigland <teigland@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
Diffstat (limited to 'fs/gfs2/ops_export.c')
-rw-r--r-- | fs/gfs2/ops_export.c | 310 |
1 files changed, 310 insertions, 0 deletions
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c new file mode 100644 index 000000000000..0ae3a0af192d --- /dev/null +++ b/fs/gfs2/ops_export.c | |||
@@ -0,0 +1,310 @@ | |||
1 | /* | ||
2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | ||
3 | * Copyright (C) 2004-2005 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 v.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 <asm/semaphore.h> | ||
16 | |||
17 | #include "gfs2.h" | ||
18 | #include "dir.h" | ||
19 | #include "glock.h" | ||
20 | #include "glops.h" | ||
21 | #include "inode.h" | ||
22 | #include "ops_export.h" | ||
23 | #include "rgrp.h" | ||
24 | |||
25 | static struct dentry *gfs2_decode_fh(struct super_block *sb, | ||
26 | __u32 *fh, | ||
27 | int fh_len, | ||
28 | int fh_type, | ||
29 | int (*acceptable)(void *context, | ||
30 | struct dentry *dentry), | ||
31 | void *context) | ||
32 | { | ||
33 | struct gfs2_inum this, parent; | ||
34 | |||
35 | atomic_inc(&get_v2sdp(sb)->sd_ops_export); | ||
36 | |||
37 | if (fh_type != fh_len) | ||
38 | return NULL; | ||
39 | |||
40 | memset(&parent, 0, sizeof(struct gfs2_inum)); | ||
41 | |||
42 | switch (fh_type) { | ||
43 | case 8: | ||
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]); | ||
48 | case 4: | ||
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]); | ||
53 | break; | ||
54 | default: | ||
55 | return NULL; | ||
56 | } | ||
57 | |||
58 | return gfs2_export_ops.find_exported_dentry(sb, &this, &parent, | ||
59 | acceptable, context); | ||
60 | } | ||
61 | |||
62 | static int gfs2_encode_fh(struct dentry *dentry, __u32 *fh, int *len, | ||
63 | int connectable) | ||
64 | { | ||
65 | struct inode *inode = dentry->d_inode; | ||
66 | struct gfs2_inode *ip = get_v2ip(inode); | ||
67 | struct gfs2_sbd *sdp = ip->i_sbd; | ||
68 | |||
69 | atomic_inc(&sdp->sd_ops_export); | ||
70 | |||
71 | if (*len < 4 || (connectable && *len < 8)) | ||
72 | return 255; | ||
73 | |||
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]); | ||
82 | *len = 4; | ||
83 | |||
84 | if (!connectable || ip == sdp->sd_root_dir) | ||
85 | return *len; | ||
86 | |||
87 | spin_lock(&dentry->d_lock); | ||
88 | inode = dentry->d_parent->d_inode; | ||
89 | ip = get_v2ip(inode); | ||
90 | gfs2_inode_hold(ip); | ||
91 | spin_unlock(&dentry->d_lock); | ||
92 | |||
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]); | ||
101 | *len = 8; | ||
102 | |||
103 | gfs2_inode_put(ip); | ||
104 | |||
105 | return *len; | ||
106 | } | ||
107 | |||
108 | struct get_name_filldir { | ||
109 | struct gfs2_inum inum; | ||
110 | char *name; | ||
111 | }; | ||
112 | |||
113 | static int get_name_filldir(void *opaque, const char *name, unsigned int length, | ||
114 | uint64_t offset, struct gfs2_inum *inum, | ||
115 | unsigned int type) | ||
116 | { | ||
117 | struct get_name_filldir *gnfd = (struct get_name_filldir *)opaque; | ||
118 | |||
119 | if (!gfs2_inum_equal(inum, &gnfd->inum)) | ||
120 | return 0; | ||
121 | |||
122 | memcpy(gnfd->name, name, length); | ||
123 | gnfd->name[length] = 0; | ||
124 | |||
125 | return 1; | ||
126 | } | ||
127 | |||
128 | static int gfs2_get_name(struct dentry *parent, char *name, | ||
129 | struct dentry *child) | ||
130 | { | ||
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; | ||
136 | uint64_t offset = 0; | ||
137 | int error; | ||
138 | |||
139 | if (!dir) | ||
140 | return -EINVAL; | ||
141 | |||
142 | atomic_inc(&get_v2sdp(dir->i_sb)->sd_ops_export); | ||
143 | |||
144 | if (!S_ISDIR(dir->i_mode) || !inode) | ||
145 | return -EINVAL; | ||
146 | |||
147 | dip = get_v2ip(dir); | ||
148 | ip = get_v2ip(inode); | ||
149 | |||
150 | *name = 0; | ||
151 | gnfd.inum = ip->i_num; | ||
152 | gnfd.name = name; | ||
153 | |||
154 | error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh); | ||
155 | if (error) | ||
156 | return error; | ||
157 | |||
158 | error = gfs2_dir_read(dip, &offset, &gnfd, get_name_filldir); | ||
159 | |||
160 | gfs2_glock_dq_uninit(&gh); | ||
161 | |||
162 | if (!error && !*name) | ||
163 | error = -ENOENT; | ||
164 | |||
165 | return error; | ||
166 | } | ||
167 | |||
168 | static struct dentry *gfs2_get_parent(struct dentry *child) | ||
169 | { | ||
170 | struct gfs2_inode *dip = get_v2ip(child->d_inode); | ||
171 | struct qstr dotdot = { .name = "..", .len = 2 }; | ||
172 | struct gfs2_inode *ip; | ||
173 | struct inode *inode; | ||
174 | struct dentry *dentry; | ||
175 | int error; | ||
176 | |||
177 | atomic_inc(&dip->i_sbd->sd_ops_export); | ||
178 | |||
179 | error = gfs2_lookupi(dip, &dotdot, 1, &ip); | ||
180 | if (error) | ||
181 | return ERR_PTR(error); | ||
182 | |||
183 | inode = gfs2_ip2v(ip); | ||
184 | gfs2_inode_put(ip); | ||
185 | |||
186 | if (!inode) | ||
187 | return ERR_PTR(-ENOMEM); | ||
188 | |||
189 | dentry = d_alloc_anon(inode); | ||
190 | if (!dentry) { | ||
191 | iput(inode); | ||
192 | return ERR_PTR(-ENOMEM); | ||
193 | } | ||
194 | |||
195 | return dentry; | ||
196 | } | ||
197 | |||
198 | static struct dentry *gfs2_get_dentry(struct super_block *sb, void *inum_p) | ||
199 | { | ||
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; | ||
205 | struct inode *inode; | ||
206 | struct dentry *dentry; | ||
207 | int error; | ||
208 | |||
209 | atomic_inc(&sdp->sd_ops_export); | ||
210 | |||
211 | /* System files? */ | ||
212 | |||
213 | inode = gfs2_iget(sb, inum); | ||
214 | if (inode) { | ||
215 | ip = get_v2ip(inode); | ||
216 | if (ip->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, | ||
224 | inum->no_addr, &gfs2_inode_glops, | ||
225 | LM_ST_SHARED, LM_FLAG_ANY | GL_LOCAL_EXCL, | ||
226 | &i_gh); | ||
227 | if (error) | ||
228 | return ERR_PTR(error); | ||
229 | |||
230 | error = gfs2_inode_get(i_gh.gh_gl, inum, NO_CREATE, &ip); | ||
231 | if (error) | ||
232 | goto fail; | ||
233 | if (ip) | ||
234 | goto out_ip; | ||
235 | |||
236 | error = gfs2_rindex_hold(sdp, &ri_gh); | ||
237 | if (error) | ||
238 | goto fail; | ||
239 | |||
240 | error = -EINVAL; | ||
241 | rgd = gfs2_blk2rgrpd(sdp, inum->no_addr); | ||
242 | if (!rgd) | ||
243 | goto fail_rindex; | ||
244 | |||
245 | error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh); | ||
246 | if (error) | ||
247 | goto fail_rindex; | ||
248 | |||
249 | error = -ESTALE; | ||
250 | if (gfs2_get_block_type(rgd, inum->no_addr) != GFS2_BLKST_DINODE) | ||
251 | goto fail_rgd; | ||
252 | |||
253 | gfs2_glock_dq_uninit(&rgd_gh); | ||
254 | gfs2_glock_dq_uninit(&ri_gh); | ||
255 | |||
256 | error = gfs2_inode_get(i_gh.gh_gl, inum, CREATE, &ip); | ||
257 | if (error) | ||
258 | goto fail; | ||
259 | |||
260 | error = gfs2_inode_refresh(ip); | ||
261 | if (error) { | ||
262 | gfs2_inode_put(ip); | ||
263 | goto fail; | ||
264 | } | ||
265 | |||
266 | atomic_inc(&sdp->sd_fh2dentry_misses); | ||
267 | |||
268 | out_ip: | ||
269 | error = -EIO; | ||
270 | if (ip->i_di.di_flags & GFS2_DIF_SYSTEM) { | ||
271 | gfs2_inode_put(ip); | ||
272 | goto fail; | ||
273 | } | ||
274 | |||
275 | gfs2_glock_dq_uninit(&i_gh); | ||
276 | |||
277 | inode = gfs2_ip2v(ip); | ||
278 | gfs2_inode_put(ip); | ||
279 | |||
280 | if (!inode) | ||
281 | return ERR_PTR(-ENOMEM); | ||
282 | |||
283 | out_inode: | ||
284 | dentry = d_alloc_anon(inode); | ||
285 | if (!dentry) { | ||
286 | iput(inode); | ||
287 | return ERR_PTR(-ENOMEM); | ||
288 | } | ||
289 | |||
290 | return dentry; | ||
291 | |||
292 | fail_rgd: | ||
293 | gfs2_glock_dq_uninit(&rgd_gh); | ||
294 | |||
295 | fail_rindex: | ||
296 | gfs2_glock_dq_uninit(&ri_gh); | ||
297 | |||
298 | fail: | ||
299 | gfs2_glock_dq_uninit(&i_gh); | ||
300 | return ERR_PTR(error); | ||
301 | } | ||
302 | |||
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, | ||
309 | }; | ||
310 | |||