]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/fs/affs/namei.c | |
3 | * | |
4 | * (c) 1996 Hans-Joachim Widmaier - Rewritten | |
5 | * | |
6 | * (C) 1993 Ray Burr - Modified for Amiga FFS filesystem. | |
7 | * | |
8 | * (C) 1991 Linus Torvalds - minix filesystem | |
9 | */ | |
10 | ||
11 | #include "affs.h" | |
ed4433d7 | 12 | #include <linux/exportfs.h> |
1da177e4 LT |
13 | |
14 | typedef int (*toupper_t)(int); | |
15 | ||
1da177e4 LT |
16 | /* Simple toupper() for DOS\1 */ |
17 | ||
18 | static int | |
19 | affs_toupper(int ch) | |
20 | { | |
21 | return ch >= 'a' && ch <= 'z' ? ch -= ('a' - 'A') : ch; | |
22 | } | |
23 | ||
24 | /* International toupper() for DOS\3 ("international") */ | |
25 | ||
26 | static int | |
27 | affs_intl_toupper(int ch) | |
28 | { | |
29 | return (ch >= 'a' && ch <= 'z') || (ch >= 0xE0 | |
30 | && ch <= 0xFE && ch != 0xF7) ? | |
31 | ch - ('a' - 'A') : ch; | |
32 | } | |
33 | ||
34 | static inline toupper_t | |
35 | affs_get_toupper(struct super_block *sb) | |
36 | { | |
79bda4d5 FF |
37 | return affs_test_opt(AFFS_SB(sb)->s_flags, SF_INTL) ? |
38 | affs_intl_toupper : affs_toupper; | |
1da177e4 LT |
39 | } |
40 | ||
41 | /* | |
42 | * Note: the dentry argument is the parent dentry. | |
43 | */ | |
44 | static inline int | |
8387ff25 | 45 | __affs_hash_dentry(const struct dentry *dentry, struct qstr *qstr, toupper_t toupper, bool notruncate) |
1da177e4 LT |
46 | { |
47 | const u8 *name = qstr->name; | |
48 | unsigned long hash; | |
eeb36f8e FF |
49 | int retval; |
50 | u32 len; | |
1da177e4 | 51 | |
eeb36f8e FF |
52 | retval = affs_check_name(qstr->name, qstr->len, notruncate); |
53 | if (retval) | |
54 | return retval; | |
1da177e4 | 55 | |
8387ff25 | 56 | hash = init_name_hash(dentry); |
f157853e | 57 | len = min(qstr->len, AFFSNAMEMAX); |
eeb36f8e | 58 | for (; len > 0; name++, len--) |
1da177e4 LT |
59 | hash = partial_name_hash(toupper(*name), hash); |
60 | qstr->hash = end_name_hash(hash); | |
61 | ||
62 | return 0; | |
63 | } | |
64 | ||
65 | static int | |
da53be12 | 66 | affs_hash_dentry(const struct dentry *dentry, struct qstr *qstr) |
1da177e4 | 67 | { |
8387ff25 | 68 | return __affs_hash_dentry(dentry, qstr, affs_toupper, |
8ca57722 FF |
69 | affs_nofilenametruncate(dentry)); |
70 | ||
1da177e4 | 71 | } |
8ca57722 | 72 | |
1da177e4 | 73 | static int |
da53be12 | 74 | affs_intl_hash_dentry(const struct dentry *dentry, struct qstr *qstr) |
1da177e4 | 75 | { |
8387ff25 | 76 | return __affs_hash_dentry(dentry, qstr, affs_intl_toupper, |
8ca57722 FF |
77 | affs_nofilenametruncate(dentry)); |
78 | ||
1da177e4 LT |
79 | } |
80 | ||
621e155a | 81 | static inline int __affs_compare_dentry(unsigned int len, |
8ca57722 FF |
82 | const char *str, const struct qstr *name, toupper_t toupper, |
83 | bool notruncate) | |
1da177e4 | 84 | { |
621e155a NP |
85 | const u8 *aname = str; |
86 | const u8 *bname = name->name; | |
1da177e4 | 87 | |
621e155a NP |
88 | /* |
89 | * 'str' is the name of an already existing dentry, so the name | |
90 | * must be valid. 'name' must be validated first. | |
1da177e4 LT |
91 | */ |
92 | ||
8ca57722 | 93 | if (affs_check_name(name->name, name->len, notruncate)) |
1da177e4 LT |
94 | return 1; |
95 | ||
621e155a NP |
96 | /* |
97 | * If the names are longer than the allowed 30 chars, | |
1da177e4 LT |
98 | * the excess is ignored, so their length may differ. |
99 | */ | |
f157853e FF |
100 | if (len >= AFFSNAMEMAX) { |
101 | if (name->len < AFFSNAMEMAX) | |
1da177e4 | 102 | return 1; |
f157853e | 103 | len = AFFSNAMEMAX; |
621e155a | 104 | } else if (len != name->len) |
1da177e4 LT |
105 | return 1; |
106 | ||
107 | for (; len > 0; len--) | |
108 | if (toupper(*aname++) != toupper(*bname++)) | |
109 | return 1; | |
110 | ||
111 | return 0; | |
112 | } | |
113 | ||
114 | static int | |
6fa67e70 | 115 | affs_compare_dentry(const struct dentry *dentry, |
621e155a | 116 | unsigned int len, const char *str, const struct qstr *name) |
1da177e4 | 117 | { |
8ca57722 FF |
118 | |
119 | return __affs_compare_dentry(len, str, name, affs_toupper, | |
e0b3f595 | 120 | affs_nofilenametruncate(dentry)); |
1da177e4 | 121 | } |
8ca57722 | 122 | |
1da177e4 | 123 | static int |
6fa67e70 | 124 | affs_intl_compare_dentry(const struct dentry *dentry, |
621e155a | 125 | unsigned int len, const char *str, const struct qstr *name) |
1da177e4 | 126 | { |
8ca57722 | 127 | return __affs_compare_dentry(len, str, name, affs_intl_toupper, |
e0b3f595 | 128 | affs_nofilenametruncate(dentry)); |
8ca57722 | 129 | |
1da177e4 LT |
130 | } |
131 | ||
132 | /* | |
133 | * NOTE! unlike strncmp, affs_match returns 1 for success, 0 for failure. | |
134 | */ | |
135 | ||
136 | static inline int | |
137 | affs_match(struct dentry *dentry, const u8 *name2, toupper_t toupper) | |
138 | { | |
139 | const u8 *name = dentry->d_name.name; | |
140 | int len = dentry->d_name.len; | |
141 | ||
f157853e FF |
142 | if (len >= AFFSNAMEMAX) { |
143 | if (*name2 < AFFSNAMEMAX) | |
1da177e4 | 144 | return 0; |
f157853e | 145 | len = AFFSNAMEMAX; |
1da177e4 LT |
146 | } else if (len != *name2) |
147 | return 0; | |
148 | ||
149 | for (name2++; len > 0; len--) | |
150 | if (toupper(*name++) != toupper(*name2++)) | |
151 | return 0; | |
152 | return 1; | |
153 | } | |
154 | ||
155 | int | |
156 | affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len) | |
157 | { | |
158 | toupper_t toupper = affs_get_toupper(sb); | |
eeb36f8e | 159 | u32 hash; |
1da177e4 | 160 | |
f157853e | 161 | hash = len = min(len, AFFSNAMEMAX); |
1da177e4 LT |
162 | for (; len > 0; len--) |
163 | hash = (hash * 13 + toupper(*name++)) & 0x7ff; | |
164 | ||
165 | return hash % AFFS_SB(sb)->s_hashsize; | |
166 | } | |
167 | ||
168 | static struct buffer_head * | |
169 | affs_find_entry(struct inode *dir, struct dentry *dentry) | |
170 | { | |
171 | struct super_block *sb = dir->i_sb; | |
172 | struct buffer_head *bh; | |
173 | toupper_t toupper = affs_get_toupper(sb); | |
174 | u32 key; | |
175 | ||
a455589f | 176 | pr_debug("%s(\"%pd\")\n", __func__, dentry); |
1da177e4 LT |
177 | |
178 | bh = affs_bread(sb, dir->i_ino); | |
179 | if (!bh) | |
180 | return ERR_PTR(-EIO); | |
181 | ||
182 | key = be32_to_cpu(AFFS_HEAD(bh)->table[affs_hash_name(sb, dentry->d_name.name, dentry->d_name.len)]); | |
183 | ||
184 | for (;;) { | |
185 | affs_brelse(bh); | |
186 | if (key == 0) | |
187 | return NULL; | |
188 | bh = affs_bread(sb, key); | |
189 | if (!bh) | |
190 | return ERR_PTR(-EIO); | |
191 | if (affs_match(dentry, AFFS_TAIL(sb, bh)->name, toupper)) | |
192 | return bh; | |
193 | key = be32_to_cpu(AFFS_TAIL(sb, bh)->hash_chain); | |
194 | } | |
195 | } | |
196 | ||
197 | struct dentry * | |
00cd8dd3 | 198 | affs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) |
1da177e4 LT |
199 | { |
200 | struct super_block *sb = dir->i_sb; | |
201 | struct buffer_head *bh; | |
202 | struct inode *inode = NULL; | |
203 | ||
a455589f | 204 | pr_debug("%s(\"%pd\")\n", __func__, dentry); |
1da177e4 LT |
205 | |
206 | affs_lock_dir(dir); | |
207 | bh = affs_find_entry(dir, dentry); | |
208 | affs_unlock_dir(dir); | |
210f8559 | 209 | if (IS_ERR(bh)) |
e231c2ee | 210 | return ERR_CAST(bh); |
1da177e4 LT |
211 | if (bh) { |
212 | u32 ino = bh->b_blocknr; | |
213 | ||
214 | /* store the real header ino in d_fsdata for faster lookups */ | |
215 | dentry->d_fsdata = (void *)(long)ino; | |
216 | switch (be32_to_cpu(AFFS_TAIL(sb, bh)->stype)) { | |
217 | //link to dirs disabled | |
218 | //case ST_LINKDIR: | |
219 | case ST_LINKFILE: | |
220 | ino = be32_to_cpu(AFFS_TAIL(sb, bh)->original); | |
221 | } | |
222 | affs_brelse(bh); | |
210f8559 DH |
223 | inode = affs_iget(sb, ino); |
224 | if (IS_ERR(inode)) | |
cccad8f9 | 225 | return ERR_CAST(inode); |
1da177e4 | 226 | } |
1da177e4 LT |
227 | d_add(dentry, inode); |
228 | return NULL; | |
229 | } | |
230 | ||
231 | int | |
232 | affs_unlink(struct inode *dir, struct dentry *dentry) | |
233 | { | |
08fe100d | 234 | pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino, |
2b0143b5 | 235 | d_inode(dentry)->i_ino, dentry); |
1da177e4 LT |
236 | |
237 | return affs_remove_header(dentry); | |
238 | } | |
239 | ||
240 | int | |
ebfc3b49 | 241 | affs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl) |
1da177e4 LT |
242 | { |
243 | struct super_block *sb = dir->i_sb; | |
244 | struct inode *inode; | |
245 | int error; | |
246 | ||
a455589f AV |
247 | pr_debug("%s(%lu,\"%pd\",0%ho)\n", |
248 | __func__, dir->i_ino, dentry, mode); | |
1da177e4 LT |
249 | |
250 | inode = affs_new_inode(dir); | |
251 | if (!inode) | |
252 | return -ENOSPC; | |
253 | ||
254 | inode->i_mode = mode; | |
c1618208 | 255 | affs_mode_to_prot(inode); |
1da177e4 LT |
256 | mark_inode_dirty(inode); |
257 | ||
258 | inode->i_op = &affs_file_inode_operations; | |
259 | inode->i_fop = &affs_file_operations; | |
79bda4d5 | 260 | inode->i_mapping->a_ops = affs_test_opt(AFFS_SB(sb)->s_flags, SF_OFS) ? |
a0016ff2 | 261 | &affs_aops_ofs : &affs_aops; |
1da177e4 LT |
262 | error = affs_add_entry(dir, inode, dentry, ST_FILE); |
263 | if (error) { | |
6d6b77f1 | 264 | clear_nlink(inode); |
1da177e4 LT |
265 | iput(inode); |
266 | return error; | |
267 | } | |
268 | return 0; | |
269 | } | |
270 | ||
271 | int | |
18bb1db3 | 272 | affs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) |
1da177e4 LT |
273 | { |
274 | struct inode *inode; | |
275 | int error; | |
276 | ||
a455589f AV |
277 | pr_debug("%s(%lu,\"%pd\",0%ho)\n", |
278 | __func__, dir->i_ino, dentry, mode); | |
1da177e4 LT |
279 | |
280 | inode = affs_new_inode(dir); | |
281 | if (!inode) | |
282 | return -ENOSPC; | |
283 | ||
284 | inode->i_mode = S_IFDIR | mode; | |
c1618208 | 285 | affs_mode_to_prot(inode); |
1da177e4 LT |
286 | |
287 | inode->i_op = &affs_dir_inode_operations; | |
288 | inode->i_fop = &affs_dir_operations; | |
289 | ||
290 | error = affs_add_entry(dir, inode, dentry, ST_USERDIR); | |
291 | if (error) { | |
6d6b77f1 | 292 | clear_nlink(inode); |
1da177e4 LT |
293 | mark_inode_dirty(inode); |
294 | iput(inode); | |
295 | return error; | |
296 | } | |
297 | return 0; | |
298 | } | |
299 | ||
300 | int | |
301 | affs_rmdir(struct inode *dir, struct dentry *dentry) | |
302 | { | |
08fe100d | 303 | pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino, |
2b0143b5 | 304 | d_inode(dentry)->i_ino, dentry); |
1da177e4 LT |
305 | |
306 | return affs_remove_header(dentry); | |
307 | } | |
308 | ||
309 | int | |
310 | affs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) | |
311 | { | |
312 | struct super_block *sb = dir->i_sb; | |
313 | struct buffer_head *bh; | |
314 | struct inode *inode; | |
315 | char *p; | |
316 | int i, maxlen, error; | |
317 | char c, lc; | |
318 | ||
a455589f AV |
319 | pr_debug("%s(%lu,\"%pd\" -> \"%s\")\n", |
320 | __func__, dir->i_ino, dentry, symname); | |
1da177e4 LT |
321 | |
322 | maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1; | |
323 | inode = affs_new_inode(dir); | |
324 | if (!inode) | |
325 | return -ENOSPC; | |
326 | ||
327 | inode->i_op = &affs_symlink_inode_operations; | |
21fc61c7 | 328 | inode_nohighmem(inode); |
1da177e4 LT |
329 | inode->i_data.a_ops = &affs_symlink_aops; |
330 | inode->i_mode = S_IFLNK | 0777; | |
c1618208 | 331 | affs_mode_to_prot(inode); |
1da177e4 LT |
332 | |
333 | error = -EIO; | |
334 | bh = affs_bread(sb, inode->i_ino); | |
335 | if (!bh) | |
336 | goto err; | |
337 | i = 0; | |
338 | p = (char *)AFFS_HEAD(bh)->table; | |
339 | lc = '/'; | |
340 | if (*symname == '/') { | |
29333920 | 341 | struct affs_sb_info *sbi = AFFS_SB(sb); |
1da177e4 LT |
342 | while (*symname == '/') |
343 | symname++; | |
29333920 AV |
344 | spin_lock(&sbi->symlink_lock); |
345 | while (sbi->s_volume[i]) /* Cannot overflow */ | |
346 | *p++ = sbi->s_volume[i++]; | |
347 | spin_unlock(&sbi->symlink_lock); | |
1da177e4 LT |
348 | } |
349 | while (i < maxlen && (c = *symname++)) { | |
350 | if (c == '.' && lc == '/' && *symname == '.' && symname[1] == '/') { | |
351 | *p++ = '/'; | |
352 | i++; | |
353 | symname += 2; | |
354 | lc = '/'; | |
355 | } else if (c == '.' && lc == '/' && *symname == '/') { | |
356 | symname++; | |
357 | lc = '/'; | |
358 | } else { | |
359 | *p++ = c; | |
360 | lc = c; | |
361 | i++; | |
362 | } | |
363 | if (lc == '/') | |
364 | while (*symname == '/') | |
365 | symname++; | |
366 | } | |
367 | *p = 0; | |
f1bf9072 | 368 | inode->i_size = i + 1; |
1da177e4 LT |
369 | mark_buffer_dirty_inode(bh, inode); |
370 | affs_brelse(bh); | |
371 | mark_inode_dirty(inode); | |
372 | ||
373 | error = affs_add_entry(dir, inode, dentry, ST_SOFTLINK); | |
374 | if (error) | |
375 | goto err; | |
376 | ||
377 | return 0; | |
378 | ||
379 | err: | |
6d6b77f1 | 380 | clear_nlink(inode); |
1da177e4 LT |
381 | mark_inode_dirty(inode); |
382 | iput(inode); | |
383 | return error; | |
384 | } | |
385 | ||
386 | int | |
387 | affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) | |
388 | { | |
2b0143b5 | 389 | struct inode *inode = d_inode(old_dentry); |
1da177e4 | 390 | |
08fe100d | 391 | pr_debug("%s(%lu, %lu, \"%pd\")\n", __func__, inode->i_ino, dir->i_ino, |
a455589f | 392 | dentry); |
1da177e4 LT |
393 | |
394 | return affs_add_entry(dir, inode, dentry, ST_LINKFILE); | |
395 | } | |
396 | ||
c6184028 | 397 | static int |
1da177e4 | 398 | affs_rename(struct inode *old_dir, struct dentry *old_dentry, |
c6184028 | 399 | struct inode *new_dir, struct dentry *new_dentry) |
1da177e4 LT |
400 | { |
401 | struct super_block *sb = old_dir->i_sb; | |
402 | struct buffer_head *bh = NULL; | |
403 | int retval; | |
404 | ||
8ca57722 FF |
405 | retval = affs_check_name(new_dentry->d_name.name, |
406 | new_dentry->d_name.len, | |
407 | affs_nofilenametruncate(old_dentry)); | |
408 | ||
1da177e4 LT |
409 | if (retval) |
410 | return retval; | |
411 | ||
412 | /* Unlink destination if it already exists */ | |
2b0143b5 | 413 | if (d_really_is_positive(new_dentry)) { |
1da177e4 LT |
414 | retval = affs_remove_header(new_dentry); |
415 | if (retval) | |
416 | return retval; | |
417 | } | |
418 | ||
2b0143b5 | 419 | bh = affs_bread(sb, d_inode(old_dentry)->i_ino); |
1da177e4 | 420 | if (!bh) |
3ac81413 | 421 | return -EIO; |
1da177e4 LT |
422 | |
423 | /* Remove header from its parent directory. */ | |
424 | affs_lock_dir(old_dir); | |
425 | retval = affs_remove_hash(old_dir, bh); | |
426 | affs_unlock_dir(old_dir); | |
427 | if (retval) | |
428 | goto done; | |
429 | ||
430 | /* And insert it into the new directory with the new name. */ | |
431 | affs_copy_name(AFFS_TAIL(sb, bh)->name, new_dentry); | |
432 | affs_fix_checksum(sb, bh); | |
433 | affs_lock_dir(new_dir); | |
434 | retval = affs_insert_hash(new_dir, bh); | |
435 | affs_unlock_dir(new_dir); | |
436 | /* TODO: move it back to old_dir, if error? */ | |
437 | ||
438 | done: | |
439 | mark_buffer_dirty_inode(bh, retval ? old_dir : new_dir); | |
440 | affs_brelse(bh); | |
441 | return retval; | |
442 | } | |
ed4433d7 | 443 | |
6b465766 FF |
444 | static int |
445 | affs_xrename(struct inode *old_dir, struct dentry *old_dentry, | |
446 | struct inode *new_dir, struct dentry *new_dentry) | |
447 | { | |
448 | ||
449 | struct super_block *sb = old_dir->i_sb; | |
450 | struct buffer_head *bh_old = NULL; | |
451 | struct buffer_head *bh_new = NULL; | |
452 | int retval; | |
453 | ||
454 | bh_old = affs_bread(sb, d_inode(old_dentry)->i_ino); | |
455 | if (!bh_old) | |
456 | return -EIO; | |
457 | ||
458 | bh_new = affs_bread(sb, d_inode(new_dentry)->i_ino); | |
459 | if (!bh_new) | |
460 | return -EIO; | |
461 | ||
462 | /* Remove old header from its parent directory. */ | |
463 | affs_lock_dir(old_dir); | |
464 | retval = affs_remove_hash(old_dir, bh_old); | |
465 | affs_unlock_dir(old_dir); | |
466 | if (retval) | |
467 | goto done; | |
468 | ||
469 | /* Remove new header from its parent directory. */ | |
470 | affs_lock_dir(new_dir); | |
471 | retval = affs_remove_hash(new_dir, bh_new); | |
472 | affs_unlock_dir(new_dir); | |
473 | if (retval) | |
474 | goto done; | |
475 | ||
476 | /* Insert old into the new directory with the new name. */ | |
477 | affs_copy_name(AFFS_TAIL(sb, bh_old)->name, new_dentry); | |
478 | affs_fix_checksum(sb, bh_old); | |
479 | affs_lock_dir(new_dir); | |
480 | retval = affs_insert_hash(new_dir, bh_old); | |
481 | affs_unlock_dir(new_dir); | |
482 | ||
483 | /* Insert new into the old directory with the old name. */ | |
484 | affs_copy_name(AFFS_TAIL(sb, bh_new)->name, old_dentry); | |
485 | affs_fix_checksum(sb, bh_new); | |
486 | affs_lock_dir(old_dir); | |
487 | retval = affs_insert_hash(old_dir, bh_new); | |
488 | affs_unlock_dir(old_dir); | |
489 | done: | |
490 | mark_buffer_dirty_inode(bh_old, new_dir); | |
491 | mark_buffer_dirty_inode(bh_new, old_dir); | |
492 | affs_brelse(bh_old); | |
493 | affs_brelse(bh_new); | |
494 | return retval; | |
495 | } | |
496 | ||
c6184028 FF |
497 | int affs_rename2(struct inode *old_dir, struct dentry *old_dentry, |
498 | struct inode *new_dir, struct dentry *new_dentry, | |
499 | unsigned int flags) | |
500 | { | |
501 | ||
6b465766 | 502 | if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE)) |
c6184028 FF |
503 | return -EINVAL; |
504 | ||
505 | pr_debug("%s(old=%lu,\"%pd\" to new=%lu,\"%pd\")\n", __func__, | |
506 | old_dir->i_ino, old_dentry, new_dir->i_ino, new_dentry); | |
507 | ||
6b465766 FF |
508 | if (flags & RENAME_EXCHANGE) |
509 | return affs_xrename(old_dir, old_dentry, new_dir, new_dentry); | |
510 | ||
c6184028 FF |
511 | return affs_rename(old_dir, old_dentry, new_dir, new_dentry); |
512 | } | |
513 | ||
b3b42c0d FF |
514 | static struct dentry *affs_get_parent(struct dentry *child) |
515 | { | |
516 | struct inode *parent; | |
517 | struct buffer_head *bh; | |
518 | ||
519 | bh = affs_bread(child->d_sb, d_inode(child)->i_ino); | |
520 | if (!bh) | |
521 | return ERR_PTR(-EIO); | |
522 | ||
523 | parent = affs_iget(child->d_sb, | |
524 | be32_to_cpu(AFFS_TAIL(child->d_sb, bh)->parent)); | |
525 | brelse(bh); | |
526 | if (IS_ERR(parent)) | |
527 | return ERR_CAST(parent); | |
528 | ||
529 | return d_obtain_alias(parent); | |
530 | } | |
531 | ||
ed4433d7 FF |
532 | static struct inode *affs_nfs_get_inode(struct super_block *sb, u64 ino, |
533 | u32 generation) | |
534 | { | |
535 | struct inode *inode; | |
536 | ||
537 | if (!affs_validblock(sb, ino)) | |
538 | return ERR_PTR(-ESTALE); | |
539 | ||
540 | inode = affs_iget(sb, ino); | |
541 | if (IS_ERR(inode)) | |
542 | return ERR_CAST(inode); | |
543 | ||
ed4433d7 FF |
544 | return inode; |
545 | } | |
546 | ||
547 | static struct dentry *affs_fh_to_dentry(struct super_block *sb, struct fid *fid, | |
548 | int fh_len, int fh_type) | |
549 | { | |
550 | return generic_fh_to_dentry(sb, fid, fh_len, fh_type, | |
551 | affs_nfs_get_inode); | |
552 | } | |
553 | ||
554 | static struct dentry *affs_fh_to_parent(struct super_block *sb, struct fid *fid, | |
555 | int fh_len, int fh_type) | |
556 | { | |
557 | return generic_fh_to_parent(sb, fid, fh_len, fh_type, | |
558 | affs_nfs_get_inode); | |
559 | } | |
560 | ||
561 | const struct export_operations affs_export_ops = { | |
562 | .fh_to_dentry = affs_fh_to_dentry, | |
563 | .fh_to_parent = affs_fh_to_parent, | |
b3b42c0d | 564 | .get_parent = affs_get_parent, |
ed4433d7 | 565 | }; |
f567accb FF |
566 | |
567 | const struct dentry_operations affs_dentry_operations = { | |
568 | .d_hash = affs_hash_dentry, | |
569 | .d_compare = affs_compare_dentry, | |
570 | }; | |
571 | ||
572 | const struct dentry_operations affs_intl_dentry_operations = { | |
573 | .d_hash = affs_intl_hash_dentry, | |
574 | .d_compare = affs_intl_compare_dentry, | |
575 | }; |