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 | ||
b3b94faa DT |
10 | #include <linux/slab.h> |
11 | #include <linux/spinlock.h> | |
12 | #include <linux/completion.h> | |
13 | #include <linux/buffer_head.h> | |
a5694255 | 14 | #include <linux/exportfs.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" | |
70831465 | 25 | #include "ops_dentry.h" |
bb8d8a6f | 26 | #include "ops_fstype.h" |
b3b94faa | 27 | #include "rgrp.h" |
c752666c | 28 | #include "util.h" |
b3b94faa | 29 | |
bb8d8a6f | 30 | #define GFS2_SMALL_FH_SIZE 4 |
35dcc52e | 31 | #define GFS2_LARGE_FH_SIZE 8 |
3ebf4490 | 32 | #define GFS2_OLD_FH_SIZE 10 |
bb8d8a6f | 33 | |
b44b84d7 | 34 | static int gfs2_encode_fh(struct dentry *dentry, __u32 *p, int *len, |
b3b94faa DT |
35 | int connectable) |
36 | { | |
b44b84d7 | 37 | __be32 *fh = (__force __be32 *)p; |
b3b94faa | 38 | struct inode *inode = dentry->d_inode; |
c9fd4307 | 39 | struct super_block *sb = inode->i_sb; |
feaa7bba | 40 | struct gfs2_inode *ip = GFS2_I(inode); |
b3b94faa | 41 | |
5acd3967 SW |
42 | if (*len < GFS2_SMALL_FH_SIZE || |
43 | (connectable && *len < GFS2_LARGE_FH_SIZE)) | |
b3b94faa DT |
44 | return 255; |
45 | ||
dbb7cae2 SW |
46 | fh[0] = cpu_to_be32(ip->i_no_formal_ino >> 32); |
47 | fh[1] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF); | |
48 | fh[2] = cpu_to_be32(ip->i_no_addr >> 32); | |
49 | fh[3] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF); | |
5acd3967 | 50 | *len = GFS2_SMALL_FH_SIZE; |
b3b94faa | 51 | |
c9fd4307 | 52 | if (!connectable || inode == sb->s_root->d_inode) |
b3b94faa DT |
53 | return *len; |
54 | ||
55 | spin_lock(&dentry->d_lock); | |
56 | inode = dentry->d_parent->d_inode; | |
feaa7bba SW |
57 | ip = GFS2_I(inode); |
58 | igrab(inode); | |
b3b94faa DT |
59 | spin_unlock(&dentry->d_lock); |
60 | ||
dbb7cae2 SW |
61 | fh[4] = cpu_to_be32(ip->i_no_formal_ino >> 32); |
62 | fh[5] = cpu_to_be32(ip->i_no_formal_ino & 0xFFFFFFFF); | |
63 | fh[6] = cpu_to_be32(ip->i_no_addr >> 32); | |
64 | fh[7] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF); | |
5acd3967 | 65 | *len = GFS2_LARGE_FH_SIZE; |
b3b94faa | 66 | |
feaa7bba | 67 | iput(inode); |
b3b94faa DT |
68 | |
69 | return *len; | |
70 | } | |
71 | ||
72 | struct get_name_filldir { | |
629a21e7 | 73 | struct gfs2_inum_host inum; |
b3b94faa DT |
74 | char *name; |
75 | }; | |
76 | ||
3699e3a4 SW |
77 | static int get_name_filldir(void *opaque, const char *name, int length, |
78 | loff_t offset, u64 inum, unsigned int type) | |
b3b94faa | 79 | { |
3699e3a4 | 80 | struct get_name_filldir *gnfd = opaque; |
b3b94faa | 81 | |
3699e3a4 | 82 | if (inum != gnfd->inum.no_addr) |
b3b94faa DT |
83 | return 0; |
84 | ||
85 | memcpy(gnfd->name, name, length); | |
86 | gnfd->name[length] = 0; | |
87 | ||
88 | return 1; | |
89 | } | |
90 | ||
91 | static int gfs2_get_name(struct dentry *parent, char *name, | |
92 | struct dentry *child) | |
93 | { | |
94 | struct inode *dir = parent->d_inode; | |
95 | struct inode *inode = child->d_inode; | |
96 | struct gfs2_inode *dip, *ip; | |
97 | struct get_name_filldir gnfd; | |
98 | struct gfs2_holder gh; | |
cd915493 | 99 | u64 offset = 0; |
b3b94faa DT |
100 | int error; |
101 | ||
102 | if (!dir) | |
103 | return -EINVAL; | |
104 | ||
b3b94faa DT |
105 | if (!S_ISDIR(dir->i_mode) || !inode) |
106 | return -EINVAL; | |
107 | ||
feaa7bba SW |
108 | dip = GFS2_I(dir); |
109 | ip = GFS2_I(inode); | |
b3b94faa DT |
110 | |
111 | *name = 0; | |
dbb7cae2 SW |
112 | gnfd.inum.no_addr = ip->i_no_addr; |
113 | gnfd.inum.no_formal_ino = ip->i_no_formal_ino; | |
b3b94faa DT |
114 | gnfd.name = name; |
115 | ||
116 | error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &gh); | |
117 | if (error) | |
118 | return error; | |
119 | ||
71b86f56 | 120 | error = gfs2_dir_read(dir, &offset, &gnfd, get_name_filldir); |
b3b94faa DT |
121 | |
122 | gfs2_glock_dq_uninit(&gh); | |
123 | ||
124 | if (!error && !*name) | |
125 | error = -ENOENT; | |
126 | ||
127 | return error; | |
128 | } | |
129 | ||
130 | static struct dentry *gfs2_get_parent(struct dentry *child) | |
131 | { | |
71b86f56 | 132 | struct qstr dotdot; |
b3b94faa DT |
133 | struct inode *inode; |
134 | struct dentry *dentry; | |
b3b94faa | 135 | |
71b86f56 | 136 | gfs2_str2qstr(&dotdot, ".."); |
c752666c SW |
137 | inode = gfs2_lookupi(child->d_inode, &dotdot, 1, NULL); |
138 | ||
139 | if (!inode) | |
140 | return ERR_PTR(-ENOENT); | |
7b625361 SW |
141 | /* |
142 | * In case of an error, @inode carries the error value, and we | |
143 | * have to return that as a(n invalid) pointer to dentry. | |
144 | */ | |
c752666c | 145 | if (IS_ERR(inode)) |
e231c2ee | 146 | return ERR_CAST(inode); |
b3b94faa | 147 | |
b3b94faa DT |
148 | dentry = d_alloc_anon(inode); |
149 | if (!dentry) { | |
150 | iput(inode); | |
151 | return ERR_PTR(-ENOMEM); | |
152 | } | |
153 | ||
70831465 | 154 | dentry->d_op = &gfs2_dops; |
b3b94faa DT |
155 | return dentry; |
156 | } | |
157 | ||
34c0d154 CH |
158 | static struct dentry *gfs2_get_dentry(struct super_block *sb, |
159 | struct gfs2_inum_host *inum) | |
b3b94faa | 160 | { |
5c676f6d | 161 | struct gfs2_sbd *sdp = sb->s_fs_info; |
b3b94faa DT |
162 | struct gfs2_holder i_gh, ri_gh, rgd_gh; |
163 | struct gfs2_rgrpd *rgd; | |
b3b94faa DT |
164 | struct inode *inode; |
165 | struct dentry *dentry; | |
166 | int error; | |
167 | ||
b3b94faa DT |
168 | /* System files? */ |
169 | ||
dbb7cae2 | 170 | inode = gfs2_ilookup(sb, inum->no_addr); |
b3b94faa | 171 | if (inode) { |
dbb7cae2 | 172 | if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) { |
b3b94faa DT |
173 | iput(inode); |
174 | return ERR_PTR(-ESTALE); | |
175 | } | |
176 | goto out_inode; | |
177 | } | |
178 | ||
feaa7bba | 179 | error = gfs2_glock_nq_num(sdp, inum->no_addr, &gfs2_inode_glops, |
1c0f4872 | 180 | LM_ST_SHARED, LM_FLAG_ANY, &i_gh); |
b3b94faa DT |
181 | if (error) |
182 | return ERR_PTR(error); | |
183 | ||
b3b94faa DT |
184 | error = gfs2_rindex_hold(sdp, &ri_gh); |
185 | if (error) | |
186 | goto fail; | |
187 | ||
188 | error = -EINVAL; | |
189 | rgd = gfs2_blk2rgrpd(sdp, inum->no_addr); | |
190 | if (!rgd) | |
191 | goto fail_rindex; | |
192 | ||
193 | error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh); | |
194 | if (error) | |
195 | goto fail_rindex; | |
196 | ||
197 | error = -ESTALE; | |
198 | if (gfs2_get_block_type(rgd, inum->no_addr) != GFS2_BLKST_DINODE) | |
199 | goto fail_rgd; | |
200 | ||
201 | gfs2_glock_dq_uninit(&rgd_gh); | |
202 | gfs2_glock_dq_uninit(&ri_gh); | |
203 | ||
35dcc52e | 204 | inode = gfs2_inode_lookup(sb, DT_UNKNOWN, |
bb9bcf06 | 205 | inum->no_addr, |
7a9f53b3 | 206 | 0, 0); |
feaa7bba SW |
207 | if (IS_ERR(inode)) { |
208 | error = PTR_ERR(inode); | |
b3b94faa | 209 | goto fail; |
feaa7bba | 210 | } |
b3b94faa | 211 | |
feaa7bba | 212 | error = gfs2_inode_refresh(GFS2_I(inode)); |
b3b94faa | 213 | if (error) { |
feaa7bba | 214 | iput(inode); |
b3b94faa DT |
215 | goto fail; |
216 | } | |
35dcc52e WC |
217 | |
218 | /* Pick up the works we bypass in gfs2_inode_lookup */ | |
219 | if (inode->i_state & I_NEW) | |
220 | gfs2_set_iop(inode); | |
221 | ||
dbb7cae2 SW |
222 | if (GFS2_I(inode)->i_no_formal_ino != inum->no_formal_ino) { |
223 | iput(inode); | |
224 | goto fail; | |
225 | } | |
b3b94faa | 226 | |
b3b94faa | 227 | error = -EIO; |
feaa7bba SW |
228 | if (GFS2_I(inode)->i_di.di_flags & GFS2_DIF_SYSTEM) { |
229 | iput(inode); | |
b3b94faa DT |
230 | goto fail; |
231 | } | |
232 | ||
233 | gfs2_glock_dq_uninit(&i_gh); | |
234 | ||
feaa7bba | 235 | out_inode: |
b3b94faa DT |
236 | dentry = d_alloc_anon(inode); |
237 | if (!dentry) { | |
238 | iput(inode); | |
239 | return ERR_PTR(-ENOMEM); | |
240 | } | |
241 | ||
70831465 | 242 | dentry->d_op = &gfs2_dops; |
b3b94faa DT |
243 | return dentry; |
244 | ||
feaa7bba | 245 | fail_rgd: |
b3b94faa DT |
246 | gfs2_glock_dq_uninit(&rgd_gh); |
247 | ||
feaa7bba | 248 | fail_rindex: |
b3b94faa DT |
249 | gfs2_glock_dq_uninit(&ri_gh); |
250 | ||
feaa7bba | 251 | fail: |
b3b94faa DT |
252 | gfs2_glock_dq_uninit(&i_gh); |
253 | return ERR_PTR(error); | |
254 | } | |
255 | ||
34c0d154 CH |
256 | static struct dentry *gfs2_fh_to_dentry(struct super_block *sb, struct fid *fid, |
257 | int fh_len, int fh_type) | |
258 | { | |
259 | struct gfs2_inum_host this; | |
260 | __be32 *fh = (__force __be32 *)fid->raw; | |
261 | ||
262 | switch (fh_type) { | |
263 | case GFS2_SMALL_FH_SIZE: | |
264 | case GFS2_LARGE_FH_SIZE: | |
265 | case GFS2_OLD_FH_SIZE: | |
266 | this.no_formal_ino = ((u64)be32_to_cpu(fh[0])) << 32; | |
267 | this.no_formal_ino |= be32_to_cpu(fh[1]); | |
268 | this.no_addr = ((u64)be32_to_cpu(fh[2])) << 32; | |
269 | this.no_addr |= be32_to_cpu(fh[3]); | |
270 | return gfs2_get_dentry(sb, &this); | |
271 | default: | |
272 | return NULL; | |
273 | } | |
274 | } | |
275 | ||
276 | static struct dentry *gfs2_fh_to_parent(struct super_block *sb, struct fid *fid, | |
277 | int fh_len, int fh_type) | |
278 | { | |
279 | struct gfs2_inum_host parent; | |
280 | __be32 *fh = (__force __be32 *)fid->raw; | |
281 | ||
282 | switch (fh_type) { | |
283 | case GFS2_LARGE_FH_SIZE: | |
284 | case GFS2_OLD_FH_SIZE: | |
285 | parent.no_formal_ino = ((u64)be32_to_cpu(fh[4])) << 32; | |
286 | parent.no_formal_ino |= be32_to_cpu(fh[5]); | |
287 | parent.no_addr = ((u64)be32_to_cpu(fh[6])) << 32; | |
288 | parent.no_addr |= be32_to_cpu(fh[7]); | |
289 | return gfs2_get_dentry(sb, &parent); | |
290 | default: | |
291 | return NULL; | |
292 | } | |
293 | } | |
294 | ||
39655164 | 295 | const struct export_operations gfs2_export_ops = { |
b3b94faa | 296 | .encode_fh = gfs2_encode_fh, |
34c0d154 CH |
297 | .fh_to_dentry = gfs2_fh_to_dentry, |
298 | .fh_to_parent = gfs2_fh_to_parent, | |
b3b94faa DT |
299 | .get_name = gfs2_get_name, |
300 | .get_parent = gfs2_get_parent, | |
b3b94faa DT |
301 | }; |
302 |