1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
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>
12 #include "exfat_raw.h"
15 static inline unsigned long exfat_d_version(struct dentry
*dentry
)
17 return (unsigned long) dentry
->d_fsdata
;
20 static inline void exfat_d_version_set(struct dentry
*dentry
,
21 unsigned long version
)
23 dentry
->d_fsdata
= (void *) version
;
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.
31 * If it happened, the negative dentry isn't actually negative anymore. So,
34 static int exfat_d_revalidate(struct dentry
*dentry
, unsigned int flags
)
38 if (flags
& LOOKUP_RCU
)
42 * This is not negative dentry. Always valid.
44 * Note, rename() to existing directory entry will have ->d_inode, and
45 * will use existing name which isn't specified name by user.
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.
51 if (d_really_is_positive(dentry
))
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.
58 if (flags
& (LOOKUP_CREATE
| LOOKUP_RENAME_TARGET
))
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
);
68 /* returns the length of a struct qstr, ignoring trailing dots */
69 static unsigned int exfat_striptail_len(unsigned int len
, const char *name
)
71 while (len
&& name
[len
- 1] == '.')
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.
81 static int exfat_d_hash(const struct dentry
*dentry
, struct qstr
*qstr
)
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
);
91 for (i
= 0; i
< len
; i
+= charlen
) {
92 charlen
= t
->char2uni(&name
[i
], len
- i
, &c
);
95 hash
= partial_name_hash(exfat_toupper(sb
, c
), hash
);
98 qstr
->hash
= end_name_hash(hash
);
102 static int exfat_d_cmp(const struct dentry
*dentry
, unsigned int len
,
103 const char *str
, const struct qstr
*name
)
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
);
115 for (i
= 0; i
< len
; i
+= charlen
) {
116 charlen
= t
->char2uni(&name
->name
[i
], alen
- i
, &c1
);
119 if (charlen
!= t
->char2uni(&str
[i
], blen
- i
, &c2
))
122 if (exfat_toupper(sb
, c1
) != exfat_toupper(sb
, c2
))
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
,
135 static int exfat_utf8_d_hash(const struct dentry
*dentry
, struct qstr
*qstr
)
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
);
144 for (i
= 0; i
< len
; i
+= charlen
) {
145 charlen
= utf8_to_utf32(&name
[i
], len
- i
, &u
);
150 * exfat_toupper() works only for code points up to the U+FFFF.
152 hash
= partial_name_hash(u
<= 0xFFFF ? exfat_toupper(sb
, u
) : u
,
156 qstr
->hash
= end_name_hash(hash
);
160 static int exfat_utf8_d_cmp(const struct dentry
*dentry
, unsigned int len
,
161 const char *str
, const struct qstr
*name
)
163 struct super_block
*sb
= dentry
->d_sb
;
164 unsigned int alen
= exfat_striptail_len(name
->len
, name
->name
);
165 unsigned int blen
= exfat_striptail_len(len
, str
);
172 for (i
= 0; i
< alen
; i
+= charlen
) {
173 charlen
= utf8_to_utf32(&name
->name
[i
], alen
- i
, &u_a
);
176 if (charlen
!= utf8_to_utf32(&str
[i
], blen
- i
, &u_b
))
179 if (u_a
<= 0xFFFF && u_b
<= 0xFFFF) {
180 if (exfat_toupper(sb
, u_a
) != exfat_toupper(sb
, u_b
))
191 const struct dentry_operations exfat_utf8_dentry_ops
= {
192 .d_revalidate
= exfat_d_revalidate
,
193 .d_hash
= exfat_utf8_d_hash
,
194 .d_compare
= exfat_utf8_d_cmp
,
197 /* used only in search empty_slot() */
198 #define CNT_UNUSED_NOHIT (-1)
199 #define CNT_UNUSED_HIT (-2)
200 /* search EMPTY CONTINUOUS "num_entries" entries */
201 static int exfat_search_empty_slot(struct super_block
*sb
,
202 struct exfat_hint_femp
*hint_femp
, struct exfat_chain
*p_dir
,
205 int i
, dentry
, num_empty
= 0;
206 int dentries_per_clu
;
208 struct exfat_chain clu
;
209 struct exfat_dentry
*ep
;
210 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
211 struct buffer_head
*bh
;
213 dentries_per_clu
= sbi
->dentries_per_clu
;
215 if (hint_femp
->eidx
!= EXFAT_HINT_NONE
) {
216 dentry
= hint_femp
->eidx
;
217 if (num_entries
<= hint_femp
->count
) {
218 hint_femp
->eidx
= EXFAT_HINT_NONE
;
222 exfat_chain_dup(&clu
, &hint_femp
->cur
);
224 exfat_chain_dup(&clu
, p_dir
);
228 while (clu
.dir
!= EXFAT_EOF_CLUSTER
) {
229 i
= dentry
& (dentries_per_clu
- 1);
231 for (; i
< dentries_per_clu
; i
++, dentry
++) {
232 ep
= exfat_get_dentry(sb
, &clu
, i
, &bh
, NULL
);
235 type
= exfat_get_entry_type(ep
);
238 if (type
== TYPE_UNUSED
|| type
== TYPE_DELETED
) {
240 if (hint_femp
->eidx
== EXFAT_HINT_NONE
) {
241 hint_femp
->eidx
= dentry
;
242 hint_femp
->count
= CNT_UNUSED_NOHIT
;
243 exfat_chain_set(&hint_femp
->cur
,
244 clu
.dir
, clu
.size
, clu
.flags
);
247 if (type
== TYPE_UNUSED
&&
248 hint_femp
->count
!= CNT_UNUSED_HIT
)
249 hint_femp
->count
= CNT_UNUSED_HIT
;
251 if (hint_femp
->eidx
!= EXFAT_HINT_NONE
&&
252 hint_femp
->count
== CNT_UNUSED_HIT
) {
253 /* unused empty group means
254 * an empty group which includes
258 "found bogus dentry(%d) beyond unused empty group(%d) (start_clu : %u, cur_clu : %u)",
259 dentry
, hint_femp
->eidx
,
260 p_dir
->dir
, clu
.dir
);
265 hint_femp
->eidx
= EXFAT_HINT_NONE
;
268 if (num_empty
>= num_entries
) {
269 /* found and invalidate hint_femp */
270 hint_femp
->eidx
= EXFAT_HINT_NONE
;
271 return (dentry
- (num_entries
- 1));
275 if (clu
.flags
== ALLOC_NO_FAT_CHAIN
) {
279 clu
.dir
= EXFAT_EOF_CLUSTER
;
281 if (exfat_get_next_cluster(sb
, &clu
.dir
))
289 static int exfat_check_max_dentries(struct inode
*inode
)
291 if (EXFAT_B_TO_DEN(i_size_read(inode
)) >= MAX_EXFAT_DENTRIES
) {
293 * exFAT spec allows a dir to grow upto 8388608(256MB)
301 /* find empty directory entry.
302 * if there isn't any empty slot, expand cluster chain.
304 static int exfat_find_empty_entry(struct inode
*inode
,
305 struct exfat_chain
*p_dir
, int num_entries
)
308 unsigned int ret
, last_clu
;
311 struct exfat_chain clu
;
312 struct exfat_dentry
*ep
= NULL
;
313 struct super_block
*sb
= inode
->i_sb
;
314 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
315 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
316 struct exfat_hint_femp hint_femp
;
318 hint_femp
.eidx
= EXFAT_HINT_NONE
;
320 if (ei
->hint_femp
.eidx
!= EXFAT_HINT_NONE
) {
321 memcpy(&hint_femp
, &ei
->hint_femp
,
322 sizeof(struct exfat_hint_femp
));
323 ei
->hint_femp
.eidx
= EXFAT_HINT_NONE
;
326 while ((dentry
= exfat_search_empty_slot(sb
, &hint_femp
, p_dir
,
331 if (exfat_check_max_dentries(inode
))
334 /* we trust p_dir->size regardless of FAT type */
335 if (exfat_find_last_cluster(sb
, p_dir
, &last_clu
))
339 * Allocate new cluster to this directory
341 exfat_chain_set(&clu
, last_clu
+ 1, 0, p_dir
->flags
);
343 /* allocate a cluster */
344 ret
= exfat_alloc_cluster(inode
, 1, &clu
);
348 if (exfat_zeroed_cluster(inode
, clu
.dir
))
351 /* append to the FAT chain */
352 if (clu
.flags
!= p_dir
->flags
) {
353 /* no-fat-chain bit is disabled,
354 * so fat-chain should be synced with alloc-bitmap
356 exfat_chain_cont_cluster(sb
, p_dir
->dir
, p_dir
->size
);
357 p_dir
->flags
= ALLOC_FAT_CHAIN
;
358 hint_femp
.cur
.flags
= ALLOC_FAT_CHAIN
;
361 if (clu
.flags
== ALLOC_FAT_CHAIN
)
362 if (exfat_ent_set(sb
, last_clu
, clu
.dir
))
365 if (hint_femp
.eidx
== EXFAT_HINT_NONE
) {
366 /* the special case that new dentry
367 * should be allocated from the start of new cluster
369 hint_femp
.eidx
= EXFAT_B_TO_DEN_IDX(p_dir
->size
, sbi
);
370 hint_femp
.count
= sbi
->dentries_per_clu
;
372 exfat_chain_set(&hint_femp
.cur
, clu
.dir
, 0, clu
.flags
);
374 hint_femp
.cur
.size
++;
376 size
= EXFAT_CLU_TO_B(p_dir
->size
, sbi
);
378 /* update the directory entry */
379 if (p_dir
->dir
!= sbi
->root_dir
) {
380 struct buffer_head
*bh
;
382 ep
= exfat_get_dentry(sb
,
383 &(ei
->dir
), ei
->entry
+ 1, &bh
, §or
);
387 ep
->dentry
.stream
.valid_size
= cpu_to_le64(size
);
388 ep
->dentry
.stream
.size
= ep
->dentry
.stream
.valid_size
;
389 ep
->dentry
.stream
.flags
= p_dir
->flags
;
390 exfat_update_bh(bh
, IS_DIRSYNC(inode
));
392 if (exfat_update_dir_chksum(inode
, &(ei
->dir
),
397 /* directory inode should be updated in here */
398 i_size_write(inode
, size
);
399 EXFAT_I(inode
)->i_size_ondisk
+= sbi
->cluster_size
;
400 EXFAT_I(inode
)->i_size_aligned
+= sbi
->cluster_size
;
401 EXFAT_I(inode
)->flags
= p_dir
->flags
;
402 inode
->i_blocks
+= 1 << sbi
->sect_per_clus_bits
;
409 * Name Resolution Functions :
410 * Zero if it was successful; otherwise nonzero.
412 static int __exfat_resolve_path(struct inode
*inode
, const unsigned char *path
,
413 struct exfat_chain
*p_dir
, struct exfat_uni_name
*p_uniname
,
417 int lossy
= NLS_NAME_NO_LOSSY
;
418 struct super_block
*sb
= inode
->i_sb
;
419 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
420 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
422 /* strip all trailing periods */
423 namelen
= exfat_striptail_len(strlen(path
), path
);
427 if (strlen(path
) > (MAX_NAME_LENGTH
* MAX_CHARSET_SIZE
))
428 return -ENAMETOOLONG
;
431 * strip all leading spaces :
432 * "MS windows 7" supports leading spaces.
433 * So we should skip this preprocessing for compatibility.
436 /* file name conversion :
437 * If lookup case, we allow bad-name for compatibility.
439 namelen
= exfat_nls_to_utf16(sb
, path
, namelen
, p_uniname
,
442 return namelen
; /* return error value */
444 if ((lossy
&& !lookup
) || !namelen
)
447 exfat_chain_set(p_dir
, ei
->start_clu
,
448 EXFAT_B_TO_CLU(i_size_read(inode
), sbi
), ei
->flags
);
453 static inline int exfat_resolve_path(struct inode
*inode
,
454 const unsigned char *path
, struct exfat_chain
*dir
,
455 struct exfat_uni_name
*uni
)
457 return __exfat_resolve_path(inode
, path
, dir
, uni
, 0);
460 static inline int exfat_resolve_path_for_lookup(struct inode
*inode
,
461 const unsigned char *path
, struct exfat_chain
*dir
,
462 struct exfat_uni_name
*uni
)
464 return __exfat_resolve_path(inode
, path
, dir
, uni
, 1);
467 static inline loff_t
exfat_make_i_pos(struct exfat_dir_entry
*info
)
469 return ((loff_t
) info
->dir
.dir
<< 32) | (info
->entry
& 0xffffffff);
472 static int exfat_add_entry(struct inode
*inode
, const char *path
,
473 struct exfat_chain
*p_dir
, unsigned int type
,
474 struct exfat_dir_entry
*info
)
476 int ret
, dentry
, num_entries
;
477 struct super_block
*sb
= inode
->i_sb
;
478 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
479 struct exfat_uni_name uniname
;
480 struct exfat_chain clu
;
482 unsigned int start_clu
= EXFAT_FREE_CLUSTER
;
484 ret
= exfat_resolve_path(inode
, path
, p_dir
, &uniname
);
488 num_entries
= exfat_calc_num_entries(&uniname
);
489 if (num_entries
< 0) {
494 /* exfat_find_empty_entry must be called before alloc_cluster() */
495 dentry
= exfat_find_empty_entry(inode
, p_dir
, num_entries
);
497 ret
= dentry
; /* -EIO or -ENOSPC */
501 if (type
== TYPE_DIR
) {
502 ret
= exfat_alloc_new_dir(inode
, &clu
);
506 clu_size
= sbi
->cluster_size
;
509 /* update the directory entry */
510 /* fill the dos name directory entry information of the created file.
511 * the first cluster is not determined yet. (0)
513 ret
= exfat_init_dir_entry(inode
, p_dir
, dentry
, type
,
514 start_clu
, clu_size
);
518 ret
= exfat_init_ext_entry(inode
, p_dir
, dentry
, num_entries
, &uniname
);
522 memcpy(&info
->dir
, p_dir
, sizeof(struct exfat_chain
));
523 info
->entry
= dentry
;
524 info
->flags
= ALLOC_NO_FAT_CHAIN
;
527 if (type
== TYPE_FILE
) {
528 info
->attr
= ATTR_ARCHIVE
;
529 info
->start_clu
= EXFAT_EOF_CLUSTER
;
531 info
->num_subdirs
= 0;
534 struct exfat_chain cdir
;
536 info
->attr
= ATTR_SUBDIR
;
537 info
->start_clu
= start_clu
;
538 info
->size
= clu_size
;
540 exfat_chain_set(&cdir
, info
->start_clu
,
541 EXFAT_B_TO_CLU(info
->size
, sbi
), info
->flags
);
542 count
= exfat_count_dir_entries(sb
, &cdir
);
545 info
->num_subdirs
= count
+ EXFAT_MIN_SUBDIR
;
547 memset(&info
->crtime
, 0, sizeof(info
->crtime
));
548 memset(&info
->mtime
, 0, sizeof(info
->mtime
));
549 memset(&info
->atime
, 0, sizeof(info
->atime
));
554 static int exfat_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
557 struct super_block
*sb
= dir
->i_sb
;
559 struct exfat_chain cdir
;
560 struct exfat_dir_entry info
;
564 mutex_lock(&EXFAT_SB(sb
)->s_lock
);
565 exfat_set_volume_dirty(sb
);
566 err
= exfat_add_entry(dir
, dentry
->d_name
.name
, &cdir
, TYPE_FILE
,
568 exfat_clear_volume_dirty(sb
);
572 inode_inc_iversion(dir
);
573 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
575 exfat_sync_inode(dir
);
577 mark_inode_dirty(dir
);
579 i_pos
= exfat_make_i_pos(&info
);
580 inode
= exfat_build_inode(sb
, &info
, i_pos
);
581 err
= PTR_ERR_OR_ZERO(inode
);
585 inode_inc_iversion(inode
);
586 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
=
587 EXFAT_I(inode
)->i_crtime
= current_time(inode
);
588 exfat_truncate_atime(&inode
->i_atime
);
589 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
591 d_instantiate(dentry
, inode
);
593 mutex_unlock(&EXFAT_SB(sb
)->s_lock
);
598 static int exfat_find(struct inode
*dir
, struct qstr
*qname
,
599 struct exfat_dir_entry
*info
)
601 int ret
, dentry
, num_entries
, count
;
602 struct exfat_chain cdir
;
603 struct exfat_uni_name uni_name
;
604 struct super_block
*sb
= dir
->i_sb
;
605 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
606 struct exfat_inode_info
*ei
= EXFAT_I(dir
);
611 /* check the validity of directory name in the given pathname */
612 ret
= exfat_resolve_path_for_lookup(dir
, qname
->name
, &cdir
, &uni_name
);
616 num_entries
= exfat_calc_num_entries(&uni_name
);
620 /* check the validation of hint_stat and initialize it if required */
621 if (ei
->version
!= (inode_peek_iversion_raw(dir
) & 0xffffffff)) {
622 ei
->hint_stat
.clu
= cdir
.dir
;
623 ei
->hint_stat
.eidx
= 0;
624 ei
->version
= (inode_peek_iversion_raw(dir
) & 0xffffffff);
625 ei
->hint_femp
.eidx
= EXFAT_HINT_NONE
;
628 /* search the file name for directories */
629 dentry
= exfat_find_dir_entry(sb
, ei
, &cdir
, &uni_name
,
630 num_entries
, TYPE_ALL
);
632 if ((dentry
< 0) && (dentry
!= -EEXIST
))
633 return dentry
; /* -error value */
635 memcpy(&info
->dir
, &cdir
.dir
, sizeof(struct exfat_chain
));
636 info
->entry
= dentry
;
637 info
->num_subdirs
= 0;
639 /* root directory itself */
640 if (unlikely(dentry
== -EEXIST
)) {
643 info
->type
= TYPE_DIR
;
644 info
->attr
= ATTR_SUBDIR
;
645 info
->flags
= ALLOC_FAT_CHAIN
;
646 info
->start_clu
= sbi
->root_dir
;
647 memset(&info
->crtime
, 0, sizeof(info
->crtime
));
648 memset(&info
->mtime
, 0, sizeof(info
->mtime
));
649 memset(&info
->atime
, 0, sizeof(info
->atime
));
651 exfat_chain_set(&cdir
, sbi
->root_dir
, 0, ALLOC_FAT_CHAIN
);
652 if (exfat_count_num_clusters(sb
, &cdir
, &num_clu
))
654 info
->size
= num_clu
<< sbi
->cluster_size_bits
;
656 count
= exfat_count_dir_entries(sb
, &cdir
);
660 info
->num_subdirs
= count
;
662 struct exfat_dentry
*ep
, *ep2
;
663 struct exfat_entry_set_cache
*es
;
665 es
= exfat_get_dentry_set(sb
, &cdir
, dentry
, ES_2_ENTRIES
);
668 ep
= exfat_get_dentry_cached(es
, 0);
669 ep2
= exfat_get_dentry_cached(es
, 1);
671 info
->type
= exfat_get_entry_type(ep
);
672 info
->attr
= le16_to_cpu(ep
->dentry
.file
.attr
);
673 info
->size
= le64_to_cpu(ep2
->dentry
.stream
.valid_size
);
674 if ((info
->type
== TYPE_FILE
) && (info
->size
== 0)) {
675 info
->flags
= ALLOC_NO_FAT_CHAIN
;
676 info
->start_clu
= EXFAT_EOF_CLUSTER
;
678 info
->flags
= ep2
->dentry
.stream
.flags
;
680 le32_to_cpu(ep2
->dentry
.stream
.start_clu
);
683 if (ei
->start_clu
== EXFAT_FREE_CLUSTER
) {
685 "non-zero size file starts with zero cluster (size : %llu, p_dir : %u, entry : 0x%08x)",
686 i_size_read(dir
), ei
->dir
.dir
, ei
->entry
);
687 exfat_free_dentry_set(es
, false);
691 exfat_get_entry_time(sbi
, &info
->crtime
,
692 ep
->dentry
.file
.create_tz
,
693 ep
->dentry
.file
.create_time
,
694 ep
->dentry
.file
.create_date
,
695 ep
->dentry
.file
.create_time_cs
);
696 exfat_get_entry_time(sbi
, &info
->mtime
,
697 ep
->dentry
.file
.modify_tz
,
698 ep
->dentry
.file
.modify_time
,
699 ep
->dentry
.file
.modify_date
,
700 ep
->dentry
.file
.modify_time_cs
);
701 exfat_get_entry_time(sbi
, &info
->atime
,
702 ep
->dentry
.file
.access_tz
,
703 ep
->dentry
.file
.access_time
,
704 ep
->dentry
.file
.access_date
,
706 exfat_free_dentry_set(es
, false);
708 if (info
->type
== TYPE_DIR
) {
709 exfat_chain_set(&cdir
, info
->start_clu
,
710 EXFAT_B_TO_CLU(info
->size
, sbi
), info
->flags
);
711 count
= exfat_count_dir_entries(sb
, &cdir
);
715 info
->num_subdirs
= count
+ EXFAT_MIN_SUBDIR
;
721 static int exfat_d_anon_disconn(struct dentry
*dentry
)
723 return IS_ROOT(dentry
) && (dentry
->d_flags
& DCACHE_DISCONNECTED
);
726 static struct dentry
*exfat_lookup(struct inode
*dir
, struct dentry
*dentry
,
729 struct super_block
*sb
= dir
->i_sb
;
731 struct dentry
*alias
;
732 struct exfat_dir_entry info
;
737 mutex_lock(&EXFAT_SB(sb
)->s_lock
);
738 err
= exfat_find(dir
, &dentry
->d_name
, &info
);
740 if (err
== -ENOENT
) {
747 i_pos
= exfat_make_i_pos(&info
);
748 inode
= exfat_build_inode(sb
, &info
, i_pos
);
749 err
= PTR_ERR_OR_ZERO(inode
);
753 i_mode
= inode
->i_mode
;
754 alias
= d_find_alias(inode
);
757 * Checking "alias->d_parent == dentry->d_parent" to make sure
758 * FS is not corrupted (especially double linked dir).
760 if (alias
&& alias
->d_parent
== dentry
->d_parent
&&
761 !exfat_d_anon_disconn(alias
)) {
764 * Unhashed alias is able to exist because of revalidate()
765 * called by lookup_fast. You can easily make this status
766 * by calling create and lookup concurrently
767 * In such case, we reuse an alias instead of new dentry
769 if (d_unhashed(alias
)) {
770 WARN_ON(alias
->d_name
.hash_len
!=
771 dentry
->d_name
.hash_len
);
772 exfat_info(sb
, "rehashed a dentry(%p) in read lookup",
776 } else if (!S_ISDIR(i_mode
)) {
778 * This inode has non anonymous-DCACHE_DISCONNECTED
779 * dentry. This means, the user did ->lookup() by an
780 * another name (longname vs 8.3 alias of it) in past.
782 * Switch to new one for reason of locality if possible.
784 d_move(alias
, dentry
);
787 mutex_unlock(&EXFAT_SB(sb
)->s_lock
);
792 mutex_unlock(&EXFAT_SB(sb
)->s_lock
);
794 exfat_d_version_set(dentry
, inode_query_iversion(dir
));
796 return d_splice_alias(inode
, dentry
);
798 mutex_unlock(&EXFAT_SB(sb
)->s_lock
);
802 /* remove an entry, BUT don't truncate */
803 static int exfat_unlink(struct inode
*dir
, struct dentry
*dentry
)
805 struct exfat_chain cdir
;
806 struct exfat_dentry
*ep
;
807 struct super_block
*sb
= dir
->i_sb
;
808 struct inode
*inode
= dentry
->d_inode
;
809 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
810 struct buffer_head
*bh
;
812 int num_entries
, entry
, err
= 0;
814 mutex_lock(&EXFAT_SB(sb
)->s_lock
);
815 exfat_chain_dup(&cdir
, &ei
->dir
);
817 if (ei
->dir
.dir
== DIR_DELETED
) {
818 exfat_err(sb
, "abnormal access to deleted dentry");
823 ep
= exfat_get_dentry(sb
, &cdir
, entry
, &bh
, §or
);
828 num_entries
= exfat_count_ext_entries(sb
, &cdir
, entry
, ep
);
829 if (num_entries
< 0) {
837 exfat_set_volume_dirty(sb
);
838 /* update the directory entry */
839 if (exfat_remove_entries(dir
, &cdir
, entry
, 0, num_entries
)) {
844 /* This doesn't modify ei */
845 ei
->dir
.dir
= DIR_DELETED
;
846 exfat_clear_volume_dirty(sb
);
848 inode_inc_iversion(dir
);
849 dir
->i_mtime
= dir
->i_atime
= current_time(dir
);
850 exfat_truncate_atime(&dir
->i_atime
);
852 exfat_sync_inode(dir
);
854 mark_inode_dirty(dir
);
857 inode
->i_mtime
= inode
->i_atime
= current_time(inode
);
858 exfat_truncate_atime(&inode
->i_atime
);
859 exfat_unhash_inode(inode
);
860 exfat_d_version_set(dentry
, inode_query_iversion(dir
));
862 mutex_unlock(&EXFAT_SB(sb
)->s_lock
);
866 static int exfat_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
868 struct super_block
*sb
= dir
->i_sb
;
870 struct exfat_dir_entry info
;
871 struct exfat_chain cdir
;
875 mutex_lock(&EXFAT_SB(sb
)->s_lock
);
876 exfat_set_volume_dirty(sb
);
877 err
= exfat_add_entry(dir
, dentry
->d_name
.name
, &cdir
, TYPE_DIR
,
879 exfat_clear_volume_dirty(sb
);
883 inode_inc_iversion(dir
);
884 dir
->i_ctime
= dir
->i_mtime
= current_time(dir
);
886 exfat_sync_inode(dir
);
888 mark_inode_dirty(dir
);
891 i_pos
= exfat_make_i_pos(&info
);
892 inode
= exfat_build_inode(sb
, &info
, i_pos
);
893 err
= PTR_ERR_OR_ZERO(inode
);
897 inode_inc_iversion(inode
);
898 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
=
899 EXFAT_I(inode
)->i_crtime
= current_time(inode
);
900 exfat_truncate_atime(&inode
->i_atime
);
901 /* timestamp is already written, so mark_inode_dirty() is unneeded. */
903 d_instantiate(dentry
, inode
);
906 mutex_unlock(&EXFAT_SB(sb
)->s_lock
);
910 static int exfat_check_dir_empty(struct super_block
*sb
,
911 struct exfat_chain
*p_dir
)
913 int i
, dentries_per_clu
;
915 struct exfat_chain clu
;
916 struct exfat_dentry
*ep
;
917 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
918 struct buffer_head
*bh
;
920 dentries_per_clu
= sbi
->dentries_per_clu
;
922 exfat_chain_dup(&clu
, p_dir
);
924 while (clu
.dir
!= EXFAT_EOF_CLUSTER
) {
925 for (i
= 0; i
< dentries_per_clu
; i
++) {
926 ep
= exfat_get_dentry(sb
, &clu
, i
, &bh
, NULL
);
929 type
= exfat_get_entry_type(ep
);
931 if (type
== TYPE_UNUSED
)
934 if (type
!= TYPE_FILE
&& type
!= TYPE_DIR
)
940 if (clu
.flags
== ALLOC_NO_FAT_CHAIN
) {
944 clu
.dir
= EXFAT_EOF_CLUSTER
;
946 if (exfat_get_next_cluster(sb
, &(clu
.dir
)))
954 static int exfat_rmdir(struct inode
*dir
, struct dentry
*dentry
)
956 struct inode
*inode
= dentry
->d_inode
;
957 struct exfat_dentry
*ep
;
958 struct exfat_chain cdir
, clu_to_free
;
959 struct super_block
*sb
= inode
->i_sb
;
960 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
961 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
962 struct buffer_head
*bh
;
964 int num_entries
, entry
, err
;
966 mutex_lock(&EXFAT_SB(inode
->i_sb
)->s_lock
);
968 exfat_chain_dup(&cdir
, &ei
->dir
);
971 if (ei
->dir
.dir
== DIR_DELETED
) {
972 exfat_err(sb
, "abnormal access to deleted dentry");
977 exfat_chain_set(&clu_to_free
, ei
->start_clu
,
978 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode
), sbi
), ei
->flags
);
980 err
= exfat_check_dir_empty(sb
, &clu_to_free
);
983 exfat_err(sb
, "failed to exfat_check_dir_empty : err(%d)",
988 ep
= exfat_get_dentry(sb
, &cdir
, entry
, &bh
, §or
);
994 num_entries
= exfat_count_ext_entries(sb
, &cdir
, entry
, ep
);
995 if (num_entries
< 0) {
1003 exfat_set_volume_dirty(sb
);
1004 err
= exfat_remove_entries(dir
, &cdir
, entry
, 0, num_entries
);
1006 exfat_err(sb
, "failed to exfat_remove_entries : err(%d)", err
);
1009 ei
->dir
.dir
= DIR_DELETED
;
1010 exfat_clear_volume_dirty(sb
);
1012 inode_inc_iversion(dir
);
1013 dir
->i_mtime
= dir
->i_atime
= current_time(dir
);
1014 exfat_truncate_atime(&dir
->i_atime
);
1015 if (IS_DIRSYNC(dir
))
1016 exfat_sync_inode(dir
);
1018 mark_inode_dirty(dir
);
1022 inode
->i_mtime
= inode
->i_atime
= current_time(inode
);
1023 exfat_truncate_atime(&inode
->i_atime
);
1024 exfat_unhash_inode(inode
);
1025 exfat_d_version_set(dentry
, inode_query_iversion(dir
));
1027 mutex_unlock(&EXFAT_SB(inode
->i_sb
)->s_lock
);
1031 static int exfat_rename_file(struct inode
*inode
, struct exfat_chain
*p_dir
,
1032 int oldentry
, struct exfat_uni_name
*p_uniname
,
1033 struct exfat_inode_info
*ei
)
1035 int ret
, num_old_entries
, num_new_entries
;
1036 sector_t sector_old
, sector_new
;
1037 struct exfat_dentry
*epold
, *epnew
;
1038 struct super_block
*sb
= inode
->i_sb
;
1039 struct buffer_head
*new_bh
, *old_bh
;
1040 int sync
= IS_DIRSYNC(inode
);
1042 epold
= exfat_get_dentry(sb
, p_dir
, oldentry
, &old_bh
, §or_old
);
1046 num_old_entries
= exfat_count_ext_entries(sb
, p_dir
, oldentry
, epold
);
1047 if (num_old_entries
< 0)
1051 num_new_entries
= exfat_calc_num_entries(p_uniname
);
1052 if (num_new_entries
< 0)
1053 return num_new_entries
;
1055 if (num_old_entries
< num_new_entries
) {
1059 exfat_find_empty_entry(inode
, p_dir
, num_new_entries
);
1061 return newentry
; /* -EIO or -ENOSPC */
1063 epnew
= exfat_get_dentry(sb
, p_dir
, newentry
, &new_bh
,
1068 memcpy(epnew
, epold
, DENTRY_SIZE
);
1069 if (exfat_get_entry_type(epnew
) == TYPE_FILE
) {
1070 epnew
->dentry
.file
.attr
|= cpu_to_le16(ATTR_ARCHIVE
);
1071 ei
->attr
|= ATTR_ARCHIVE
;
1073 exfat_update_bh(new_bh
, sync
);
1077 epold
= exfat_get_dentry(sb
, p_dir
, oldentry
+ 1, &old_bh
,
1081 epnew
= exfat_get_dentry(sb
, p_dir
, newentry
+ 1, &new_bh
,
1088 memcpy(epnew
, epold
, DENTRY_SIZE
);
1089 exfat_update_bh(new_bh
, sync
);
1093 ret
= exfat_init_ext_entry(inode
, p_dir
, newentry
,
1094 num_new_entries
, p_uniname
);
1098 exfat_remove_entries(inode
, p_dir
, oldentry
, 0,
1100 ei
->entry
= newentry
;
1102 if (exfat_get_entry_type(epold
) == TYPE_FILE
) {
1103 epold
->dentry
.file
.attr
|= cpu_to_le16(ATTR_ARCHIVE
);
1104 ei
->attr
|= ATTR_ARCHIVE
;
1106 exfat_update_bh(old_bh
, sync
);
1108 ret
= exfat_init_ext_entry(inode
, p_dir
, oldentry
,
1109 num_new_entries
, p_uniname
);
1113 exfat_remove_entries(inode
, p_dir
, oldentry
, num_new_entries
,
1119 static int exfat_move_file(struct inode
*inode
, struct exfat_chain
*p_olddir
,
1120 int oldentry
, struct exfat_chain
*p_newdir
,
1121 struct exfat_uni_name
*p_uniname
, struct exfat_inode_info
*ei
)
1123 int ret
, newentry
, num_new_entries
, num_old_entries
;
1124 sector_t sector_mov
, sector_new
;
1125 struct exfat_dentry
*epmov
, *epnew
;
1126 struct super_block
*sb
= inode
->i_sb
;
1127 struct buffer_head
*mov_bh
, *new_bh
;
1129 epmov
= exfat_get_dentry(sb
, p_olddir
, oldentry
, &mov_bh
, §or_mov
);
1133 /* check if the source and target directory is the same */
1134 if (exfat_get_entry_type(epmov
) == TYPE_DIR
&&
1135 le32_to_cpu(epmov
->dentry
.stream
.start_clu
) == p_newdir
->dir
)
1138 num_old_entries
= exfat_count_ext_entries(sb
, p_olddir
, oldentry
,
1140 if (num_old_entries
< 0)
1144 num_new_entries
= exfat_calc_num_entries(p_uniname
);
1145 if (num_new_entries
< 0)
1146 return num_new_entries
;
1148 newentry
= exfat_find_empty_entry(inode
, p_newdir
, num_new_entries
);
1150 return newentry
; /* -EIO or -ENOSPC */
1152 epnew
= exfat_get_dentry(sb
, p_newdir
, newentry
, &new_bh
, §or_new
);
1156 memcpy(epnew
, epmov
, DENTRY_SIZE
);
1157 if (exfat_get_entry_type(epnew
) == TYPE_FILE
) {
1158 epnew
->dentry
.file
.attr
|= cpu_to_le16(ATTR_ARCHIVE
);
1159 ei
->attr
|= ATTR_ARCHIVE
;
1161 exfat_update_bh(new_bh
, IS_DIRSYNC(inode
));
1165 epmov
= exfat_get_dentry(sb
, p_olddir
, oldentry
+ 1, &mov_bh
,
1169 epnew
= exfat_get_dentry(sb
, p_newdir
, newentry
+ 1, &new_bh
,
1176 memcpy(epnew
, epmov
, DENTRY_SIZE
);
1177 exfat_update_bh(new_bh
, IS_DIRSYNC(inode
));
1181 ret
= exfat_init_ext_entry(inode
, p_newdir
, newentry
, num_new_entries
,
1186 exfat_remove_entries(inode
, p_olddir
, oldentry
, 0, num_old_entries
);
1188 exfat_chain_set(&ei
->dir
, p_newdir
->dir
, p_newdir
->size
,
1191 ei
->entry
= newentry
;
1195 static void exfat_update_parent_info(struct exfat_inode_info
*ei
,
1196 struct inode
*parent_inode
)
1198 struct exfat_sb_info
*sbi
= EXFAT_SB(parent_inode
->i_sb
);
1199 struct exfat_inode_info
*parent_ei
= EXFAT_I(parent_inode
);
1200 loff_t parent_isize
= i_size_read(parent_inode
);
1203 * the problem that struct exfat_inode_info caches wrong parent info.
1205 * because of flag-mismatch of ei->dir,
1206 * there is abnormal traversing cluster chain.
1208 if (unlikely(parent_ei
->flags
!= ei
->dir
.flags
||
1209 parent_isize
!= EXFAT_CLU_TO_B(ei
->dir
.size
, sbi
) ||
1210 parent_ei
->start_clu
!= ei
->dir
.dir
)) {
1211 exfat_chain_set(&ei
->dir
, parent_ei
->start_clu
,
1212 EXFAT_B_TO_CLU_ROUND_UP(parent_isize
, sbi
),
1217 /* rename or move a old file into a new file */
1218 static int __exfat_rename(struct inode
*old_parent_inode
,
1219 struct exfat_inode_info
*ei
, struct inode
*new_parent_inode
,
1220 struct dentry
*new_dentry
)
1224 struct exfat_chain olddir
, newdir
;
1225 struct exfat_chain
*p_dir
= NULL
;
1226 struct exfat_uni_name uni_name
;
1227 struct exfat_dentry
*ep
;
1228 struct super_block
*sb
= old_parent_inode
->i_sb
;
1229 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
1230 const unsigned char *new_path
= new_dentry
->d_name
.name
;
1231 struct inode
*new_inode
= new_dentry
->d_inode
;
1233 struct exfat_inode_info
*new_ei
= NULL
;
1234 unsigned int new_entry_type
= TYPE_UNUSED
;
1236 struct buffer_head
*old_bh
, *new_bh
= NULL
;
1238 /* check the validity of pointer parameters */
1239 if (new_path
== NULL
|| strlen(new_path
) == 0)
1242 if (ei
->dir
.dir
== DIR_DELETED
) {
1243 exfat_err(sb
, "abnormal access to deleted source dentry");
1247 exfat_update_parent_info(ei
, old_parent_inode
);
1249 exfat_chain_dup(&olddir
, &ei
->dir
);
1252 ep
= exfat_get_dentry(sb
, &olddir
, dentry
, &old_bh
, NULL
);
1259 /* check whether new dir is existing directory and empty */
1262 new_ei
= EXFAT_I(new_inode
);
1264 if (new_ei
->dir
.dir
== DIR_DELETED
) {
1265 exfat_err(sb
, "abnormal access to deleted target dentry");
1269 exfat_update_parent_info(new_ei
, new_parent_inode
);
1271 p_dir
= &(new_ei
->dir
);
1272 new_entry
= new_ei
->entry
;
1273 ep
= exfat_get_dentry(sb
, p_dir
, new_entry
, &new_bh
, NULL
);
1277 new_entry_type
= exfat_get_entry_type(ep
);
1280 /* if new_inode exists, update ei */
1281 if (new_entry_type
== TYPE_DIR
) {
1282 struct exfat_chain new_clu
;
1284 new_clu
.dir
= new_ei
->start_clu
;
1286 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode
),
1288 new_clu
.flags
= new_ei
->flags
;
1290 ret
= exfat_check_dir_empty(sb
, &new_clu
);
1296 /* check the validity of directory name in the given new pathname */
1297 ret
= exfat_resolve_path(new_parent_inode
, new_path
, &newdir
,
1302 exfat_set_volume_dirty(sb
);
1304 if (olddir
.dir
== newdir
.dir
)
1305 ret
= exfat_rename_file(new_parent_inode
, &olddir
, dentry
,
1308 ret
= exfat_move_file(new_parent_inode
, &olddir
, dentry
,
1309 &newdir
, &uni_name
, ei
);
1311 if (!ret
&& new_inode
) {
1312 /* delete entries of new_dir */
1313 ep
= exfat_get_dentry(sb
, p_dir
, new_entry
, &new_bh
, NULL
);
1319 num_entries
= exfat_count_ext_entries(sb
, p_dir
, new_entry
, ep
);
1320 if (num_entries
< 0) {
1326 if (exfat_remove_entries(new_inode
, p_dir
, new_entry
, 0,
1332 /* Free the clusters if new_inode is a dir(as if exfat_rmdir) */
1333 if (new_entry_type
== TYPE_DIR
) {
1334 /* new_ei, new_clu_to_free */
1335 struct exfat_chain new_clu_to_free
;
1337 exfat_chain_set(&new_clu_to_free
, new_ei
->start_clu
,
1338 EXFAT_B_TO_CLU_ROUND_UP(i_size_read(new_inode
),
1339 sbi
), new_ei
->flags
);
1341 if (exfat_free_cluster(new_inode
, &new_clu_to_free
)) {
1342 /* just set I/O error only */
1346 i_size_write(new_inode
, 0);
1347 new_ei
->start_clu
= EXFAT_EOF_CLUSTER
;
1348 new_ei
->flags
= ALLOC_NO_FAT_CHAIN
;
1351 /* Update new_inode ei
1352 * Prevent syncing removed new_inode
1353 * (new_ei is already initialized above code ("if (new_inode)")
1355 new_ei
->dir
.dir
= DIR_DELETED
;
1357 exfat_clear_volume_dirty(sb
);
1362 static int exfat_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1363 struct inode
*new_dir
, struct dentry
*new_dentry
,
1366 struct inode
*old_inode
, *new_inode
;
1367 struct super_block
*sb
= old_dir
->i_sb
;
1372 * The VFS already checks for existence, so for local filesystems
1373 * the RENAME_NOREPLACE implementation is equivalent to plain rename.
1374 * Don't support any other flags
1376 if (flags
& ~RENAME_NOREPLACE
)
1379 mutex_lock(&EXFAT_SB(sb
)->s_lock
);
1380 old_inode
= old_dentry
->d_inode
;
1381 new_inode
= new_dentry
->d_inode
;
1383 err
= __exfat_rename(old_dir
, EXFAT_I(old_inode
), new_dir
, new_dentry
);
1387 inode_inc_iversion(new_dir
);
1388 new_dir
->i_ctime
= new_dir
->i_mtime
= new_dir
->i_atime
=
1389 EXFAT_I(new_dir
)->i_crtime
= current_time(new_dir
);
1390 exfat_truncate_atime(&new_dir
->i_atime
);
1391 if (IS_DIRSYNC(new_dir
))
1392 exfat_sync_inode(new_dir
);
1394 mark_inode_dirty(new_dir
);
1396 i_pos
= ((loff_t
)EXFAT_I(old_inode
)->dir
.dir
<< 32) |
1397 (EXFAT_I(old_inode
)->entry
& 0xffffffff);
1398 exfat_unhash_inode(old_inode
);
1399 exfat_hash_inode(old_inode
, i_pos
);
1400 if (IS_DIRSYNC(new_dir
))
1401 exfat_sync_inode(old_inode
);
1403 mark_inode_dirty(old_inode
);
1405 if (S_ISDIR(old_inode
->i_mode
) && old_dir
!= new_dir
) {
1406 drop_nlink(old_dir
);
1411 inode_inc_iversion(old_dir
);
1412 old_dir
->i_ctime
= old_dir
->i_mtime
= current_time(old_dir
);
1413 if (IS_DIRSYNC(old_dir
))
1414 exfat_sync_inode(old_dir
);
1416 mark_inode_dirty(old_dir
);
1419 exfat_unhash_inode(new_inode
);
1421 /* skip drop_nlink if new_inode already has been dropped */
1422 if (new_inode
->i_nlink
) {
1423 drop_nlink(new_inode
);
1424 if (S_ISDIR(new_inode
->i_mode
))
1425 drop_nlink(new_inode
);
1427 exfat_warn(sb
, "abnormal access to an inode dropped");
1428 WARN_ON(new_inode
->i_nlink
== 0);
1430 new_inode
->i_ctime
= EXFAT_I(new_inode
)->i_crtime
=
1431 current_time(new_inode
);
1435 mutex_unlock(&EXFAT_SB(sb
)->s_lock
);
1439 const struct inode_operations exfat_dir_inode_operations
= {
1440 .create
= exfat_create
,
1441 .lookup
= exfat_lookup
,
1442 .unlink
= exfat_unlink
,
1443 .mkdir
= exfat_mkdir
,
1444 .rmdir
= exfat_rmdir
,
1445 .rename
= exfat_rename
,
1446 .setattr
= exfat_setattr
,
1447 .getattr
= exfat_getattr
,