1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
6 #include <linux/init.h>
7 #include <linux/buffer_head.h>
8 #include <linux/mpage.h>
10 #include <linux/blkdev.h>
11 #include <linux/time.h>
12 #include <linux/writeback.h>
13 #include <linux/uio.h>
14 #include <linux/random.h>
15 #include <linux/iversion.h>
17 #include "exfat_raw.h"
20 static int __exfat_write_inode(struct inode
*inode
, int sync
)
22 unsigned long long on_disk_size
;
23 struct exfat_dentry
*ep
, *ep2
;
24 struct exfat_entry_set_cache
*es
= NULL
;
25 struct super_block
*sb
= inode
->i_sb
;
26 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
27 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
28 bool is_dir
= (ei
->type
== TYPE_DIR
) ? true : false;
30 if (inode
->i_ino
== EXFAT_ROOT_INO
)
34 * If the indode is already unlinked, there is no need for updating it.
36 if (ei
->dir
.dir
== DIR_DELETED
)
39 if (is_dir
&& ei
->dir
.dir
== sbi
->root_dir
&& ei
->entry
== -1)
42 exfat_set_volume_dirty(sb
);
44 /* get the directory entry of given file or directory */
45 es
= exfat_get_dentry_set(sb
, &(ei
->dir
), ei
->entry
, ES_ALL_ENTRIES
);
48 ep
= exfat_get_dentry_cached(es
, 0);
49 ep2
= exfat_get_dentry_cached(es
, 1);
51 ep
->dentry
.file
.attr
= cpu_to_le16(exfat_make_attr(inode
));
53 /* set FILE_INFO structure using the acquired struct exfat_dentry */
54 exfat_set_entry_time(sbi
, &ei
->i_crtime
,
55 &ep
->dentry
.file
.create_tz
,
56 &ep
->dentry
.file
.create_time
,
57 &ep
->dentry
.file
.create_date
,
58 &ep
->dentry
.file
.create_time_cs
);
59 exfat_set_entry_time(sbi
, &inode
->i_mtime
,
60 &ep
->dentry
.file
.modify_tz
,
61 &ep
->dentry
.file
.modify_time
,
62 &ep
->dentry
.file
.modify_date
,
63 &ep
->dentry
.file
.modify_time_cs
);
64 exfat_set_entry_time(sbi
, &inode
->i_atime
,
65 &ep
->dentry
.file
.access_tz
,
66 &ep
->dentry
.file
.access_time
,
67 &ep
->dentry
.file
.access_date
,
70 /* File size should be zero if there is no cluster allocated */
71 on_disk_size
= i_size_read(inode
);
73 if (ei
->start_clu
== EXFAT_EOF_CLUSTER
)
76 ep2
->dentry
.stream
.valid_size
= cpu_to_le64(on_disk_size
);
77 ep2
->dentry
.stream
.size
= ep2
->dentry
.stream
.valid_size
;
79 exfat_update_dir_chksum_with_entry_set(es
);
80 return exfat_free_dentry_set(es
, sync
);
83 int exfat_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
87 mutex_lock(&EXFAT_SB(inode
->i_sb
)->s_lock
);
88 ret
= __exfat_write_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
89 mutex_unlock(&EXFAT_SB(inode
->i_sb
)->s_lock
);
94 void exfat_sync_inode(struct inode
*inode
)
96 lockdep_assert_held(&EXFAT_SB(inode
->i_sb
)->s_lock
);
97 __exfat_write_inode(inode
, 1);
101 * Input: inode, (logical) clu_offset, target allocation area
102 * Output: errcode, cluster number
103 * *clu = (~0), if it's unable to allocate a new cluster
105 static int exfat_map_cluster(struct inode
*inode
, unsigned int clu_offset
,
106 unsigned int *clu
, int create
)
108 int ret
, modified
= false;
109 unsigned int last_clu
;
110 struct exfat_chain new_clu
;
111 struct super_block
*sb
= inode
->i_sb
;
112 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
113 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
114 unsigned int local_clu_offset
= clu_offset
;
115 unsigned int num_to_be_allocated
= 0, num_clusters
= 0;
117 if (EXFAT_I(inode
)->i_size_ondisk
> 0)
119 EXFAT_B_TO_CLU_ROUND_UP(EXFAT_I(inode
)->i_size_ondisk
,
122 if (clu_offset
>= num_clusters
)
123 num_to_be_allocated
= clu_offset
- num_clusters
+ 1;
125 if (!create
&& (num_to_be_allocated
> 0)) {
126 *clu
= EXFAT_EOF_CLUSTER
;
130 *clu
= last_clu
= ei
->start_clu
;
132 if (ei
->flags
== ALLOC_NO_FAT_CHAIN
) {
133 if (clu_offset
> 0 && *clu
!= EXFAT_EOF_CLUSTER
) {
134 last_clu
+= clu_offset
- 1;
136 if (clu_offset
== num_clusters
)
137 *clu
= EXFAT_EOF_CLUSTER
;
141 } else if (ei
->type
== TYPE_FILE
) {
142 unsigned int fclus
= 0;
143 int err
= exfat_get_cluster(inode
, clu_offset
,
144 &fclus
, clu
, &last_clu
, 1);
150 /* hint information */
151 if (clu_offset
> 0 && ei
->hint_bmap
.off
!= EXFAT_EOF_CLUSTER
&&
152 ei
->hint_bmap
.off
> 0 && clu_offset
>= ei
->hint_bmap
.off
) {
153 clu_offset
-= ei
->hint_bmap
.off
;
154 /* hint_bmap.clu should be valid */
155 WARN_ON(ei
->hint_bmap
.clu
< 2);
156 *clu
= ei
->hint_bmap
.clu
;
159 while (clu_offset
> 0 && *clu
!= EXFAT_EOF_CLUSTER
) {
161 if (exfat_get_next_cluster(sb
, clu
))
167 if (*clu
== EXFAT_EOF_CLUSTER
) {
168 exfat_set_volume_dirty(sb
);
170 new_clu
.dir
= (last_clu
== EXFAT_EOF_CLUSTER
) ?
171 EXFAT_EOF_CLUSTER
: last_clu
+ 1;
173 new_clu
.flags
= ei
->flags
;
175 /* allocate a cluster */
176 if (num_to_be_allocated
< 1) {
177 /* Broken FAT (i_sze > allocated FAT) */
178 exfat_fs_error(sb
, "broken FAT chain.");
182 ret
= exfat_alloc_cluster(inode
, num_to_be_allocated
, &new_clu
,
183 inode_needs_sync(inode
));
187 if (new_clu
.dir
== EXFAT_EOF_CLUSTER
||
188 new_clu
.dir
== EXFAT_FREE_CLUSTER
) {
190 "bogus cluster new allocated (last_clu : %u, new_clu : %u)",
191 last_clu
, new_clu
.dir
);
195 /* append to the FAT chain */
196 if (last_clu
== EXFAT_EOF_CLUSTER
) {
197 if (new_clu
.flags
== ALLOC_FAT_CHAIN
)
198 ei
->flags
= ALLOC_FAT_CHAIN
;
199 ei
->start_clu
= new_clu
.dir
;
202 if (new_clu
.flags
!= ei
->flags
) {
203 /* no-fat-chain bit is disabled,
204 * so fat-chain should be synced with
207 exfat_chain_cont_cluster(sb
, ei
->start_clu
,
209 ei
->flags
= ALLOC_FAT_CHAIN
;
212 if (new_clu
.flags
== ALLOC_FAT_CHAIN
)
213 if (exfat_ent_set(sb
, last_clu
, new_clu
.dir
))
217 num_clusters
+= num_to_be_allocated
;
220 if (ei
->dir
.dir
!= DIR_DELETED
&& modified
) {
221 struct exfat_dentry
*ep
;
222 struct exfat_entry_set_cache
*es
;
225 es
= exfat_get_dentry_set(sb
, &(ei
->dir
), ei
->entry
,
229 /* get stream entry */
230 ep
= exfat_get_dentry_cached(es
, 1);
232 /* update directory entry */
233 ep
->dentry
.stream
.flags
= ei
->flags
;
234 ep
->dentry
.stream
.start_clu
=
235 cpu_to_le32(ei
->start_clu
);
236 ep
->dentry
.stream
.valid_size
=
237 cpu_to_le64(i_size_read(inode
));
238 ep
->dentry
.stream
.size
=
239 ep
->dentry
.stream
.valid_size
;
241 exfat_update_dir_chksum_with_entry_set(es
);
242 err
= exfat_free_dentry_set(es
, inode_needs_sync(inode
));
245 } /* end of if != DIR_DELETED */
248 num_to_be_allocated
<< sbi
->sect_per_clus_bits
;
251 * Move *clu pointer along FAT chains (hole care) because the
252 * caller of this function expect *clu to be the last cluster.
253 * This only works when num_to_be_allocated >= 2,
254 * *clu = (the first cluster of the allocated chain) =>
255 * (the last cluster of ...)
257 if (ei
->flags
== ALLOC_NO_FAT_CHAIN
) {
258 *clu
+= num_to_be_allocated
- 1;
260 while (num_to_be_allocated
> 1) {
261 if (exfat_get_next_cluster(sb
, clu
))
263 num_to_be_allocated
--;
269 /* hint information */
270 ei
->hint_bmap
.off
= local_clu_offset
;
271 ei
->hint_bmap
.clu
= *clu
;
276 static int exfat_map_new_buffer(struct exfat_inode_info
*ei
,
277 struct buffer_head
*bh
, loff_t pos
)
279 if (buffer_delay(bh
) && pos
> ei
->i_size_aligned
)
284 * Adjust i_size_aligned if i_size_ondisk is bigger than it.
286 if (ei
->i_size_ondisk
> ei
->i_size_aligned
)
287 ei
->i_size_aligned
= ei
->i_size_ondisk
;
291 static int exfat_get_block(struct inode
*inode
, sector_t iblock
,
292 struct buffer_head
*bh_result
, int create
)
294 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
295 struct super_block
*sb
= inode
->i_sb
;
296 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
297 unsigned long max_blocks
= bh_result
->b_size
>> inode
->i_blkbits
;
299 unsigned long mapped_blocks
= 0;
300 unsigned int cluster
, sec_offset
;
305 mutex_lock(&sbi
->s_lock
);
306 last_block
= EXFAT_B_TO_BLK_ROUND_UP(i_size_read(inode
), sb
);
307 if (iblock
>= last_block
&& !create
)
310 /* Is this block already allocated? */
311 err
= exfat_map_cluster(inode
, iblock
>> sbi
->sect_per_clus_bits
,
315 exfat_fs_error_ratelimit(sb
,
316 "failed to bmap (inode : %p iblock : %llu, err : %d)",
317 inode
, (unsigned long long)iblock
, err
);
321 if (cluster
== EXFAT_EOF_CLUSTER
)
324 /* sector offset in cluster */
325 sec_offset
= iblock
& (sbi
->sect_per_clus
- 1);
327 phys
= exfat_cluster_to_sector(sbi
, cluster
) + sec_offset
;
328 mapped_blocks
= sbi
->sect_per_clus
- sec_offset
;
329 max_blocks
= min(mapped_blocks
, max_blocks
);
331 /* Treat newly added block / cluster */
332 if (iblock
< last_block
)
335 if (create
|| buffer_delay(bh_result
)) {
336 pos
= EXFAT_BLK_TO_B((iblock
+ 1), sb
);
337 if (ei
->i_size_ondisk
< pos
)
338 ei
->i_size_ondisk
= pos
;
342 err
= exfat_map_new_buffer(ei
, bh_result
, pos
);
345 "requested for bmap out of range(pos : (%llu) > i_size_aligned(%llu)\n",
346 pos
, ei
->i_size_aligned
);
351 if (buffer_delay(bh_result
))
352 clear_buffer_delay(bh_result
);
353 map_bh(bh_result
, sb
, phys
);
355 bh_result
->b_size
= EXFAT_BLK_TO_B(max_blocks
, sb
);
357 mutex_unlock(&sbi
->s_lock
);
361 static int exfat_readpage(struct file
*file
, struct page
*page
)
363 return mpage_readpage(page
, exfat_get_block
);
366 static void exfat_readahead(struct readahead_control
*rac
)
368 mpage_readahead(rac
, exfat_get_block
);
371 static int exfat_writepage(struct page
*page
, struct writeback_control
*wbc
)
373 return block_write_full_page(page
, exfat_get_block
, wbc
);
376 static int exfat_writepages(struct address_space
*mapping
,
377 struct writeback_control
*wbc
)
379 return mpage_writepages(mapping
, wbc
, exfat_get_block
);
382 static void exfat_write_failed(struct address_space
*mapping
, loff_t to
)
384 struct inode
*inode
= mapping
->host
;
386 if (to
> i_size_read(inode
)) {
387 truncate_pagecache(inode
, i_size_read(inode
));
388 exfat_truncate(inode
, EXFAT_I(inode
)->i_size_aligned
);
392 static int exfat_write_begin(struct file
*file
, struct address_space
*mapping
,
393 loff_t pos
, unsigned int len
, unsigned int flags
,
394 struct page
**pagep
, void **fsdata
)
399 ret
= cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
401 &EXFAT_I(mapping
->host
)->i_size_ondisk
);
404 exfat_write_failed(mapping
, pos
+len
);
409 static int exfat_write_end(struct file
*file
, struct address_space
*mapping
,
410 loff_t pos
, unsigned int len
, unsigned int copied
,
411 struct page
*pagep
, void *fsdata
)
413 struct inode
*inode
= mapping
->host
;
414 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
417 err
= generic_write_end(file
, mapping
, pos
, len
, copied
, pagep
, fsdata
);
419 if (EXFAT_I(inode
)->i_size_aligned
< i_size_read(inode
)) {
420 exfat_fs_error(inode
->i_sb
,
421 "invalid size(size(%llu) > aligned(%llu)\n",
422 i_size_read(inode
), EXFAT_I(inode
)->i_size_aligned
);
427 exfat_write_failed(mapping
, pos
+len
);
429 if (!(err
< 0) && !(ei
->attr
& ATTR_ARCHIVE
)) {
430 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
431 ei
->attr
|= ATTR_ARCHIVE
;
432 mark_inode_dirty(inode
);
438 static ssize_t
exfat_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
440 struct address_space
*mapping
= iocb
->ki_filp
->f_mapping
;
441 struct inode
*inode
= mapping
->host
;
442 loff_t size
= iocb
->ki_pos
+ iov_iter_count(iter
);
443 int rw
= iov_iter_rw(iter
);
448 * FIXME: blockdev_direct_IO() doesn't use ->write_begin(),
449 * so we need to update the ->i_size_aligned to block boundary.
451 * But we must fill the remaining area or hole by nul for
452 * updating ->i_size_aligned
454 * Return 0, and fallback to normal buffered write.
456 if (EXFAT_I(inode
)->i_size_aligned
< size
)
461 * Need to use the DIO_LOCKING for avoiding the race
462 * condition of exfat_get_block() and ->truncate().
464 ret
= blockdev_direct_IO(iocb
, inode
, iter
, exfat_get_block
);
465 if (ret
< 0 && (rw
& WRITE
))
466 exfat_write_failed(mapping
, size
);
470 static sector_t
exfat_aop_bmap(struct address_space
*mapping
, sector_t block
)
474 /* exfat_get_cluster() assumes the requested blocknr isn't truncated. */
475 down_read(&EXFAT_I(mapping
->host
)->truncate_lock
);
476 blocknr
= generic_block_bmap(mapping
, block
, exfat_get_block
);
477 up_read(&EXFAT_I(mapping
->host
)->truncate_lock
);
482 * exfat_block_truncate_page() zeroes out a mapping from file offset `from'
483 * up to the end of the block which corresponds to `from'.
484 * This is required during truncate to physically zeroout the tail end
485 * of that block so it doesn't yield old data if the file is later grown.
486 * Also, avoid causing failure from fsx for cases of "data past EOF"
488 int exfat_block_truncate_page(struct inode
*inode
, loff_t from
)
490 return block_truncate_page(inode
->i_mapping
, from
, exfat_get_block
);
493 static const struct address_space_operations exfat_aops
= {
494 .readpage
= exfat_readpage
,
495 .readahead
= exfat_readahead
,
496 .writepage
= exfat_writepage
,
497 .writepages
= exfat_writepages
,
498 .write_begin
= exfat_write_begin
,
499 .write_end
= exfat_write_end
,
500 .direct_IO
= exfat_direct_IO
,
501 .bmap
= exfat_aop_bmap
504 static inline unsigned long exfat_hash(loff_t i_pos
)
506 return hash_32(i_pos
, EXFAT_HASH_BITS
);
509 void exfat_hash_inode(struct inode
*inode
, loff_t i_pos
)
511 struct exfat_sb_info
*sbi
= EXFAT_SB(inode
->i_sb
);
512 struct hlist_head
*head
= sbi
->inode_hashtable
+ exfat_hash(i_pos
);
514 spin_lock(&sbi
->inode_hash_lock
);
515 EXFAT_I(inode
)->i_pos
= i_pos
;
516 hlist_add_head(&EXFAT_I(inode
)->i_hash_fat
, head
);
517 spin_unlock(&sbi
->inode_hash_lock
);
520 void exfat_unhash_inode(struct inode
*inode
)
522 struct exfat_sb_info
*sbi
= EXFAT_SB(inode
->i_sb
);
524 spin_lock(&sbi
->inode_hash_lock
);
525 hlist_del_init(&EXFAT_I(inode
)->i_hash_fat
);
526 EXFAT_I(inode
)->i_pos
= 0;
527 spin_unlock(&sbi
->inode_hash_lock
);
530 struct inode
*exfat_iget(struct super_block
*sb
, loff_t i_pos
)
532 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
533 struct exfat_inode_info
*info
;
534 struct hlist_head
*head
= sbi
->inode_hashtable
+ exfat_hash(i_pos
);
535 struct inode
*inode
= NULL
;
537 spin_lock(&sbi
->inode_hash_lock
);
538 hlist_for_each_entry(info
, head
, i_hash_fat
) {
539 WARN_ON(info
->vfs_inode
.i_sb
!= sb
);
541 if (i_pos
!= info
->i_pos
)
543 inode
= igrab(&info
->vfs_inode
);
547 spin_unlock(&sbi
->inode_hash_lock
);
551 /* doesn't deal with root inode */
552 static int exfat_fill_inode(struct inode
*inode
, struct exfat_dir_entry
*info
)
554 struct exfat_sb_info
*sbi
= EXFAT_SB(inode
->i_sb
);
555 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
556 loff_t size
= info
->size
;
559 ei
->entry
= info
->entry
;
560 ei
->attr
= info
->attr
;
561 ei
->start_clu
= info
->start_clu
;
562 ei
->flags
= info
->flags
;
563 ei
->type
= info
->type
;
566 ei
->hint_stat
.eidx
= 0;
567 ei
->hint_stat
.clu
= info
->start_clu
;
568 ei
->hint_femp
.eidx
= EXFAT_HINT_NONE
;
569 ei
->hint_bmap
.off
= EXFAT_EOF_CLUSTER
;
572 inode
->i_uid
= sbi
->options
.fs_uid
;
573 inode
->i_gid
= sbi
->options
.fs_gid
;
574 inode_inc_iversion(inode
);
575 inode
->i_generation
= prandom_u32();
577 if (info
->attr
& ATTR_SUBDIR
) { /* directory */
578 inode
->i_generation
&= ~1;
579 inode
->i_mode
= exfat_make_mode(sbi
, info
->attr
, 0777);
580 inode
->i_op
= &exfat_dir_inode_operations
;
581 inode
->i_fop
= &exfat_dir_operations
;
582 set_nlink(inode
, info
->num_subdirs
);
583 } else { /* regular file */
584 inode
->i_generation
|= 1;
585 inode
->i_mode
= exfat_make_mode(sbi
, info
->attr
, 0777);
586 inode
->i_op
= &exfat_file_inode_operations
;
587 inode
->i_fop
= &exfat_file_operations
;
588 inode
->i_mapping
->a_ops
= &exfat_aops
;
589 inode
->i_mapping
->nrpages
= 0;
592 i_size_write(inode
, size
);
594 /* ondisk and aligned size should be aligned with block size */
595 if (size
& (inode
->i_sb
->s_blocksize
- 1)) {
596 size
|= (inode
->i_sb
->s_blocksize
- 1);
600 ei
->i_size_aligned
= size
;
601 ei
->i_size_ondisk
= size
;
603 exfat_save_attr(inode
, info
->attr
);
605 inode
->i_blocks
= ((i_size_read(inode
) + (sbi
->cluster_size
- 1)) &
606 ~(sbi
->cluster_size
- 1)) >> inode
->i_blkbits
;
607 inode
->i_mtime
= info
->mtime
;
608 inode
->i_ctime
= info
->mtime
;
609 ei
->i_crtime
= info
->crtime
;
610 inode
->i_atime
= info
->atime
;
615 struct inode
*exfat_build_inode(struct super_block
*sb
,
616 struct exfat_dir_entry
*info
, loff_t i_pos
)
621 inode
= exfat_iget(sb
, i_pos
);
624 inode
= new_inode(sb
);
626 inode
= ERR_PTR(-ENOMEM
);
629 inode
->i_ino
= iunique(sb
, EXFAT_ROOT_INO
);
630 inode_set_iversion(inode
, 1);
631 err
= exfat_fill_inode(inode
, info
);
634 inode
= ERR_PTR(err
);
637 exfat_hash_inode(inode
, i_pos
);
638 insert_inode_hash(inode
);
643 void exfat_evict_inode(struct inode
*inode
)
645 truncate_inode_pages(&inode
->i_data
, 0);
647 if (!inode
->i_nlink
) {
648 i_size_write(inode
, 0);
649 mutex_lock(&EXFAT_SB(inode
->i_sb
)->s_lock
);
650 __exfat_truncate(inode
, 0);
651 mutex_unlock(&EXFAT_SB(inode
->i_sb
)->s_lock
);
654 invalidate_inode_buffers(inode
);
656 exfat_cache_inval_inode(inode
);
657 exfat_unhash_inode(inode
);