1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
6 #include <linux/slab.h>
7 #include <linux/compat.h>
8 #include <linux/cred.h>
9 #include <linux/buffer_head.h>
10 #include <linux/blkdev.h>
12 #include "exfat_raw.h"
15 static int exfat_cont_expand(struct inode
*inode
, loff_t size
)
17 struct address_space
*mapping
= inode
->i_mapping
;
18 loff_t start
= i_size_read(inode
), count
= size
- i_size_read(inode
);
21 err
= generic_cont_expand_simple(inode
, size
);
25 inode
->i_ctime
= inode
->i_mtime
= current_time(inode
);
26 mark_inode_dirty(inode
);
31 err
= filemap_fdatawrite_range(mapping
, start
, start
+ count
- 1);
32 err2
= sync_mapping_buffers(mapping
);
35 err2
= write_inode_now(inode
, 1);
41 return filemap_fdatawait_range(mapping
, start
, start
+ count
- 1);
44 static bool exfat_allow_set_time(struct exfat_sb_info
*sbi
, struct inode
*inode
)
46 mode_t allow_utime
= sbi
->options
.allow_utime
;
48 if (!uid_eq(current_fsuid(), inode
->i_uid
)) {
49 if (in_group_p(inode
->i_gid
))
51 if (allow_utime
& MAY_WRITE
)
55 /* use a default check */
59 static int exfat_sanitize_mode(const struct exfat_sb_info
*sbi
,
60 struct inode
*inode
, umode_t
*mode_ptr
)
62 mode_t i_mode
, mask
, perm
;
64 i_mode
= inode
->i_mode
;
66 mask
= (S_ISREG(i_mode
) || S_ISLNK(i_mode
)) ?
67 sbi
->options
.fs_fmask
: sbi
->options
.fs_dmask
;
68 perm
= *mode_ptr
& ~(S_IFMT
| mask
);
70 /* Of the r and x bits, all (subject to umask) must be present.*/
71 if ((perm
& 0555) != (i_mode
& 0555))
74 if (exfat_mode_can_hold_ro(inode
)) {
76 * Of the w bits, either all (subject to umask) or none must
79 if ((perm
& 0222) && ((perm
& 0222) != (0222 & ~mask
)))
83 * If exfat_mode_can_hold_ro(inode) is false, can't change
86 if ((perm
& 0222) != (0222 & ~mask
))
90 *mode_ptr
&= S_IFMT
| perm
;
95 /* resize the file length */
96 int __exfat_truncate(struct inode
*inode
, loff_t new_size
)
98 unsigned int num_clusters_new
, num_clusters_phys
;
99 unsigned int last_clu
= EXFAT_FREE_CLUSTER
;
100 struct exfat_chain clu
;
101 struct super_block
*sb
= inode
->i_sb
;
102 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
103 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
104 int evict
= (ei
->dir
.dir
== DIR_DELETED
) ? 1 : 0;
106 /* check if the given file ID is opened */
107 if (ei
->type
!= TYPE_FILE
&& ei
->type
!= TYPE_DIR
)
110 exfat_set_volume_dirty(sb
);
112 num_clusters_new
= EXFAT_B_TO_CLU_ROUND_UP(i_size_read(inode
), sbi
);
113 num_clusters_phys
= EXFAT_B_TO_CLU_ROUND_UP(ei
->i_size_ondisk
, sbi
);
115 exfat_chain_set(&clu
, ei
->start_clu
, num_clusters_phys
, ei
->flags
);
119 * Truncate FAT chain num_clusters after the first cluster
120 * num_clusters = min(new, phys);
122 unsigned int num_clusters
=
123 min(num_clusters_new
, num_clusters_phys
);
127 * (defensive coding - works fine even with corrupted FAT table
129 if (clu
.flags
== ALLOC_NO_FAT_CHAIN
) {
130 clu
.dir
+= num_clusters
;
131 clu
.size
-= num_clusters
;
133 while (num_clusters
> 0) {
135 if (exfat_get_next_cluster(sb
, &(clu
.dir
)))
143 ei
->flags
= ALLOC_NO_FAT_CHAIN
;
144 ei
->start_clu
= EXFAT_EOF_CLUSTER
;
147 i_size_write(inode
, new_size
);
149 if (ei
->type
== TYPE_FILE
)
150 ei
->attr
|= ATTR_ARCHIVE
;
152 /* update the directory entry */
154 struct timespec64 ts
;
155 struct exfat_dentry
*ep
, *ep2
;
156 struct exfat_entry_set_cache
*es
;
159 es
= exfat_get_dentry_set(sb
, &(ei
->dir
), ei
->entry
,
163 ep
= exfat_get_dentry_cached(es
, 0);
164 ep2
= exfat_get_dentry_cached(es
, 1);
166 ts
= current_time(inode
);
167 exfat_set_entry_time(sbi
, &ts
,
168 &ep
->dentry
.file
.modify_tz
,
169 &ep
->dentry
.file
.modify_time
,
170 &ep
->dentry
.file
.modify_date
,
171 &ep
->dentry
.file
.modify_time_cs
);
172 ep
->dentry
.file
.attr
= cpu_to_le16(ei
->attr
);
174 /* File size should be zero if there is no cluster allocated */
175 if (ei
->start_clu
== EXFAT_EOF_CLUSTER
) {
176 ep2
->dentry
.stream
.valid_size
= 0;
177 ep2
->dentry
.stream
.size
= 0;
179 ep2
->dentry
.stream
.valid_size
= cpu_to_le64(new_size
);
180 ep2
->dentry
.stream
.size
= ep2
->dentry
.stream
.valid_size
;
184 /* Any directory can not be truncated to zero */
185 WARN_ON(ei
->type
!= TYPE_FILE
);
187 ep2
->dentry
.stream
.flags
= ALLOC_FAT_CHAIN
;
188 ep2
->dentry
.stream
.start_clu
= EXFAT_FREE_CLUSTER
;
191 exfat_update_dir_chksum_with_entry_set(es
);
192 err
= exfat_free_dentry_set(es
, inode_needs_sync(inode
));
197 /* cut off from the FAT chain */
198 if (ei
->flags
== ALLOC_FAT_CHAIN
&& last_clu
!= EXFAT_FREE_CLUSTER
&&
199 last_clu
!= EXFAT_EOF_CLUSTER
) {
200 if (exfat_ent_set(sb
, last_clu
, EXFAT_EOF_CLUSTER
))
204 /* invalidate cache and free the clusters */
205 /* clear exfat cache */
206 exfat_cache_inval_inode(inode
);
208 /* hint information */
209 ei
->hint_bmap
.off
= EXFAT_EOF_CLUSTER
;
210 ei
->hint_bmap
.clu
= EXFAT_EOF_CLUSTER
;
212 /* hint_stat will be used if this is directory. */
213 ei
->hint_stat
.eidx
= 0;
214 ei
->hint_stat
.clu
= ei
->start_clu
;
215 ei
->hint_femp
.eidx
= EXFAT_HINT_NONE
;
217 /* free the clusters */
218 if (exfat_free_cluster(inode
, &clu
))
221 exfat_clear_volume_dirty(sb
);
226 void exfat_truncate(struct inode
*inode
, loff_t size
)
228 struct super_block
*sb
= inode
->i_sb
;
229 struct exfat_sb_info
*sbi
= EXFAT_SB(sb
);
230 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
231 unsigned int blocksize
= i_blocksize(inode
);
235 mutex_lock(&sbi
->s_lock
);
236 if (ei
->start_clu
== 0) {
238 * Empty start_clu != ~0 (not allocated)
240 exfat_fs_error(sb
, "tried to truncate zeroed cluster.");
244 err
= __exfat_truncate(inode
, i_size_read(inode
));
248 inode
->i_ctime
= inode
->i_mtime
= current_time(inode
);
249 if (IS_DIRSYNC(inode
))
250 exfat_sync_inode(inode
);
252 mark_inode_dirty(inode
);
254 inode
->i_blocks
= round_up(i_size_read(inode
), sbi
->cluster_size
) >>
257 aligned_size
= i_size_read(inode
);
258 if (aligned_size
& (blocksize
- 1)) {
259 aligned_size
|= (blocksize
- 1);
263 if (ei
->i_size_ondisk
> i_size_read(inode
))
264 ei
->i_size_ondisk
= aligned_size
;
266 if (ei
->i_size_aligned
> i_size_read(inode
))
267 ei
->i_size_aligned
= aligned_size
;
268 mutex_unlock(&sbi
->s_lock
);
271 int exfat_getattr(struct user_namespace
*mnt_uerns
, const struct path
*path
,
272 struct kstat
*stat
, unsigned int request_mask
,
273 unsigned int query_flags
)
275 struct inode
*inode
= d_backing_inode(path
->dentry
);
276 struct exfat_inode_info
*ei
= EXFAT_I(inode
);
278 generic_fillattr(&init_user_ns
, inode
, stat
);
279 exfat_truncate_atime(&stat
->atime
);
280 stat
->result_mask
|= STATX_BTIME
;
281 stat
->btime
.tv_sec
= ei
->i_crtime
.tv_sec
;
282 stat
->btime
.tv_nsec
= ei
->i_crtime
.tv_nsec
;
283 stat
->blksize
= EXFAT_SB(inode
->i_sb
)->cluster_size
;
287 int exfat_setattr(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
290 struct exfat_sb_info
*sbi
= EXFAT_SB(dentry
->d_sb
);
291 struct inode
*inode
= dentry
->d_inode
;
292 unsigned int ia_valid
;
295 if ((attr
->ia_valid
& ATTR_SIZE
) &&
296 attr
->ia_size
> i_size_read(inode
)) {
297 error
= exfat_cont_expand(inode
, attr
->ia_size
);
298 if (error
|| attr
->ia_valid
== ATTR_SIZE
)
300 attr
->ia_valid
&= ~ATTR_SIZE
;
303 /* Check for setting the inode time. */
304 ia_valid
= attr
->ia_valid
;
305 if ((ia_valid
& (ATTR_MTIME_SET
| ATTR_ATIME_SET
| ATTR_TIMES_SET
)) &&
306 exfat_allow_set_time(sbi
, inode
)) {
307 attr
->ia_valid
&= ~(ATTR_MTIME_SET
| ATTR_ATIME_SET
|
311 error
= setattr_prepare(&init_user_ns
, dentry
, attr
);
312 attr
->ia_valid
= ia_valid
;
316 if (((attr
->ia_valid
& ATTR_UID
) &&
317 !uid_eq(attr
->ia_uid
, sbi
->options
.fs_uid
)) ||
318 ((attr
->ia_valid
& ATTR_GID
) &&
319 !gid_eq(attr
->ia_gid
, sbi
->options
.fs_gid
)) ||
320 ((attr
->ia_valid
& ATTR_MODE
) &&
321 (attr
->ia_mode
& ~(S_IFREG
| S_IFLNK
| S_IFDIR
| 0777)))) {
327 * We don't return -EPERM here. Yes, strange, but this is too
330 if (attr
->ia_valid
& ATTR_MODE
) {
331 if (exfat_sanitize_mode(sbi
, inode
, &attr
->ia_mode
) < 0)
332 attr
->ia_valid
&= ~ATTR_MODE
;
335 if (attr
->ia_valid
& ATTR_SIZE
) {
336 error
= exfat_block_truncate_page(inode
, attr
->ia_size
);
340 down_write(&EXFAT_I(inode
)->truncate_lock
);
341 truncate_setsize(inode
, attr
->ia_size
);
342 exfat_truncate(inode
, attr
->ia_size
);
343 up_write(&EXFAT_I(inode
)->truncate_lock
);
346 setattr_copy(&init_user_ns
, inode
, attr
);
347 exfat_truncate_atime(&inode
->i_atime
);
348 mark_inode_dirty(inode
);
354 static int exfat_ioctl_fitrim(struct inode
*inode
, unsigned long arg
)
356 struct request_queue
*q
= bdev_get_queue(inode
->i_sb
->s_bdev
);
357 struct fstrim_range range
;
360 if (!capable(CAP_SYS_ADMIN
))
363 if (!blk_queue_discard(q
))
366 if (copy_from_user(&range
, (struct fstrim_range __user
*)arg
, sizeof(range
)))
369 range
.minlen
= max_t(unsigned int, range
.minlen
,
370 q
->limits
.discard_granularity
);
372 ret
= exfat_trim_fs(inode
, &range
);
376 if (copy_to_user((struct fstrim_range __user
*)arg
, &range
, sizeof(range
)))
382 long exfat_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
384 struct inode
*inode
= file_inode(filp
);
388 return exfat_ioctl_fitrim(inode
, arg
);
395 long exfat_compat_ioctl(struct file
*filp
, unsigned int cmd
,
398 return exfat_ioctl(filp
, cmd
, (unsigned long)compat_ptr(arg
));
402 int exfat_file_fsync(struct file
*filp
, loff_t start
, loff_t end
, int datasync
)
404 struct inode
*inode
= filp
->f_mapping
->host
;
407 err
= __generic_file_fsync(filp
, start
, end
, datasync
);
411 err
= sync_blockdev(inode
->i_sb
->s_bdev
);
415 return blkdev_issue_flush(inode
->i_sb
->s_bdev
);
418 const struct file_operations exfat_file_operations
= {
419 .llseek
= generic_file_llseek
,
420 .read_iter
= generic_file_read_iter
,
421 .write_iter
= generic_file_write_iter
,
422 .unlocked_ioctl
= exfat_ioctl
,
424 .compat_ioctl
= exfat_compat_ioctl
,
426 .mmap
= generic_file_mmap
,
427 .fsync
= exfat_file_fsync
,
428 .splice_read
= generic_file_splice_read
,
429 .splice_write
= iter_file_splice_write
,
432 const struct inode_operations exfat_file_inode_operations
= {
433 .setattr
= exfat_setattr
,
434 .getattr
= exfat_getattr
,