]> git.ipfire.org Git - thirdparty/linux.git/blob - fs/exfat/namei.c
projects / thirdparty / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'io_uring-5.7-2020-05-22' of git://git.kernel.dk/linux-block
[thirdparty/linux.git] / fs / exfat / namei.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4 */
5
6 #include <linux/iversion.h>
7 #include <linux/namei.h>
8 #include <linux/slab.h>
9 #include <linux/buffer_head.h>
10 #include <linux/nls.h>
11
12 #include "exfat_raw.h"
13 #include "exfat_fs.h"
14
15 static inline unsigned long exfat_d_version(struct dentry *dentry)
16 {
17 return (unsigned long) dentry->d_fsdata;
18 }
19
20 static inline void exfat_d_version_set(struct dentry *dentry,
21 unsigned long version)
22 {
23 dentry->d_fsdata = (void *) version;
24 }
25
26 /*
27 * If new entry was created in the parent, it could create the 8.3 alias (the
28 * shortname of logname). So, the parent may have the negative-dentry which
29 * matches the created 8.3 alias.
30 *
31 * If it happened, the negative dentry isn't actually negative anymore. So,
32 * drop it.
33 */
34 static int exfat_d_revalidate(struct dentry *dentry, unsigned int flags)
35 {
36 int ret;
37
38 if (flags & LOOKUP_RCU)
39 return -ECHILD;
40
41 /*
42 * This is not negative dentry. Always valid.
43 *
44 * Note, rename() to existing directory entry will have ->d_inode, and
45 * will use existing name which isn't specified name by user.
46 *
47 * We may be able to drop this positive dentry here. But dropping
48 * positive dentry isn't good idea. So it's unsupported like
49 * rename("filename", "FILENAME") for now.
50 */
51 if (d_really_is_positive(dentry))
52 return 1;
53
54 /*
55 * Drop the negative dentry, in order to make sure to use the case
56 * sensitive name which is specified by user if this is for creation.
57 */
58 if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
59 return 0;
60
61 spin_lock(&dentry->d_lock);
62 ret = inode_eq_iversion(d_inode(dentry->d_parent),
63 exfat_d_version(dentry));
64 spin_unlock(&dentry->d_lock);
65 return ret;
66 }
67
68 /* returns the length of a struct qstr, ignoring trailing dots */
69 static unsigned int exfat_striptail_len(unsigned int len, const char *name)
70 {
71 while (len && name[len - 1] == '.')
72 len--;
73 return len;
74 }
75
76 /*
77 * Compute the hash for the exfat name corresponding to the dentry. If the name
78 * is invalid, we leave the hash code unchanged so that the existing dentry can
79 * be used. The exfat fs routines will return ENOENT or EINVAL as appropriate.
80 */
81 static int exfat_d_hash(const struct dentry *dentry, struct qstr *qstr)
82 {
83 struct super_block *sb = dentry->d_sb;
84 struct nls_table *t = EXFAT_SB(sb)->nls_io;
85 const unsigned char *name = qstr->name;
86 unsigned int len = exfat_striptail_len(qstr->len, qstr->name);
87 unsigned long hash = init_name_hash(dentry);
88 int i, charlen;
89 wchar_t c;
90
91 for (i = 0; i < len; i += charlen) {
92 charlen = t->char2uni(&name[i], len - i, &c);
93 if (charlen < 0)
94 return charlen;
95 hash = partial_name_hash(exfat_toupper(sb, c), hash);
96 }
97
98 qstr->hash = end_name_hash(hash);
99 return 0;
100 }
101
102 static int exfat_d_cmp(const struct dentry *dentry, unsigned int len,
103 const char *str, const struct qstr *name)
104 {
105 struct super_block *sb = dentry->d_sb;
106 struct nls_table *t = EXFAT_SB(sb)->nls_io;
107 unsigned int alen = exfat_striptail_len(name->len, name->name);
108 unsigned int blen = exfat_striptail_len(len, str);
109 wchar_t c1, c2;
110 int charlen, i;
111
112 if (alen != blen)
113 return 1;
114
115 for (i = 0; i < len; i += charlen) {
116 charlen = t->char2uni(&name->name[i], alen - i, &c1);
117 if (charlen < 0)
118 return 1;
119 if (charlen != t->char2uni(&str[i], blen - i, &c2))
120 return 1;
121
122 if (exfat_toupper(sb, c1) != exfat_toupper(sb, c2))
123 return 1;
124 }
125
126 return 0;
127 }
128
129 const struct dentry_operations exfat_dentry_ops = {
130 .d_revalidate = exfat_d_revalidate,
131 .d_hash = exfat_d_hash,
132 .d_compare = exfat_d_cmp,
133 };
134
135 static int exfat_utf8_d_hash(const struct dentry *dentry, struct qstr *qstr)
136 {
137 struct super_block *sb = dentry->d_sb;
138 const unsigned char *name = qstr->name;
139 unsigned int len = exfat_striptail_len(qstr->len, qstr->name);
140 unsigned long hash = init_name_hash(dentry);
141 int i, charlen;
142 unicode_t u;
143
144 for (i = 0; i < len; i += charlen) {
145 charlen = utf8_to_utf32(&name[i], len - i, &u);
146 if (charlen < 0)
147 return charlen;
148
149 /*
150 * Convert to UTF-16: code points above U+FFFF are encoded as
151 * surrogate pairs.
152 * exfat_toupper() works only for code points up to the U+FFFF.
153 */
154 if (u > 0xFFFF) {
155 hash = partial_name_hash(exfat_high_surrogate(u), hash);
156 hash = partial_name_hash(exfat_low_surrogate(u), hash);
157 } else {
158 hash = partial_name_hash(exfat_toupper(sb, u), hash);
159 }
160 }
161
162 qstr->hash = end_name_hash(hash);
163 return 0;
164 }
165
166 static int exfat_utf8_d_cmp(const struct dentry *dentry, unsigned int len,
167 const char *str, const struct qstr *name)
168 {
169 struct super_block *sb = dentry->d_sb;
170 unsigned int alen = exfat_striptail_len(name->len, name->name);
171 unsigned int blen = exfat_striptail_len(len, str);
172 unicode_t u_a, u_b;
173 int charlen, i;
174
175 if (alen != blen)
176 return 1;
177
178 for (i = 0; i < alen; i += charlen) {
179 charlen = utf8_to_utf32(&name->name[i], alen - i, &u_a);
180 if (charlen < 0)
181 return 1;
182 if (charlen != utf8_to_utf32(&str[i], blen - i, &u_b))
183 return 1;
184
185 if (u_a <= 0xFFFF && u_b <= 0xFFFF) {
186 if (exfat_toupper(sb, u_a) != exfat_toupper(sb, u_b))
187 return 1;
188 } else if (u_a > 0xFFFF && u_b > 0xFFFF) {
189 if (exfat_low_surrogate(u_a) !=
190 exfat_low_surrogate(u_b) ||
191 exfat_high_surrogate(u_a) !=
192 exfat_high_surrogate(u_b))
193 return 1;
194 } else {
195 return 1;
196 }
197 }
198
199 return 0;
200 }
201
202 const struct dentry_operations exfat_utf8_dentry_ops = {
203 .d_revalidate = exfat_d_revalidate,
204 .d_hash = exfat_utf8_d_hash,
205 .d_compare = exfat_utf8_d_cmp,
206 };
207
208 /* used only in search empty_slot() */
209 #define CNT_UNUSED_NOHIT (-1)
210 #define CNT_UNUSED_HIT (-2)
211 /* search EMPTY CONTINUOUS "num_entries" entries */
212 static int exfat_search_empty_slot(struct super_block *sb,
213 struct exfat_hint_femp *hint_femp, struct exfat_chain *p_dir,
214 int num_entries)
215 {
216 int i, dentry, num_empty = 0;
217 int dentries_per_clu;
218 unsigned int type;
219 struct exfat_chain clu;
220 struct exfat_dentry *ep;
221 struct exfat_sb_info *sbi = EXFAT_SB(sb);
222 struct buffer_head *bh;
223
224 dentries_per_clu = sbi->dentries_per_clu;
225
226 if (hint_femp->eidx != EXFAT_HINT_NONE) {
227 dentry = hint_femp->eidx;
228 if (num_entries <= hint_femp->count) {
229 hint_femp->eidx = EXFAT_HINT_NONE;
230 return dentry;
231 }
232
233 exfat_chain_dup(&clu, &hint_femp->cur);
234 } else {
235 exfat_chain_dup(&clu, p_dir);
236 dentry = 0;
237 }
238
239 while (clu.dir != EXFAT_EOF_CLUSTER) {
240 i = dentry & (dentries_per_clu - 1);
241
242 for (; i < dentries_per_clu; i++, dentry++) {
243 ep = exfat_get_dentry(sb, &clu, i, &bh, NULL);
244 if (!ep)
245 return -EIO;
246 type = exfat_get_entry_type(ep);
247 brelse(bh);
248
249 if (type == TYPE_UNUSED || type == TYPE_DELETED) {
250 num_empty++;
251 if (hint_femp->eidx == EXFAT_HINT_NONE) {
252 hint_femp->eidx = dentry;
253 hint_femp->count = CNT_UNUSED_NOHIT;
254 exfat_chain_set(&hint_femp->cur,
255 clu.dir, clu.size, clu.flags);
256 }
257
258 if (type == TYPE_UNUSED &&
259 hint_femp->count != CNT_UNUSED_HIT)
260 hint_femp->count = CNT_UNUSED_HIT;
261 } else {
262 if (hint_femp->eidx != EXFAT_HINT_NONE &&
263 hint_femp->count == CNT_UNUSED_HIT) {
264 /* unused empty group means
265 * an empty group which includes
266 * unused dentry
267 */
268 exfat_fs_error(sb,
269 "found bogus dentry(%d) beyond unused empty group(%d) (start_clu : %u, cur_clu : %u)",
270 dentry, hint_femp->eidx,
271 p_dir->dir, clu.dir);
272 return -EIO;
273 }
274
275 num_empty = 0;
276 hint_femp->eidx = EXFAT_HINT_NONE;
277 }
278
279 if (num_empty >= num_entries) {
280 /* found and invalidate hint_femp */
281 hint_femp->eidx = EXFAT_HINT_NONE;
282 return (dentry - (num_entries - 1));
283 }
284 }
285
286 if (clu.flags == ALLOC_NO_FAT_CHAIN) {
287 if (--clu.size > 0)
288 clu.dir++;
289 else
290 clu.dir = EXFAT_EOF_CLUSTER;
291 } else {
292 if (exfat_get_next_cluster(sb, &clu.dir))
293 return -EIO;
294 }
295 }
296
297 return -ENOSPC;
298 }
299
300 static int exfat_check_max_dentries(struct inode *inode)
301 {
302 if (EXFAT_B_TO_DEN(i_size_read(inode)) >= MAX_EXFAT_DENTRIES) {
303 /*
304 * exFAT spec allows a dir to grow upto 8388608(256MB)
305 * dentries
306 */
307 return -ENOSPC;
308 }
309 return 0;
310 }
311
312 /* find empty directory entry.
313 * if there isn't any empty slot, expand cluster chain.
314 */
315 static int exfat_find_empty_entry(struct inode *inode,
316 struct exfat_chain *p_dir, int num_entries)
317 {
318 int dentry;
319 unsigned int ret, last_clu;
320 sector_t sector;
321 loff_t size = 0;
322 struct exfat_chain clu;
323 struct exfat_dentry *ep = NULL;
324 struct super_block *sb = inode->i_sb;
325 struct exfat_sb_info *sbi = EXFAT_SB(sb);
326 struct exfat_inode_info *ei = EXFAT_I(inode);
327 struct exfat_hint_femp hint_femp;
328
329 hint_femp.eidx = EXFAT_HINT_NONE;
330
331 if (ei->hint_femp.eidx != EXFAT_HINT_NONE) {
332 memcpy(&hint_femp, &ei->hint_femp,
333 sizeof(struct exfat_hint_femp));
334 ei->hint_femp.eidx = EXFAT_HINT_NONE;
335 }
336
337 while ((dentry = exfat_search_empty_slot(sb, &hint_femp, p_dir,
338 num_entries)) < 0) {
339 if (dentry == -EIO)
340 break;
341
342 if (exfat_check_max_dentries(inode))
343 return -ENOSPC;
344
345 /* we trust p_dir->size regardless of FAT type */
346 if (exfat_find_last_cluster(sb, p_dir, &last_clu))
347 return -EIO;
348
349 /*
350 * Allocate new cluster to this directory
351 */
352 exfat_chain_set(&clu, last_clu + 1, 0, p_dir->flags);
353
354 /* allocate a cluster */
355 ret = exfat_alloc_cluster(inode, 1, &clu);
356 if (ret)
357 return ret;
358
359 if (exfat_zeroed_cluster(inode, clu.dir))
360 return -EIO;
361
362 /* append to the FAT chain */
363 if (clu.flags != p_dir->flags) {
364 /* no-fat-chain bit is disabled,
365 * so fat-chain should be synced with alloc-bitmap
366 */
367 exfat_chain_cont_cluster(sb, p_dir->dir, p_dir->size);
368 p_dir->flags = ALLOC_FAT_CHAIN;
369 hint_femp.cur.flags = ALLOC_FAT_CHAIN;
370 }
371
372 if (clu.flags == ALLOC_FAT_CHAIN)
373 if (exfat_ent_set(sb, last_clu, clu.dir))
374 return -EIO;
375
376 if (hint_femp.eidx == EXFAT_HINT_NONE) {
377 /* the special case that new dentry
378 * should be allocated from the start of new cluster
379 */
380 hint_femp.eidx = EXFAT_B_TO_DEN_IDX(p_dir->size, sbi);
381 hint_femp.count = sbi->dentries_per_clu;
382
383 exfat_chain_set(&hint_femp.cur, clu.dir, 0, clu.flags);
384 }
385 hint_femp.cur.size++;
386 p_dir->size++;
387 size = EXFAT_CLU_TO_B(p_dir->size, sbi);
388
389 /* update the directory entry */
390 if (p_dir->dir != sbi->root_dir) {
391 struct buffer_head *bh;
392
393 ep = exfat_get_dentry(sb,
394 &(ei->dir), ei->entry + 1, &bh, &sector);
395 if (!ep)
396 return -EIO;
397
398 ep->dentry.stream.valid_size = cpu_to_le64(size);
399 ep->dentry.stream.size = ep->dentry.stream.valid_size;
400 ep->dentry.stream.flags = p_dir->flags;
401 exfat_update_bh(sb, bh, IS_DIRSYNC(inode));
402 brelse(bh);
403 if (exfat_update_dir_chksum(inode, &(ei->dir),
404 ei->entry))
405 return -EIO;
406 }
407
408 /* directory inode should be updated in here */
409 i_size_write(inode, size);
410 EXFAT_I(inode)->i_size_ondisk += sbi->cluster_size;
411 EXFAT_I(inode)->i_size_aligned += sbi->cluster_size;
412 EXFAT_I(inode)->flags = p_dir->flags;
413 inode->i_blocks += 1 << sbi->sect_per_clus_bits;
414 }
415
416 return dentry;
417 }
418
419 /*
420 * Name Resolution Functions :
421 * Zero if it was successful; otherwise nonzero.
422 */
423 static int __exfat_resolve_path(struct inode *inode, const unsigned char *path,
424 struct exfat_chain *p_dir, struct exfat_uni_name *p_uniname,
425 int lookup)
426 {
427 int namelen;
428 int lossy = NLS_NAME_NO_LOSSY;
429 struct super_block *sb = inode->i_sb;
430 struct exfat_sb_info *sbi = EXFAT_SB(sb);
431 struct exfat_inode_info *ei = EXFAT_I(inode);
432
433 /* strip all trailing periods */
434 namelen = exfat_striptail_len(strlen(path), path);
435 if (!namelen)
436 return -ENOENT;
437
438 if (strlen(path) > (MAX_NAME_LENGTH * MAX_CHARSET_SIZE))
439 return -ENAMETOOLONG;
440
441 /*
442 * strip all leading spaces :
443 * "MS windows 7" supports leading spaces.
444 * So we should skip this preprocessing for compatibility.
445 */
446
447 /* file name conversion :
448 * If lookup case, we allow bad-name for compatibility.
449 */
450 namelen = exfat_nls_to_utf16(sb, path, namelen, p_uniname,
451 &lossy);
452 if (namelen < 0)
453 return namelen; /* return error value */
454
455 if ((lossy && !lookup) || !namelen)
456 return -EINVAL;
457
458 exfat_chain_set(p_dir, ei->start_clu,
459 EXFAT_B_TO_CLU(i_size_read(inode), sbi), ei->flags);
460
461 return 0;
462 }
463
464 static inline int exfat_resolve_path(struct inode *inode,
465 const unsigned char *path, struct exfat_chain *dir,
466 struct exfat_uni_name *uni)
467 {
468 return __exfat_resolve_path(inode, path, dir, uni, 0);
469 }
470
471 static inline int exfat_resolve_path_for_lookup(struct inode *inode,
472 const unsigned char *path, struct exfat_chain *dir,
473 struct exfat_uni_name *uni)
474 {
475 return __exfat_resolve_path(inode, path, dir, uni, 1);
476 }
477
478 static inline loff_t exfat_make_i_pos(struct exfat_dir_entry *info)
479 {
480 return ((loff_t) info->dir.dir << 32) | (info->entry & 0xffffffff);
481 }
482
483 static int exfat_add_entry(struct inode *inode, const char *path,
484 struct exfat_chain *p_dir, unsigned int type,
485 struct exfat_dir_entry *info)
486 {
487 int ret, dentry, num_entries;
488 struct super_block *sb = inode->i_sb;
489 struct exfat_sb_info *sbi = EXFAT_SB(sb);
490 struct exfat_uni_name uniname;
491 struct exfat_chain clu;
492 int clu_size = 0;
493 unsigned int start_clu = EXFAT_FREE_CLUSTER;
494
495 ret = exfat_resolve_path(inode, path, p_dir, &uniname);
496 if (ret)
497 goto out;
498
499 num_entries = exfat_calc_num_entries(&uniname);
500 if (num_entries < 0) {
501 ret = num_entries;
502 goto out;
503 }
504
505 /* exfat_find_empty_entry must be called before alloc_cluster() */
506 dentry = exfat_find_empty_entry(inode, p_dir, num_entries);
507 if (dentry < 0) {
508 ret = dentry; /* -EIO or -ENOSPC */
509 goto out;
510 }
511
512 if (type == TYPE_DIR) {
513 ret = exfat_alloc_new_dir(inode, &clu);
514 if (ret)
515 goto out;
516 start_clu = clu.dir;
517 clu_size = sbi->cluster_size;
518 }
519
520 /* update the directory entry */
521 /* fill the dos name directory entry information of the created file.
522 * the first cluster is not determined yet. (0)
523 */
524 ret = exfat_init_dir_entry(inode, p_dir, dentry, type,
525 start_clu, clu_size);
526 if (ret)
527 goto out;
528
529 ret = exfat_init_ext_entry(inode, p_dir, dentry, num_entries, &uniname);
530 if (ret)
531 goto out;
532
533 memcpy(&info->dir, p_dir, sizeof(struct exfat_chain));
534 info->entry = dentry;
535 info->flags = ALLOC_NO_FAT_CHAIN;
536 info->type = type;
537
538 if (type == TYPE_FILE) {
539 info->attr = ATTR_ARCHIVE;
540 info->start_clu = EXFAT_EOF_CLUSTER;
541 info->size = 0;
542 info->num_subdirs = 0;
543 } else {
544 int count;
545 struct exfat_chain cdir;
546
547 info->attr = ATTR_SUBDIR;
548 info->start_clu = start_clu;
549 info->size = clu_size;
550
551 exfat_chain_set(&cdir, info->start_clu,
552 EXFAT_B_TO_CLU(info->size, sbi), info->flags);
553 count = exfat_count_dir_entries(sb, &cdir);
554 if (count < 0)
555 return -EIO;
556 info->num_subdirs = count + EXFAT_MIN_SUBDIR;
557 }
558 memset(&info->crtime, 0, sizeof(info->crtime));
559 memset(&info->mtime, 0, sizeof(info->mtime));
560 memset(&info->atime, 0, sizeof(info->atime));
561 out:
562 return ret;
563 }
564
565 static int exfat_create(struct inode *dir, struct dentry *dentry, umode_t mode,
566 bool excl)
567 {
568 struct super_block *sb = dir->i_sb;
569 struct inode *inode;
570 struct exfat_chain cdir;
571 struct exfat_dir_entry info;
572 loff_t i_pos;
573 int err;
574
575 mutex_lock(&EXFAT_SB(sb)->s_lock);
576 exfat_set_vol_flags(sb, VOL_DIRTY);
577 err = exfat_add_entry(dir, dentry->d_name.name, &cdir, TYPE_FILE,
578 &info);
579 exfat_set_vol_flags(sb, VOL_CLEAN);
580 if (err)
581 goto unlock;
582
583 inode_inc_iversion(dir);
584 dir->i_ctime = dir->i_mtime = current_time(dir);
585 if (IS_DIRSYNC(dir))
586 exfat_sync_inode(dir);
587 else
588 mark_inode_dirty(dir);
589
590 i_pos = exfat_make_i_pos(&info);
591 inode = exfat_build_inode(sb, &info, i_pos);
592 if (IS_ERR(inode))
593 goto unlock;
594
595 inode_inc_iversion(inode);
596 inode->i_mtime = inode->i_atime = inode->i_ctime =
597 EXFAT_I(inode)->i_crtime = current_time(inode);
598 exfat_truncate_atime(&inode->i_atime);
599 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
600
601 d_instantiate(dentry, inode);
602 unlock:
603 mutex_unlock(&EXFAT_SB(sb)->s_lock);
604 return err;
605 }
606
607 /* lookup a file */
608 static int exfat_find(struct inode *dir, struct qstr *qname,
609 struct exfat_dir_entry *info)
610 {
611 int ret, dentry, num_entries, count;
612 struct exfat_chain cdir;
613 struct exfat_uni_name uni_name;
614 struct exfat_dentry *ep, *ep2;
615 struct exfat_entry_set_cache *es = NULL;
616 struct super_block *sb = dir->i_sb;
617 struct exfat_sb_info *sbi = EXFAT_SB(sb);
618 struct exfat_inode_info *ei = EXFAT_I(dir);
619
620 if (qname->len == 0)
621 return -ENOENT;
622
623 /* check the validity of directory name in the given pathname */
624 ret = exfat_resolve_path_for_lookup(dir, qname->name, &cdir, &uni_name);
625 if (ret)
626 return ret;
627
628 num_entries = exfat_calc_num_entries(&uni_name);
629 if (num_entries < 0)
630 return num_entries;
631
632 /* check the validation of hint_stat and initialize it if required */
633 if (ei->version != (inode_peek_iversion_raw(dir) & 0xffffffff)) {
634 ei->hint_stat.clu = cdir.dir;
635 ei->hint_stat.eidx = 0;
636 ei->version = (inode_peek_iversion_raw(dir) & 0xffffffff);
637 ei->hint_femp.eidx = EXFAT_HINT_NONE;
638 }
639
640 /* search the file name for directories */
641 dentry = exfat_find_dir_entry(sb, ei, &cdir, &uni_name,
642 num_entries, TYPE_ALL);
643
644 if ((dentry < 0) && (dentry != -EEXIST))
645 return dentry; /* -error value */
646
647 memcpy(&info->dir, &cdir.dir, sizeof(struct exfat_chain));
648 info->entry = dentry;
649 info->num_subdirs = 0;
650
651 /* root directory itself */
652 if (unlikely(dentry == -EEXIST)) {
653 int num_clu = 0;
654
655 info->type = TYPE_DIR;
656 info->attr = ATTR_SUBDIR;
657 info->flags = ALLOC_FAT_CHAIN;
658 info->start_clu = sbi->root_dir;
659 memset(&info->crtime, 0, sizeof(info->crtime));
660 memset(&info->mtime, 0, sizeof(info->mtime));
661 memset(&info->atime, 0, sizeof(info->atime));
662
663 exfat_chain_set(&cdir, sbi->root_dir, 0, ALLOC_FAT_CHAIN);
664 if (exfat_count_num_clusters(sb, &cdir, &num_clu))
665 return -EIO;
666 info->size = num_clu << sbi->cluster_size_bits;
667
668 count = exfat_count_dir_entries(sb, &cdir);
669 if (count < 0)
670 return -EIO;
671
672 info->num_subdirs = count;
673 } else {
674 es = exfat_get_dentry_set(sb, &cdir, dentry, ES_2_ENTRIES, &ep);
675 if (!es)
676 return -EIO;
677 ep2 = ep + 1;
678
679 info->type = exfat_get_entry_type(ep);
680 info->attr = le16_to_cpu(ep->dentry.file.attr);
681 info->size = le64_to_cpu(ep2->dentry.stream.valid_size);
682 if ((info->type == TYPE_FILE) && (info->size == 0)) {
683 info->flags = ALLOC_NO_FAT_CHAIN;
684 info->start_clu = EXFAT_EOF_CLUSTER;
685 } else {
686 info->flags = ep2->dentry.stream.flags;
687 info->start_clu =
688 le32_to_cpu(ep2->dentry.stream.start_clu);
689 }
690
691 if (ei->start_clu == EXFAT_FREE_CLUSTER) {
692 exfat_fs_error(sb,
693 "non-zero size file starts with zero cluster (size : %llu, p_dir : %u, entry : 0x%08x)",
694 i_size_read(dir), ei->dir.dir, ei->entry);
695 kfree(es);
696 return -EIO;
697 }
698
699 exfat_get_entry_time(sbi, &info->crtime,
700 ep->dentry.file.create_tz,
701 ep->dentry.file.create_time,
702 ep->dentry.file.create_date,
703 ep->dentry.file.create_time_ms);
704 exfat_get_entry_time(sbi, &info->mtime,
705 ep->dentry.file.modify_tz,
706 ep->dentry.file.modify_time,
707 ep->dentry.file.modify_date,
708 ep->dentry.file.modify_time_ms);
709 exfat_get_entry_time(sbi, &info->atime,
710 ep->dentry.file.access_tz,
711 ep->dentry.file.access_time,
712 ep->dentry.file.access_date,
713 0);
714 kfree(es);
715
716 if (info->type == TYPE_DIR) {
717 exfat_chain_set(&cdir, info->start_clu,
718 EXFAT_B_TO_CLU(info->size, sbi), info->flags);
719 count = exfat_count_dir_entries(sb, &cdir);
720 if (count < 0)
721 return -EIO;
722
723 info->num_subdirs = count + EXFAT_MIN_SUBDIR;
724 }
725 }
726 return 0;
727 }
728
729 static int exfat_d_anon_disconn(struct dentry *dentry)
730 {
731 return IS_ROOT(dentry) && (dentry->d_flags & DCACHE_DISCONNECTED);
732 }
733
734 static struct dentry *exfat_lookup(struct inode *dir, struct dentry *dentry,
735 unsigned int flags)
736 {
737 struct super_block *sb = dir->i_sb;
738 struct inode *inode;
739 struct dentry *alias;
740 struct exfat_dir_entry info;
741 int err;
742 loff_t i_pos;
743 mode_t i_mode;
744
745 mutex_lock(&EXFAT_SB(sb)->s_lock);
746 err = exfat_find(dir, &dentry->d_name, &info);
747 if (err) {
748 if (err == -ENOENT) {
749 inode = NULL;
750 goto out;
751 }
752 goto unlock;
753 }
754
755 i_pos = exfat_make_i_pos(&info);
756 inode = exfat_build_inode(sb, &info, i_pos);
757 if (IS_ERR(inode)) {
758 err = PTR_ERR(inode);
759 goto unlock;
760 }
761
762 i_mode = inode->i_mode;
763 alias = d_find_alias(inode);
764
765 /*
766 * Checking "alias->d_parent == dentry->d_parent" to make sure
767 * FS is not corrupted (especially double linked dir).
768 */
769 if (alias && alias->d_parent == dentry->d_parent &&
770 !exfat_d_anon_disconn(alias)) {
771
772 /*
773 * Unhashed alias is able to exist because of revalidate()
774 * called by lookup_fast. You can easily make this status
775 * by calling create and lookup concurrently
776 * In such case, we reuse an alias instead of new dentry
777 */
778 if (d_unhashed(alias)) {
779 WARN_ON(alias->d_name.hash_len !=
780 dentry->d_name.hash_len);
781 exfat_msg(sb, KERN_INFO,
782 "rehashed a dentry(%p) in read lookup", alias);
783 d_drop(dentry);
784 d_rehash(alias);
785 } else if (!S_ISDIR(i_mode)) {
786 /*
787 * This inode has non anonymous-DCACHE_DISCONNECTED
788 * dentry. This means, the user did ->lookup() by an
789 * another name (longname vs 8.3 alias of it) in past.
790 *
791 * Switch to new one for reason of locality if possible.
792 */
793 d_move(alias, dentry);
794 }
795 iput(inode);
796 mutex_unlock(&EXFAT_SB(sb)->s_lock);
797 return alias;
798 }
799 dput(alias);
800 out:
801 mutex_unlock(&EXFAT_SB(sb)->s_lock);
802 if (!inode)
803 exfat_d_version_set(dentry, inode_query_iversion(dir));
804
805 return d_splice_alias(inode, dentry);
806 unlock:
807 mutex_unlock(&EXFAT_SB(sb)->s_lock);
808 return ERR_PTR(err);
809 }
810
811 /* remove an entry, BUT don't truncate */
812 static int exfat_unlink(struct inode *dir, struct dentry *dentry)
813 {
814 struct exfat_chain cdir;
815 struct exfat_dentry *ep;
816 struct super_block *sb = dir->i_sb;
817 struct inode *inode = dentry->d_inode;
818 struct exfat_inode_info *ei = EXFAT_I(inode);
819 struct buffer_head *bh;
820 sector_t sector;
821 int num_entries, entry, err = 0;
822
823 mutex_lock(&EXFAT_SB(sb)->s_lock);
824 exfat_chain_dup(&cdir, &ei->dir);
825 entry = ei->entry;
826 if (ei->dir.dir == DIR_DELETED) {
827 exfat_msg(sb, KERN_ERR, "abnormal access to deleted dentry");
828 err = -ENOENT;
829 goto unlock;
830 }
831
832 ep = exfat_get_dentry(sb, &cdir, entry, &bh, &sector);
833 if (!ep) {
834 err = -EIO;
835 goto unlock;
836 }
837 num_entries = exfat_count_ext_entries(sb, &cdir, entry, ep);
838 if (num_entries < 0) {
839 err = -EIO;
840 brelse(bh);
841 goto unlock;
842 }
843 num_entries++;
844 brelse(bh);
845
846 exfat_set_vol_flags(sb, VOL_DIRTY);
847 /* update the directory entry */
848 if (exfat_remove_entries(dir, &cdir, entry, 0, num_entries)) {
849 err = -EIO;
850 goto unlock;
851 }
852
853 /* This doesn't modify ei */
854 ei->dir.dir = DIR_DELETED;
855 exfat_set_vol_flags(sb, VOL_CLEAN);
856
857 inode_inc_iversion(dir);
858 dir->i_mtime = dir->i_atime = current_time(dir);
859 exfat_truncate_atime(&dir->i_atime);
860 if (IS_DIRSYNC(dir))
861 exfat_sync_inode(dir);
862 else
863 mark_inode_dirty(dir);
864
865 clear_nlink(inode);
866 inode->i_mtime = inode->i_atime = current_time(inode);
867 exfat_truncate_atime(&inode->i_atime);
868 exfat_unhash_inode(inode);
869 exfat_d_version_set(dentry, inode_query_iversion(dir));
870 unlock:
871 mutex_unlock(&EXFAT_SB(sb)->s_lock);
872 return err;
873 }
874
875 static int exfat_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
876 {
877 struct super_block *sb = dir->i_sb;
878 struct inode *inode;
879 struct exfat_dir_entry info;
880 struct exfat_chain cdir;
881 loff_t i_pos;
882 int err;
883
884 mutex_lock(&EXFAT_SB(sb)->s_lock);
885 exfat_set_vol_flags(sb, VOL_DIRTY);
886 err = exfat_add_entry(dir, dentry->d_name.name, &cdir, TYPE_DIR,
887 &info);
888 exfat_set_vol_flags(sb, VOL_CLEAN);
889 if (err)
890 goto unlock;
891
892 inode_inc_iversion(dir);
893 dir->i_ctime = dir->i_mtime = current_time(dir);
894 if (IS_DIRSYNC(dir))
895 exfat_sync_inode(dir);
896 else
897 mark_inode_dirty(dir);
898 inc_nlink(dir);
899
900 i_pos = exfat_make_i_pos(&info);
901 inode = exfat_build_inode(sb, &info, i_pos);
902 if (IS_ERR(inode)) {
903 err = PTR_ERR(inode);
904 goto unlock;
905 }
906
907 inode_inc_iversion(inode);
908 inode->i_mtime = inode->i_atime = inode->i_ctime =
909 EXFAT_I(inode)->i_crtime = current_time(inode);
910 exfat_truncate_atime(&inode->i_atime);
911 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
912
913 d_instantiate(dentry, inode);
914
915 unlock:
916 mutex_unlock(&EXFAT_SB(sb)->s_lock);
917 return err;
918 }
919
920 static int exfat_check_dir_empty(struct super_block *sb,
921 struct exfat_chain *p_dir)
922 {
923 int i, dentries_per_clu;
924 unsigned int type;
925 struct exfat_chain clu;
926 struct exfat_dentry *ep;
927 struct exfat_sb_info *sbi = EXFAT_SB(sb);
928 struct buffer_head *bh;
929
930 dentries_per_clu = sbi->dentries_per_clu;
931
932 exfat_chain_dup(&clu, p_dir);
933
934 while (clu.dir != EXFAT_EOF_CLUSTER) {
935 for (i = 0; i < dentries_per_clu; i++) {
936 ep = exfat_get_dentry(sb, &clu, i, &bh, NULL);
937 if (!ep)
938 return -EIO;
939 type = exfat_get_entry_type(ep);
940 brelse(bh);
941 if (type == TYPE_UNUSED)
942 return 0;
943
944 if (type != TYPE_FILE && type != TYPE_DIR)
945 continue;
946
947 return -ENOTEMPTY;
948 }
949
950 if (clu.flags == ALLOC_NO_FAT_CHAIN) {
951 if (--clu.size > 0)
952 clu.dir++;
953 else
954 clu.dir = EXFAT_EOF_CLUSTER;
955 } else {
956 if (exfat_get_next_cluster(sb, &(clu.dir)))
957 return -EIO;
958 }
959 }
960
961 return 0;
962 }
963
964 static int exfat_rmdir(struct inode *dir, struct dentry *dentry)
965 {
966 struct inode *inode = dentry->d_inode;
967 struct exfat_dentry *ep;
968 struct exfat_chain cdir, clu_to_free;
969 struct super_block *sb = inode->i_sb;
970 struct exfat_sb_info *sbi = EXFAT_SB(sb);
971 struct exfat_inode_info *ei = EXFAT_I(inode);
972 struct buffer_head *bh;
973 sector_t sector;
974 int num_entries, entry, err;
975
976 mutex_lock(&EXFAT_SB(inode->i_sb)->s_lock);
977
978 exfat_chain_dup(&cdir, &ei->dir);
979 entry = ei->entry;
980
981 if (ei->dir.dir == DIR_DELETED) {
982 exfat_msg(sb, KERN_ERR, "abnormal access to deleted dentry");
983 err = -ENOENT;
984 goto unlock;
985 }
986
987 exfat_set_vol_flags(sb, VOL_DIRTY);
988 exfat_chain_set(&clu_to_free, ei->start_clu,
989 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode), sbi), ei->flags);
990
991 err = exfat_check_dir_empty(sb, &clu_to_free);
992 if (err) {
993 if (err == -EIO)
994 exfat_msg(sb, KERN_ERR,
995 "failed to exfat_check_dir_empty : err(%d)",
996 err);
997 goto unlock;
998 }
999
1000 ep = exfat_get_dentry(sb, &cdir, entry, &bh, &sector);
1001 if (!ep) {
1002 err = -EIO;
1003 goto unlock;
1004 }
1005
1006 num_entries = exfat_count_ext_entries(sb, &cdir, entry, ep);
1007 if (num_entries < 0) {
1008 err = -EIO;
1009 brelse(bh);
1010 goto unlock;
1011 }
1012 num_entries++;
1013 brelse(bh);
1014
1015 err = exfat_remove_entries(dir, &cdir, entry, 0, num_entries);
1016 if (err) {
1017 exfat_msg(sb, KERN_ERR,
1018 "failed to exfat_remove_entries : err(%d)",
1019 err);
1020 goto unlock;
1021 }
1022 ei->dir.dir = DIR_DELETED;
1023 exfat_set_vol_flags(sb, VOL_CLEAN);
1024
1025 inode_inc_iversion(dir);
1026 dir->i_mtime = dir->i_atime = current_time(dir);
1027 exfat_truncate_atime(&dir->i_atime);
1028 if (IS_DIRSYNC(dir))
1029 exfat_sync_inode(dir);
1030 else
1031 mark_inode_dirty(dir);
1032 drop_nlink(dir);
1033
1034 clear_nlink(inode);
1035 inode->i_mtime = inode->i_atime = current_time(inode);
1036 exfat_truncate_atime(&inode->i_atime);
1037 exfat_unhash_inode(inode);
1038 exfat_d_version_set(dentry, inode_query_iversion(dir));
1039 unlock:
1040 mutex_unlock(&EXFAT_SB(inode->i_sb)->s_lock);
1041 return err;
1042 }
1043
1044 static int exfat_rename_file(struct inode *inode, struct exfat_chain *p_dir,
1045 int oldentry, struct exfat_uni_name *p_uniname,
1046 struct exfat_inode_info *ei)
1047 {
1048 int ret, num_old_entries, num_new_entries;
1049 sector_t sector_old, sector_new;
1050 struct exfat_dentry *epold, *epnew;
1051 struct super_block *sb = inode->i_sb;
1052 struct buffer_head *new_bh, *old_bh;
1053 int sync = IS_DIRSYNC(inode);
1054
1055 epold = exfat_get_dentry(sb, p_dir, oldentry, &old_bh, &sector_old);
1056 if (!epold)
1057 return -EIO;
1058
1059 num_old_entries = exfat_count_ext_entries(sb, p_dir, oldentry, epold);
1060 if (num_old_entries < 0)
1061 return -EIO;
1062 num_old_entries++;
1063
1064 num_new_entries = exfat_calc_num_entries(p_uniname);
1065 if (num_new_entries < 0)
1066 return num_new_entries;
1067
1068 if (num_old_entries < num_new_entries) {
1069 int newentry;
1070
1071 newentry =
1072 exfat_find_empty_entry(inode, p_dir, num_new_entries);
1073 if (newentry < 0)
1074 return newentry; /* -EIO or -ENOSPC */
1075
1076 epnew = exfat_get_dentry(sb, p_dir, newentry, &new_bh,
1077 &sector_new);
1078 if (!epnew)
1079 return -EIO;
1080
1081 memcpy(epnew, epold, DENTRY_SIZE);
1082 if (exfat_get_entry_type(epnew) == TYPE_FILE) {
1083 epnew->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1084 ei->attr |= ATTR_ARCHIVE;
1085 }
1086 exfat_update_bh(sb, new_bh, sync);
1087 brelse(old_bh);
1088 brelse(new_bh);
1089
1090 epold = exfat_get_dentry(sb, p_dir, oldentry + 1, &old_bh,
1091 &sector_old);
1092 epnew = exfat_get_dentry(sb, p_dir, newentry + 1, &new_bh,
1093 &sector_new);
1094 if (!epold || !epnew)
1095 return -EIO;
1096
1097 memcpy(epnew, epold, DENTRY_SIZE);
1098 exfat_update_bh(sb, new_bh, sync);
1099 brelse(old_bh);
1100 brelse(new_bh);
1101
1102 ret = exfat_init_ext_entry(inode, p_dir, newentry,
1103 num_new_entries, p_uniname);
1104 if (ret)
1105 return ret;
1106
1107 exfat_remove_entries(inode, p_dir, oldentry, 0,
1108 num_old_entries);
1109 ei->entry = newentry;
1110 } else {
1111 if (exfat_get_entry_type(epold) == TYPE_FILE) {
1112 epold->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1113 ei->attr |= ATTR_ARCHIVE;
1114 }
1115 exfat_update_bh(sb, old_bh, sync);
1116 brelse(old_bh);
1117 ret = exfat_init_ext_entry(inode, p_dir, oldentry,
1118 num_new_entries, p_uniname);
1119 if (ret)
1120 return ret;
1121
1122 exfat_remove_entries(inode, p_dir, oldentry, num_new_entries,
1123 num_old_entries);
1124 }
1125 return 0;
1126 }
1127
1128 static int exfat_move_file(struct inode *inode, struct exfat_chain *p_olddir,
1129 int oldentry, struct exfat_chain *p_newdir,
1130 struct exfat_uni_name *p_uniname, struct exfat_inode_info *ei)
1131 {
1132 int ret, newentry, num_new_entries, num_old_entries;
1133 sector_t sector_mov, sector_new;
1134 struct exfat_dentry *epmov, *epnew;
1135 struct super_block *sb = inode->i_sb;
1136 struct buffer_head *mov_bh, *new_bh;
1137
1138 epmov = exfat_get_dentry(sb, p_olddir, oldentry, &mov_bh, &sector_mov);
1139 if (!epmov)
1140 return -EIO;
1141
1142 /* check if the source and target directory is the same */
1143 if (exfat_get_entry_type(epmov) == TYPE_DIR &&
1144 le32_to_cpu(epmov->dentry.stream.start_clu) == p_newdir->dir)
1145 return -EINVAL;
1146
1147 num_old_entries = exfat_count_ext_entries(sb, p_olddir, oldentry,
1148 epmov);
1149 if (num_old_entries < 0)
1150 return -EIO;
1151 num_old_entries++;
1152
1153 num_new_entries = exfat_calc_num_entries(p_uniname);
1154 if (num_new_entries < 0)
1155 return num_new_entries;
1156
1157 newentry = exfat_find_empty_entry(inode, p_newdir, num_new_entries);
1158 if (newentry < 0)
1159 return newentry; /* -EIO or -ENOSPC */
1160
1161 epnew = exfat_get_dentry(sb, p_newdir, newentry, &new_bh, &sector_new);
1162 if (!epnew)
1163 return -EIO;
1164
1165 memcpy(epnew, epmov, DENTRY_SIZE);
1166 if (exfat_get_entry_type(epnew) == TYPE_FILE) {
1167 epnew->dentry.file.attr |= cpu_to_le16(ATTR_ARCHIVE);
1168 ei->attr |= ATTR_ARCHIVE;
1169 }
1170 exfat_update_bh(sb, new_bh, IS_DIRSYNC(inode));
1171 brelse(mov_bh);
1172 brelse(new_bh);
1173
1174 epmov = exfat_get_dentry(sb, p_olddir, oldentry + 1, &mov_bh,
1175 &sector_mov);
1176 epnew = exfat_get_dentry(sb, p_newdir, newentry + 1, &new_bh,
1177 &sector_new);
1178 if (!epmov || !epnew)
1179 return -EIO;
1180
1181 memcpy(epnew, epmov, DENTRY_SIZE);
1182 exfat_update_bh(sb, new_bh, IS_DIRSYNC(inode));
1183 brelse(mov_bh);
1184 brelse(new_bh);
1185
1186 ret = exfat_init_ext_entry(inode, p_newdir, newentry, num_new_entries,
1187 p_uniname);
1188 if (ret)
1189 return ret;
1190
1191 exfat_remove_entries(inode, p_olddir, oldentry, 0, num_old_entries);
1192
1193 exfat_chain_set(&ei->dir, p_newdir->dir, p_newdir->size,
1194 p_newdir->flags);
1195
1196 ei->entry = newentry;
1197 return 0;
1198 }
1199
1200 static void exfat_update_parent_info(struct exfat_inode_info *ei,
1201 struct inode *parent_inode)
1202 {
1203 struct exfat_sb_info *sbi = EXFAT_SB(parent_inode->i_sb);
1204 struct exfat_inode_info *parent_ei = EXFAT_I(parent_inode);
1205 loff_t parent_isize = i_size_read(parent_inode);
1206
1207 /*
1208 * the problem that struct exfat_inode_info caches wrong parent info.
1209 *
1210 * because of flag-mismatch of ei->dir,
1211 * there is abnormal traversing cluster chain.
1212 */
1213 if (unlikely(parent_ei->flags != ei->dir.flags ||
1214 parent_isize != EXFAT_CLU_TO_B(ei->dir.size, sbi) ||
1215 parent_ei->start_clu != ei->dir.dir)) {
1216 exfat_chain_set(&ei->dir, parent_ei->start_clu,
1217 EXFAT_B_TO_CLU_ROUND_UP(parent_isize, sbi),
1218 parent_ei->flags);
1219 }
1220 }
1221
1222 /* rename or move a old file into a new file */
1223 static int __exfat_rename(struct inode *old_parent_inode,
1224 struct exfat_inode_info *ei, struct inode *new_parent_inode,
1225 struct dentry *new_dentry)
1226 {
1227 int ret;
1228 int dentry;
1229 struct exfat_chain olddir, newdir;
1230 struct exfat_chain *p_dir = NULL;
1231 struct exfat_uni_name uni_name;
1232 struct exfat_dentry *ep;
1233 struct super_block *sb = old_parent_inode->i_sb;
1234 struct exfat_sb_info *sbi = EXFAT_SB(sb);
1235 const unsigned char *new_path = new_dentry->d_name.name;
1236 struct inode *new_inode = new_dentry->d_inode;
1237 int num_entries;
1238 struct exfat_inode_info *new_ei = NULL;
1239 unsigned int new_entry_type = TYPE_UNUSED;
1240 int new_entry = 0;
1241 struct buffer_head *old_bh, *new_bh = NULL;
1242
1243 /* check the validity of pointer parameters */
1244 if (new_path == NULL || strlen(new_path) == 0)
1245 return -EINVAL;
1246
1247 if (ei->dir.dir == DIR_DELETED) {
1248 exfat_msg(sb, KERN_ERR,
1249 "abnormal access to deleted source dentry");
1250 return -ENOENT;
1251 }
1252
1253 exfat_update_parent_info(ei, old_parent_inode);
1254
1255 exfat_chain_dup(&olddir, &ei->dir);
1256 dentry = ei->entry;
1257
1258 ep = exfat_get_dentry(sb, &olddir, dentry, &old_bh, NULL);
1259 if (!ep) {
1260 ret = -EIO;
1261 goto out;
1262 }
1263 brelse(old_bh);
1264
1265 /* check whether new dir is existing directory and empty */
1266 if (new_inode) {
1267 ret = -EIO;
1268 new_ei = EXFAT_I(new_inode);
1269
1270 if (new_ei->dir.dir == DIR_DELETED) {
1271 exfat_msg(sb, KERN_ERR,
1272 "abnormal access to deleted target dentry");
1273 goto out;
1274 }
1275
1276 exfat_update_parent_info(new_ei, new_parent_inode);
1277
1278 p_dir = &(new_ei->dir);
1279 new_entry = new_ei->entry;
1280 ep = exfat_get_dentry(sb, p_dir, new_entry, &new_bh, NULL);
1281 if (!ep)
1282 goto out;
1283
1284 new_entry_type = exfat_get_entry_type(ep);
1285 brelse(new_bh);
1286
1287 /* if new_inode exists, update ei */
1288 if (new_entry_type == TYPE_DIR) {
1289 struct exfat_chain new_clu;
1290
1291 new_clu.dir = new_ei->start_clu;
1292 new_clu.size =
1293 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode),
1294 sbi);
1295 new_clu.flags = new_ei->flags;
1296
1297 ret = exfat_check_dir_empty(sb, &new_clu);
1298 if (ret)
1299 goto out;
1300 }
1301 }
1302
1303 /* check the validity of directory name in the given new pathname */
1304 ret = exfat_resolve_path(new_parent_inode, new_path, &newdir,
1305 &uni_name);
1306 if (ret)
1307 goto out;
1308
1309 exfat_set_vol_flags(sb, VOL_DIRTY);
1310
1311 if (olddir.dir == newdir.dir)
1312 ret = exfat_rename_file(new_parent_inode, &olddir, dentry,
1313 &uni_name, ei);
1314 else
1315 ret = exfat_move_file(new_parent_inode, &olddir, dentry,
1316 &newdir, &uni_name, ei);
1317
1318 if (!ret && new_inode) {
1319 /* delete entries of new_dir */
1320 ep = exfat_get_dentry(sb, p_dir, new_entry, &new_bh, NULL);
1321 if (!ep) {
1322 ret = -EIO;
1323 goto del_out;
1324 }
1325
1326 num_entries = exfat_count_ext_entries(sb, p_dir, new_entry, ep);
1327 if (num_entries < 0) {
1328 ret = -EIO;
1329 goto del_out;
1330 }
1331 brelse(new_bh);
1332
1333 if (exfat_remove_entries(new_inode, p_dir, new_entry, 0,
1334 num_entries + 1)) {
1335 ret = -EIO;
1336 goto del_out;
1337 }
1338
1339 /* Free the clusters if new_inode is a dir(as if exfat_rmdir) */
1340 if (new_entry_type == TYPE_DIR) {
1341 /* new_ei, new_clu_to_free */
1342 struct exfat_chain new_clu_to_free;
1343
1344 exfat_chain_set(&new_clu_to_free, new_ei->start_clu,
1345 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode),
1346 sbi), new_ei->flags);
1347
1348 if (exfat_free_cluster(new_inode, &new_clu_to_free)) {
1349 /* just set I/O error only */
1350 ret = -EIO;
1351 }
1352
1353 i_size_write(new_inode, 0);
1354 new_ei->start_clu = EXFAT_EOF_CLUSTER;
1355 new_ei->flags = ALLOC_NO_FAT_CHAIN;
1356 }
1357 del_out:
1358 /* Update new_inode ei
1359 * Prevent syncing removed new_inode
1360 * (new_ei is already initialized above code ("if (new_inode)")
1361 */
1362 new_ei->dir.dir = DIR_DELETED;
1363 }
1364 exfat_set_vol_flags(sb, VOL_CLEAN);
1365 out:
1366 return ret;
1367 }
1368
1369 static int exfat_rename(struct inode *old_dir, struct dentry *old_dentry,
1370 struct inode *new_dir, struct dentry *new_dentry,
1371 unsigned int flags)
1372 {
1373 struct inode *old_inode, *new_inode;
1374 struct super_block *sb = old_dir->i_sb;
1375 loff_t i_pos;
1376 int err;
1377
1378 /*
1379 * The VFS already checks for existence, so for local filesystems
1380 * the RENAME_NOREPLACE implementation is equivalent to plain rename.
1381 * Don't support any other flags
1382 */
1383 if (flags & ~RENAME_NOREPLACE)
1384 return -EINVAL;
1385
1386 mutex_lock(&EXFAT_SB(sb)->s_lock);
1387 old_inode = old_dentry->d_inode;
1388 new_inode = new_dentry->d_inode;
1389
1390 err = __exfat_rename(old_dir, EXFAT_I(old_inode), new_dir, new_dentry);
1391 if (err)
1392 goto unlock;
1393
1394 inode_inc_iversion(new_dir);
1395 new_dir->i_ctime = new_dir->i_mtime = new_dir->i_atime =
1396 EXFAT_I(new_dir)->i_crtime = current_time(new_dir);
1397 exfat_truncate_atime(&new_dir->i_atime);
1398 if (IS_DIRSYNC(new_dir))
1399 exfat_sync_inode(new_dir);
1400 else
1401 mark_inode_dirty(new_dir);
1402
1403 i_pos = ((loff_t)EXFAT_I(old_inode)->dir.dir << 32) |
1404 (EXFAT_I(old_inode)->entry & 0xffffffff);
1405 exfat_unhash_inode(old_inode);
1406 exfat_hash_inode(old_inode, i_pos);
1407 if (IS_DIRSYNC(new_dir))
1408 exfat_sync_inode(old_inode);
1409 else
1410 mark_inode_dirty(old_inode);
1411
1412 if (S_ISDIR(old_inode->i_mode) && old_dir != new_dir) {
1413 drop_nlink(old_dir);
1414 if (!new_inode)
1415 inc_nlink(new_dir);
1416 }
1417
1418 inode_inc_iversion(old_dir);
1419 old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
1420 if (IS_DIRSYNC(old_dir))
1421 exfat_sync_inode(old_dir);
1422 else
1423 mark_inode_dirty(old_dir);
1424
1425 if (new_inode) {
1426 exfat_unhash_inode(new_inode);
1427
1428 /* skip drop_nlink if new_inode already has been dropped */
1429 if (new_inode->i_nlink) {
1430 drop_nlink(new_inode);
1431 if (S_ISDIR(new_inode->i_mode))
1432 drop_nlink(new_inode);
1433 } else {
1434 exfat_msg(sb, KERN_WARNING,
1435 "abnormal access to an inode dropped");
1436 WARN_ON(new_inode->i_nlink == 0);
1437 }
1438 new_inode->i_ctime = EXFAT_I(new_inode)->i_crtime =
1439 current_time(new_inode);
1440 }
1441
1442 unlock:
1443 mutex_unlock(&EXFAT_SB(sb)->s_lock);
1444 return err;
1445 }
1446
1447 const struct inode_operations exfat_dir_inode_operations = {
1448 .create = exfat_create,
1449 .lookup = exfat_lookup,
1450 .unlink = exfat_unlink,
1451 .mkdir = exfat_mkdir,
1452 .rmdir = exfat_rmdir,
1453 .rename = exfat_rename,
1454 .setattr = exfat_setattr,
1455 .getattr = exfat_getattr,
1456 };
A mirror of Linus' kernel repository