Commit | Line | Data |
---|---|---|
b3b94faa DT |
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 |