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 ei
->rwoffset
= EXFAT_CLU_TO_B(clu_offset
, sbi
);
119 if (EXFAT_I(inode
)->i_size_ondisk
> 0)
121 EXFAT_B_TO_CLU_ROUND_UP(EXFAT_I(inode
)->i_size_ondisk
,
124 if (clu_offset
>= num_clusters
)
125 num_to_be_allocated
= clu_offset
- num_clusters
+ 1;
127 if (!create
&& (num_to_be_allocated
> 0)) {
128 *clu
= EXFAT_EOF_CLUSTER
;
132 *clu
= last_clu
= ei
->start_clu
;
134 if (ei
->flags
== ALLOC_NO_FAT_CHAIN
) {
135 if (clu_offset
> 0 && *clu
!= EXFAT_EOF_CLUSTER
) {
136 last_clu
+= clu_offset
- 1;
138 if (clu_offset
== num_clusters
)
139 *clu
= EXFAT_EOF_CLUSTER
;
143 } else if (ei
->type
== TYPE_FILE
) {
144 unsigned int fclus
= 0;
145 int err
= exfat_get_cluster(inode
, clu_offset
,
146 &fclus
, clu
, &last_clu
, 1);
152 /* hint information */
153 if (clu_offset
> 0 && ei
->hint_bmap
.off
!= EXFAT_EOF_CLUSTER
&&
154 ei
->hint_bmap
.off
> 0 && clu_offset
>= ei
->hint_bmap
.off
) {
155 clu_offset
-= ei
->hint_bmap
.off
;
156 /* hint_bmap.clu should be valid */
157 WARN_ON(ei
->hint_bmap
.clu
< 2);
158 *clu
= ei
->hint_bmap
.clu
;
161 while (clu_offset
> 0 && *clu
!= EXFAT_EOF_CLUSTER
) {
163 if (exfat_get_next_cluster(sb
, clu
))
169 if (*clu
== EXFAT_EOF_CLUSTER
) {
170 exfat_set_volume_dirty(sb
);
172 new_clu
.dir
= (last_clu
== EXFAT_EOF_CLUSTER
) ?
173 EXFAT_EOF_CLUSTER
: last_clu
+ 1;
175 new_clu
.flags
= ei
->flags
;
177 /* allocate a cluster */
178 if (num_to_be_allocated
< 1) {
179 /* Broken FAT (i_sze > allocated FAT) */
180 exfat_fs_error(sb
, "broken FAT chain.");
184 ret
= exfat_alloc_cluster(inode
, num_to_be_allocated
, &new_clu
);
188 if (new_clu
.dir
== EXFAT_EOF_CLUSTER
||
189 new_clu
.dir
== EXFAT_FREE_CLUSTER
) {
191 "bogus cluster new allocated (last_clu : %u, new_clu : %u)",
192 last_clu
, new_clu
.dir
);
196 /* append to the FAT chain */
197 if (last_clu
== EXFAT_EOF_CLUSTER
) {
198 if (new_clu
.flags
== ALLOC_FAT_CHAIN
)
199 ei
->flags
= ALLOC_FAT_CHAIN
;
200 ei
->start_clu
= new_clu
.dir
;
203 if (new_clu
.flags
!= ei
->flags
) {
204 /* no-fat-chain bit is disabled,
205 * so fat-chain should be synced with
208 exfat_chain_cont_cluster(sb
, ei
->start_clu
,
210 ei
->flags
= ALLOC_FAT_CHAIN
;
213 if (new_clu
.flags
== ALLOC_FAT_CHAIN
)
214 if (exfat_ent_set(sb
, last_clu
, new_clu
.dir
))
218 num_clusters
+= num_to_be_allocated
;
221 if (ei
->dir
.dir
!= DIR_DELETED
&& modified
) {
222 struct exfat_dentry
*ep
;
223 struct exfat_entry_set_cache
*es
;
226 es
= exfat_get_dentry_set(sb
, &(ei
->dir
), ei
->entry
,
230 /* get stream entry */
231 ep
= exfat_get_dentry_cached(es
, 1);
233 /* update directory entry */
234 ep
->dentry
.stream
.flags
= ei
->flags
;
235 ep
->dentry
.stream
.start_clu
=
236 cpu_to_le32(ei
->start_clu
);
237 ep
->dentry
.stream
.valid_size
=
238 cpu_to_le64(i_size_read(inode
));
239 ep
->dentry
.stream
.size
=
240 ep
->dentry
.stream
.valid_size
;
242 exfat_update_dir_chksum_with_entry_set(es
);
243 err
= exfat_free_dentry_set(es
, inode_needs_sync(inode
));
246 } /* end of if != DIR_DELETED */
249 num_to_be_allocated
<< sbi
->sect_per_clus_bits
;
252 * Move *clu pointer along FAT chains (hole care) because the
253 * caller of this function expect *clu to be the last cluster.
254 * This only works when num_to_be_allocated >= 2,
255 * *clu = (the first cluster of the allocated chain) =>
256 * (the last cluster of ...)
258 if (ei
->flags
== ALLOC_NO_FAT_CHAIN
) {
259 *clu
+= num_to_be_allocated
- 1;
261 while (num_to_be_allocated
> 1) {
262 if (exfat_get_next_cluster(sb
, clu
))
264 num_to_be_allocated
--;
270 /* hint information */
271 ei
->hint_bmap
.off
= local_clu_offset
;
272 ei
->hint_bmap
.clu
= *clu
;
277 static int exfat_map_new_buffer(struct exfat_inode_info
*ei
,
278 struct buffer_head
*bh
, loff_t pos
)
280 if (buffer_delay(bh
) && pos
> ei
->i_size_aligned
)
285 * Adjust i_size_aligned if i_size_ondisk is bigger than it.
287 if (ei
->i_size_ondisk
> ei
->i_size_aligned
)
288 ei
->i_size_aligned
= ei
->i_size_ondisk
;
292 static int exfat_get_block(struct inode
*inode
, sector_t iblock
,
293 struct buffer_head
*bh_result
, int create
)
295 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
296 struct super_block
*sb
= inode
->i_sb
;
297 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
298 unsigned long max_blocks
= bh_result
->b_size
>> inode
->i_blkbits
;
300 unsigned long mapped_blocks
= 0;
301 unsigned int cluster
, sec_offset
;
306 mutex_lock(&sbi
->s_lock
);
307 last_block
= EXFAT_B_TO_BLK_ROUND_UP(i_size_read(inode
), sb
);
308 if (iblock
>= last_block
&& !create
)
311 /* Is this block already allocated? */
312 err
= exfat_map_cluster(inode
, iblock
>> sbi
->sect_per_clus_bits
,
316 exfat_fs_error_ratelimit(sb
,
317 "failed to bmap (inode : %p iblock : %llu, err : %d)",
318 inode
, (unsigned long long)iblock
, err
);
322 if (cluster
== EXFAT_EOF_CLUSTER
)
325 /* sector offset in cluster */
326 sec_offset
= iblock
& (sbi
->sect_per_clus
- 1);
328 phys
= exfat_cluster_to_sector(sbi
, cluster
) + sec_offset
;
329 mapped_blocks
= sbi
->sect_per_clus
- sec_offset
;
330 max_blocks
= min(mapped_blocks
, max_blocks
);
332 /* Treat newly added block / cluster */
333 if (iblock
< last_block
)
336 if (create
|| buffer_delay(bh_result
)) {
337 pos
= EXFAT_BLK_TO_B((iblock
+ 1), sb
);
338 if (ei
->i_size_ondisk
< pos
)
339 ei
->i_size_ondisk
= pos
;
343 err
= exfat_map_new_buffer(ei
, bh_result
, pos
);
346 "requested for bmap out of range(pos : (%llu) > i_size_aligned(%llu)\n",
347 pos
, ei
->i_size_aligned
);
352 if (buffer_delay(bh_result
))
353 clear_buffer_delay(bh_result
);
354 map_bh(bh_result
, sb
, phys
);
356 bh_result
->b_size
= EXFAT_BLK_TO_B(max_blocks
, sb
);
358 mutex_unlock(&sbi
->s_lock
);
362 static int exfat_readpage(struct file
*file
, struct page
*page
)
364 return mpage_readpage(page
, exfat_get_block
);
367 static void exfat_readahead(struct readahead_control
*rac
)
369 mpage_readahead(rac
, exfat_get_block
);
372 static int exfat_writepage(struct page
*page
, struct writeback_control
*wbc
)
374 return block_write_full_page(page
, exfat_get_block
, wbc
);
377 static int exfat_writepages(struct address_space
*mapping
,
378 struct writeback_control
*wbc
)
380 return mpage_writepages(mapping
, wbc
, exfat_get_block
);
383 static void exfat_write_failed(struct address_space
*mapping
, loff_t to
)
385 struct inode
*inode
= mapping
->host
;
387 if (to
> i_size_read(inode
)) {
388 truncate_pagecache(inode
, i_size_read(inode
));
389 exfat_truncate(inode
, EXFAT_I(inode
)->i_size_aligned
);
393 static int exfat_write_begin(struct file
*file
, struct address_space
*mapping
,
394 loff_t pos
, unsigned int len
, unsigned int flags
,
395 struct page
**pagep
, void **fsdata
)
400 ret
= cont_write_begin(file
, mapping
, pos
, len
, flags
, pagep
, fsdata
,
402 &EXFAT_I(mapping
->host
)->i_size_ondisk
);
405 exfat_write_failed(mapping
, pos
+len
);
410 static int exfat_write_end(struct file
*file
, struct address_space
*mapping
,
411 loff_t pos
, unsigned int len
, unsigned int copied
,
412 struct page
*pagep
, void *fsdata
)
414 struct inode
*inode
= mapping
->host
;
415 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
418 err
= generic_write_end(file
, mapping
, pos
, len
, copied
, pagep
, fsdata
);
420 if (EXFAT_I(inode
)->i_size_aligned
< i_size_read(inode
)) {
421 exfat_fs_error(inode
->i_sb
,
422 "invalid size(size(%llu) > aligned(%llu)\n",
423 i_size_read(inode
), EXFAT_I(inode
)->i_size_aligned
);
428 exfat_write_failed(mapping
, pos
+len
);
430 if (!(err
< 0) && !(ei
->attr
& ATTR_ARCHIVE
)) {
431 inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
432 ei
->attr
|= ATTR_ARCHIVE
;
433 mark_inode_dirty(inode
);
439 static ssize_t
exfat_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
441 struct address_space
*mapping
= iocb
->ki_filp
->f_mapping
;
442 struct inode
*inode
= mapping
->host
;
443 loff_t size
= iocb
->ki_pos
+ iov_iter_count(iter
);
444 int rw
= iov_iter_rw(iter
);
449 * FIXME: blockdev_direct_IO() doesn't use ->write_begin(),
450 * so we need to update the ->i_size_aligned to block boundary.
452 * But we must fill the remaining area or hole by nul for
453 * updating ->i_size_aligned
455 * Return 0, and fallback to normal buffered write.
457 if (EXFAT_I(inode
)->i_size_aligned
< size
)
462 * Need to use the DIO_LOCKING for avoiding the race
463 * condition of exfat_get_block() and ->truncate().
465 ret
= blockdev_direct_IO(iocb
, inode
, iter
, exfat_get_block
);
466 if (ret
< 0 && (rw
& WRITE
))
467 exfat_write_failed(mapping
, size
);
471 static sector_t
exfat_aop_bmap(struct address_space
*mapping
, sector_t block
)
475 /* exfat_get_cluster() assumes the requested blocknr isn't truncated. */
476 down_read(&EXFAT_I(mapping
->host
)->truncate_lock
);
477 blocknr
= generic_block_bmap(mapping
, block
, exfat_get_block
);
478 up_read(&EXFAT_I(mapping
->host
)->truncate_lock
);
483 * exfat_block_truncate_page() zeroes out a mapping from file offset `from'
484 * up to the end of the block which corresponds to `from'.
485 * This is required during truncate to physically zeroout the tail end
486 * of that block so it doesn't yield old data if the file is later grown.
487 * Also, avoid causing failure from fsx for cases of "data past EOF"
489 int exfat_block_truncate_page(struct inode
*inode
, loff_t from
)
491 return block_truncate_page(inode
->i_mapping
, from
, exfat_get_block
);
494 static const struct address_space_operations exfat_aops
= {
495 .readpage
= exfat_readpage
,
496 .readahead
= exfat_readahead
,
497 .writepage
= exfat_writepage
,
498 .writepages
= exfat_writepages
,
499 .write_begin
= exfat_write_begin
,
500 .write_end
= exfat_write_end
,
501 .direct_IO
= exfat_direct_IO
,
502 .bmap
= exfat_aop_bmap
505 static inline unsigned long exfat_hash(loff_t i_pos
)
507 return hash_32(i_pos
, EXFAT_HASH_BITS
);
510 void exfat_hash_inode(struct inode
*inode
, loff_t i_pos
)
512 struct exfat_sb_info
*sbi
= EXFAT_SB(inode
->i_sb
);
513 struct hlist_head
*head
= sbi
->inode_hashtable
+ exfat_hash(i_pos
);
515 spin_lock(&sbi
->inode_hash_lock
);
516 EXFAT_I(inode
)->i_pos
= i_pos
;
517 hlist_add_head(&EXFAT_I(inode
)->i_hash_fat
, head
);
518 spin_unlock(&sbi
->inode_hash_lock
);
521 void exfat_unhash_inode(struct inode
*inode
)
523 struct exfat_sb_info
*sbi
= EXFAT_SB(inode
->i_sb
);
525 spin_lock(&sbi
->inode_hash_lock
);
526 hlist_del_init(&EXFAT_I(inode
)->i_hash_fat
);
527 EXFAT_I(inode
)->i_pos
= 0;
528 spin_unlock(&sbi
->inode_hash_lock
);
531 struct inode
*exfat_iget(struct super_block
*sb
, loff_t i_pos
)
533 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
534 struct exfat_inode_info
*info
;
535 struct hlist_head
*head
= sbi
->inode_hashtable
+ exfat_hash(i_pos
);
536 struct inode
*inode
= NULL
;
538 spin_lock(&sbi
->inode_hash_lock
);
539 hlist_for_each_entry(info
, head
, i_hash_fat
) {
540 WARN_ON(info
->vfs_inode
.i_sb
!= sb
);
542 if (i_pos
!= info
->i_pos
)
544 inode
= igrab(&info
->vfs_inode
);
548 spin_unlock(&sbi
->inode_hash_lock
);
552 /* doesn't deal with root inode */
553 static int exfat_fill_inode(struct inode
*inode
, struct exfat_dir_entry
*info
)
555 struct exfat_sb_info
*sbi
= EXFAT_SB(inode
->i_sb
);
556 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
557 loff_t size
= info
->size
;
559 memcpy(&ei
->dir
, &info
->dir
, sizeof(struct exfat_chain
));
560 ei
->entry
= info
->entry
;
561 ei
->attr
= info
->attr
;
562 ei
->start_clu
= info
->start_clu
;
563 ei
->flags
= info
->flags
;
564 ei
->type
= info
->type
;
567 ei
->hint_stat
.eidx
= 0;
568 ei
->hint_stat
.clu
= info
->start_clu
;
569 ei
->hint_femp
.eidx
= EXFAT_HINT_NONE
;
571 ei
->hint_bmap
.off
= EXFAT_EOF_CLUSTER
;
574 inode
->i_uid
= sbi
->options
.fs_uid
;
575 inode
->i_gid
= sbi
->options
.fs_gid
;
576 inode_inc_iversion(inode
);
577 inode
->i_generation
= prandom_u32();
579 if (info
->attr
& ATTR_SUBDIR
) { /* directory */
580 inode
->i_generation
&= ~1;
581 inode
->i_mode
= exfat_make_mode(sbi
, info
->attr
, 0777);
582 inode
->i_op
= &exfat_dir_inode_operations
;
583 inode
->i_fop
= &exfat_dir_operations
;
584 set_nlink(inode
, info
->num_subdirs
);
585 } else { /* regular file */
586 inode
->i_generation
|= 1;
587 inode
->i_mode
= exfat_make_mode(sbi
, info
->attr
, 0777);
588 inode
->i_op
= &exfat_file_inode_operations
;
589 inode
->i_fop
= &exfat_file_operations
;
590 inode
->i_mapping
->a_ops
= &exfat_aops
;
591 inode
->i_mapping
->nrpages
= 0;
594 i_size_write(inode
, size
);
596 /* ondisk and aligned size should be aligned with block size */
597 if (size
& (inode
->i_sb
->s_blocksize
- 1)) {
598 size
|= (inode
->i_sb
->s_blocksize
- 1);
602 ei
->i_size_aligned
= size
;
603 ei
->i_size_ondisk
= size
;
605 exfat_save_attr(inode
, info
->attr
);
607 inode
->i_blocks
= ((i_size_read(inode
) + (sbi
->cluster_size
- 1)) &
608 ~(sbi
->cluster_size
- 1)) >> inode
->i_blkbits
;
609 inode
->i_mtime
= info
->mtime
;
610 inode
->i_ctime
= info
->mtime
;
611 ei
->i_crtime
= info
->crtime
;
612 inode
->i_atime
= info
->atime
;
617 struct inode
*exfat_build_inode(struct super_block
*sb
,
618 struct exfat_dir_entry
*info
, loff_t i_pos
)
623 inode
= exfat_iget(sb
, i_pos
);
626 inode
= new_inode(sb
);
628 inode
= ERR_PTR(-ENOMEM
);
631 inode
->i_ino
= iunique(sb
, EXFAT_ROOT_INO
);
632 inode_set_iversion(inode
, 1);
633 err
= exfat_fill_inode(inode
, info
);
636 inode
= ERR_PTR(err
);
639 exfat_hash_inode(inode
, i_pos
);
640 insert_inode_hash(inode
);
645 void exfat_evict_inode(struct inode
*inode
)
647 truncate_inode_pages(&inode
->i_data
, 0);
649 if (!inode
->i_nlink
) {
650 i_size_write(inode
, 0);
651 mutex_lock(&EXFAT_SB(inode
->i_sb
)->s_lock
);
652 __exfat_truncate(inode
, 0);
653 mutex_unlock(&EXFAT_SB(inode
->i_sb
)->s_lock
);
656 invalidate_inode_buffers(inode
);
658 exfat_cache_inval_inode(inode
);
659 exfat_unhash_inode(inode
);