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