1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
4 */
5
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>
11 #include <linux/fsnotify.h>
12 #include <linux/security.h>
13 #include <linux/msdos_fs.h>
14 #include <linux/writeback.h>
15 #include <linux/filelock.h>
16 #include <linux/falloc.h>
17 #include <linux/fileattr.h>
18 #include <linux/iomap.h>
19 #include <linux/pagemap.h>
20
21 #include "exfat_raw.h"
22 #include "exfat_fs.h"
23 #include "iomap.h"
24
exfat_cont_expand(struct inode * inode,loff_t size)25 static int exfat_cont_expand(struct inode *inode, loff_t size)
26 {
27 int ret;
28 unsigned int num_clusters, new_num_clusters, last_clu;
29 struct exfat_inode_info *ei = EXFAT_I(inode);
30 struct super_block *sb = inode->i_sb;
31 struct exfat_sb_info *sbi = EXFAT_SB(sb);
32 struct exfat_chain clu;
33 loff_t oldsize = i_size_read(inode);
34
35 truncate_pagecache(inode, oldsize);
36
37 ret = inode_newsize_ok(inode, size);
38 if (ret)
39 return ret;
40
41 num_clusters = exfat_bytes_to_cluster(sbi, exfat_ondisk_size(inode));
42 /* integer overflow is already checked in inode_newsize_ok(). */
43 new_num_clusters = exfat_bytes_to_cluster_round_up(sbi, size);
44
45 if (new_num_clusters == num_clusters)
46 goto out;
47
48 if (num_clusters) {
49 exfat_chain_set(&clu, ei->start_clu, num_clusters, ei->flags);
50 ret = exfat_find_last_cluster(sb, &clu, &last_clu);
51 if (ret)
52 return ret;
53
54 clu.dir = last_clu + 1;
55 } else {
56 last_clu = EXFAT_EOF_CLUSTER;
57 clu.dir = EXFAT_EOF_CLUSTER;
58 }
59
60 clu.size = 0;
61 clu.flags = ei->flags;
62
63 ret = exfat_alloc_cluster(inode, new_num_clusters - num_clusters,
64 &clu, inode_needs_sync(inode), false);
65 if (ret)
66 return ret;
67
68 /* Append new clusters to chain */
69 if (num_clusters) {
70 if (clu.flags != ei->flags)
71 if (exfat_chain_cont_cluster(sb, ei->start_clu, num_clusters))
72 goto free_clu;
73
74 if (clu.flags == ALLOC_FAT_CHAIN)
75 if (exfat_ent_set(sb, last_clu, clu.dir))
76 goto free_clu;
77 } else
78 ei->start_clu = clu.dir;
79
80 ei->flags = clu.flags;
81
82 out:
83 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
84 /* Expanded range not zeroed, do not update valid_size */
85 i_size_write(inode, size);
86 /*
87 * When extending file size, call truncate_pagecache() first,
88 * then update i_size, and call pagecache_isize_extended()
89 * to ensures the straddling folio is properly marked RO so
90 * page_mkwrite() is called and post-EOF area is zeroed.
91 */
92 pagecache_isize_extended(inode, oldsize, inode->i_size);
93
94 inode->i_blocks = round_up(size, sbi->cluster_size) >> 9;
95 mark_inode_dirty(inode);
96
97 if (IS_SYNC(inode))
98 return write_inode_now(inode, 1);
99
100 return 0;
101
102 free_clu:
103 exfat_free_cluster(inode, &clu);
104 return -EIO;
105 }
106
107 /*
108 * Preallocate space for a file. This implements exfat's fallocate file
109 * operation, which gets called from sys_fallocate system call. User space
110 * requests len bytes at offset. In contrary to fat, we only support
111 * FALLOC_FL_ALLOCATE_RANGE because by leaving the valid data length(VDL)
112 * field, it is unnecessary to zero out the newly allocated clusters.
113 */
exfat_fallocate(struct file * file,int mode,loff_t offset,loff_t len)114 static long exfat_fallocate(struct file *file, int mode,
115 loff_t offset, loff_t len)
116 {
117 struct inode *inode = file->f_mapping->host;
118 loff_t newsize = offset + len;
119 int err = 0;
120
121 /* No support for other modes */
122 if (mode != FALLOC_FL_ALLOCATE_RANGE)
123 return -EOPNOTSUPP;
124
125 /* No support for dir */
126 if (!S_ISREG(inode->i_mode))
127 return -EOPNOTSUPP;
128
129 if (unlikely(exfat_forced_shutdown(inode->i_sb)))
130 return -EIO;
131
132 inode_lock(inode);
133
134 if (newsize <= i_size_read(inode))
135 goto error;
136
137 /* This is just an expanding truncate */
138 err = exfat_cont_expand(inode, newsize);
139
140 error:
141 inode_unlock(inode);
142
143 return err;
144 }
145
exfat_allow_set_time(const struct mnt_idmap * idmap,struct exfat_sb_info * sbi,struct inode * inode)146 static bool exfat_allow_set_time(const struct mnt_idmap *idmap,
147 struct exfat_sb_info *sbi, struct inode *inode)
148 {
149 mode_t allow_utime = sbi->options.allow_utime;
150
151 if (!vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode),
152 current_fsuid())) {
153 if (vfsgid_in_group_p(i_gid_into_vfsgid(idmap, inode)))
154 allow_utime >>= 3;
155 if (allow_utime & MAY_WRITE)
156 return true;
157 }
158
159 /* use a default check */
160 return false;
161 }
162
exfat_sanitize_mode(const struct exfat_sb_info * sbi,struct inode * inode,umode_t * mode_ptr)163 static int exfat_sanitize_mode(const struct exfat_sb_info *sbi,
164 struct inode *inode, umode_t *mode_ptr)
165 {
166 mode_t i_mode, mask, perm;
167
168 i_mode = inode->i_mode;
169
170 mask = (S_ISREG(i_mode) || S_ISLNK(i_mode)) ?
171 sbi->options.fs_fmask : sbi->options.fs_dmask;
172 perm = *mode_ptr & ~(S_IFMT | mask);
173
174 /* Of the r and x bits, all (subject to umask) must be present.*/
175 if ((perm & 0555) != (i_mode & 0555))
176 return -EPERM;
177
178 if (exfat_mode_can_hold_ro(inode)) {
179 /*
180 * Of the w bits, either all (subject to umask) or none must
181 * be present.
182 */
183 if ((perm & 0222) && ((perm & 0222) != (0222 & ~mask)))
184 return -EPERM;
185 } else {
186 /*
187 * If exfat_mode_can_hold_ro(inode) is false, can't change
188 * w bits.
189 */
190 if ((perm & 0222) != (0222 & ~mask))
191 return -EPERM;
192 }
193
194 *mode_ptr &= S_IFMT | perm;
195
196 return 0;
197 }
198
199 /* resize the file length */
__exfat_truncate(struct inode * inode)200 int __exfat_truncate(struct inode *inode)
201 {
202 unsigned int num_clusters_new, num_clusters_phys;
203 unsigned int last_clu = EXFAT_FREE_CLUSTER;
204 struct exfat_chain clu;
205 struct super_block *sb = inode->i_sb;
206 struct exfat_sb_info *sbi = EXFAT_SB(sb);
207 struct exfat_inode_info *ei = EXFAT_I(inode);
208
209 /* check if the given file ID is opened */
210 if (ei->type != TYPE_FILE && ei->type != TYPE_DIR)
211 return -EPERM;
212
213 exfat_set_volume_dirty(sb);
214
215 num_clusters_new = exfat_bytes_to_cluster_round_up(sbi, i_size_read(inode));
216 num_clusters_phys = exfat_bytes_to_cluster(sbi, exfat_ondisk_size(inode));
217
218 exfat_chain_set(&clu, ei->start_clu, num_clusters_phys, ei->flags);
219
220 if (i_size_read(inode) > 0) {
221 /*
222 * Truncate FAT chain num_clusters after the first cluster
223 * num_clusters = min(new, phys);
224 */
225 unsigned int num_clusters =
226 min(num_clusters_new, num_clusters_phys);
227
228 /*
229 * Follow FAT chain
230 * (defensive coding - works fine even with corrupted FAT table
231 */
232 if (clu.flags == ALLOC_NO_FAT_CHAIN) {
233 clu.dir += num_clusters;
234 clu.size -= num_clusters;
235 } else {
236 while (num_clusters > 0) {
237 last_clu = clu.dir;
238 if (exfat_get_next_cluster(sb, &(clu.dir)))
239 return -EIO;
240
241 num_clusters--;
242 clu.size--;
243 }
244 }
245 } else {
246 ei->flags = ALLOC_NO_FAT_CHAIN;
247 ei->start_clu = EXFAT_EOF_CLUSTER;
248 }
249
250 if (i_size_read(inode) < ei->valid_size)
251 ei->valid_size = ei->zeroed_size = i_size_read(inode);
252
253 if (ei->type == TYPE_FILE)
254 ei->attr |= EXFAT_ATTR_ARCHIVE;
255
256 /*
257 * update the directory entry
258 *
259 * If the directory entry is updated by mark_inode_dirty(), the
260 * directory entry will be written after a writeback cycle of
261 * updating the bitmap/FAT, which may result in clusters being
262 * freed but referenced by the directory entry in the event of a
263 * sudden power failure.
264 * __exfat_write_inode() is called for directory entry, bitmap
265 * and FAT to be written in a same writeback.
266 */
267 if (__exfat_write_inode(inode, inode_needs_sync(inode)))
268 return -EIO;
269
270 /* cut off from the FAT chain */
271 if (ei->flags == ALLOC_FAT_CHAIN && last_clu != EXFAT_FREE_CLUSTER &&
272 last_clu != EXFAT_EOF_CLUSTER) {
273 if (exfat_ent_set(sb, last_clu, EXFAT_EOF_CLUSTER))
274 return -EIO;
275 }
276
277 /* invalidate cache and free the clusters */
278 /* clear exfat cache */
279 exfat_cache_inval_inode(inode);
280
281 /* hint information */
282 ei->hint_bmap.off = EXFAT_EOF_CLUSTER;
283 ei->hint_bmap.clu = EXFAT_EOF_CLUSTER;
284
285 /* hint_stat will be used if this is directory. */
286 ei->hint_stat.eidx = 0;
287 ei->hint_stat.clu = ei->start_clu;
288 ei->hint_femp.eidx = EXFAT_HINT_NONE;
289
290 /* free the clusters */
291 if (exfat_free_cluster(inode, &clu))
292 return -EIO;
293
294 return 0;
295 }
296
exfat_truncate(struct inode * inode)297 static void exfat_truncate(struct inode *inode)
298 {
299 struct super_block *sb = inode->i_sb;
300 struct exfat_sb_info *sbi = EXFAT_SB(sb);
301 struct exfat_inode_info *ei = EXFAT_I(inode);
302 int err;
303
304 mutex_lock(&sbi->s_lock);
305 if (ei->start_clu == 0) {
306 /*
307 * Empty start_clu != ~0 (not allocated)
308 */
309 exfat_fs_error(sb, "tried to truncate zeroed cluster.");
310 goto write_size;
311 }
312
313 err = __exfat_truncate(inode);
314 if (err)
315 goto write_size;
316
317 inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9;
318 write_size:
319 mutex_unlock(&sbi->s_lock);
320 }
321
exfat_getattr(const struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,unsigned int request_mask,unsigned int query_flags)322 int exfat_getattr(const struct mnt_idmap *idmap, const struct path *path,
323 struct kstat *stat, unsigned int request_mask,
324 unsigned int query_flags)
325 {
326 struct inode *inode = d_backing_inode(path->dentry);
327 struct exfat_inode_info *ei = EXFAT_I(inode);
328
329 generic_fillattr(idmap, request_mask, inode, stat);
330 exfat_truncate_atime(&stat->atime);
331 stat->result_mask |= STATX_BTIME;
332 stat->btime.tv_sec = ei->i_crtime.tv_sec;
333 stat->btime.tv_nsec = ei->i_crtime.tv_nsec;
334 stat->blksize = EXFAT_SB(inode->i_sb)->cluster_size;
335 return 0;
336 }
337
exfat_fileattr_get(struct dentry * dentry,struct file_kattr * fa)338 int exfat_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
339 {
340 /*
341 * exFAT compares filenames through an upcase table, so lookup
342 * is always case-insensitive. Long names are stored in UTF-16
343 * with case intact; CASENONPRESERVING stays clear.
344 */
345 fa->fsx_xflags |= FS_XFLAG_CASEFOLD;
346 fa->flags |= FS_CASEFOLD_FL;
347 return 0;
348 }
349
exfat_setattr(const struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)350 int exfat_setattr(const struct mnt_idmap *idmap, struct dentry *dentry,
351 struct iattr *attr)
352 {
353 struct exfat_sb_info *sbi = EXFAT_SB(dentry->d_sb);
354 struct inode *inode = dentry->d_inode;
355 unsigned int ia_valid;
356 int error;
357
358 if (unlikely(exfat_forced_shutdown(inode->i_sb)))
359 return -EIO;
360
361 if ((attr->ia_valid & ATTR_SIZE) &&
362 attr->ia_size > i_size_read(inode)) {
363 error = exfat_cont_expand(inode, attr->ia_size);
364 if (error || attr->ia_valid == ATTR_SIZE)
365 return error;
366 attr->ia_valid &= ~ATTR_SIZE;
367 }
368
369 /* Check for setting the inode time. */
370 ia_valid = attr->ia_valid;
371 if ((ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET | ATTR_TIMES_SET)) &&
372 exfat_allow_set_time(idmap, sbi, inode)) {
373 attr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET |
374 ATTR_TIMES_SET);
375 }
376
377 error = setattr_prepare(idmap, dentry, attr);
378 attr->ia_valid = ia_valid;
379 if (error)
380 goto out;
381
382 if (((attr->ia_valid & ATTR_UID) &&
383 (!uid_eq(from_vfsuid(idmap, i_user_ns(inode), attr->ia_vfsuid),
384 sbi->options.fs_uid))) ||
385 ((attr->ia_valid & ATTR_GID) &&
386 (!gid_eq(from_vfsgid(idmap, i_user_ns(inode), attr->ia_vfsgid),
387 sbi->options.fs_gid))) ||
388 ((attr->ia_valid & ATTR_MODE) &&
389 (attr->ia_mode & ~(S_IFREG | S_IFLNK | S_IFDIR | 0777)))) {
390 error = -EPERM;
391 goto out;
392 }
393
394 /*
395 * We don't return -EPERM here. Yes, strange, but this is too
396 * old behavior.
397 */
398 if (attr->ia_valid & ATTR_MODE) {
399 if (exfat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0)
400 attr->ia_valid &= ~ATTR_MODE;
401 }
402
403 if (attr->ia_valid & ATTR_SIZE)
404 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
405
406 setattr_copy(idmap, inode, attr);
407 exfat_truncate_inode_atime(inode);
408
409 if (attr->ia_valid & ATTR_SIZE) {
410 /*
411 * Wait for any in-flight DIO to finish before truncating to
412 * prevent a concurrent DIO from writing to clusters that are
413 * about to be freed.
414 */
415 inode_dio_wait(inode);
416 truncate_setsize(inode, attr->ia_size);
417
418 /*
419 * __exfat_write_inode() is called from exfat_truncate(), inode
420 * is already written by it, so mark_inode_dirty() is unneeded.
421 */
422 exfat_truncate(inode);
423 } else
424 mark_inode_dirty(inode);
425
426 out:
427 return error;
428 }
429
430 /*
431 * modified ioctls from fat/file.c by Welmer Almesberger
432 */
exfat_ioctl_get_attributes(struct inode * inode,u32 __user * user_attr)433 static int exfat_ioctl_get_attributes(struct inode *inode, u32 __user *user_attr)
434 {
435 u32 attr;
436
437 inode_lock_shared(inode);
438 attr = exfat_make_attr(inode);
439 inode_unlock_shared(inode);
440
441 return put_user(attr, user_attr);
442 }
443
exfat_ioctl_set_attributes(struct file * file,u32 __user * user_attr)444 static int exfat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
445 {
446 struct inode *inode = file_inode(file);
447 struct exfat_sb_info *sbi = EXFAT_SB(inode->i_sb);
448 int is_dir = S_ISDIR(inode->i_mode);
449 u32 attr, oldattr;
450 struct iattr ia;
451 int err;
452
453 err = get_user(attr, user_attr);
454 if (err)
455 goto out;
456
457 err = mnt_want_write_file(file);
458 if (err)
459 goto out;
460 inode_lock(inode);
461
462 oldattr = exfat_make_attr(inode);
463
464 /*
465 * Mask attributes so we don't set reserved fields.
466 */
467 attr &= (EXFAT_ATTR_READONLY | EXFAT_ATTR_HIDDEN | EXFAT_ATTR_SYSTEM |
468 EXFAT_ATTR_ARCHIVE);
469 attr |= (is_dir ? EXFAT_ATTR_SUBDIR : 0);
470
471 /* Equivalent to a chmod() */
472 ia.ia_valid = ATTR_MODE | ATTR_CTIME;
473 ia.ia_ctime = current_time(inode);
474 if (is_dir)
475 ia.ia_mode = exfat_make_mode(sbi, attr, 0777);
476 else
477 ia.ia_mode = exfat_make_mode(sbi, attr, 0666 | (inode->i_mode & 0111));
478
479 /* The root directory has no attributes */
480 if (inode->i_ino == EXFAT_ROOT_INO && attr != EXFAT_ATTR_SUBDIR) {
481 err = -EINVAL;
482 goto out_unlock_inode;
483 }
484
485 if (((attr | oldattr) & EXFAT_ATTR_SYSTEM) &&
486 !capable(CAP_LINUX_IMMUTABLE)) {
487 err = -EPERM;
488 goto out_unlock_inode;
489 }
490
491 /*
492 * The security check is questionable... We single
493 * out the RO attribute for checking by the security
494 * module, just because it maps to a file mode.
495 */
496 err = security_inode_setattr(file_mnt_idmap(file),
497 file->f_path.dentry, &ia);
498 if (err)
499 goto out_unlock_inode;
500
501 /* This MUST be done before doing anything irreversible... */
502 err = exfat_setattr(file_mnt_idmap(file), file->f_path.dentry, &ia);
503 if (err)
504 goto out_unlock_inode;
505
506 fsnotify_change(file->f_path.dentry, ia.ia_valid);
507
508 exfat_save_attr(inode, attr);
509 mark_inode_dirty(inode);
510 out_unlock_inode:
511 inode_unlock(inode);
512 mnt_drop_write_file(file);
513 out:
514 return err;
515 }
516
exfat_ioctl_fitrim(struct inode * inode,unsigned long arg)517 static int exfat_ioctl_fitrim(struct inode *inode, unsigned long arg)
518 {
519 struct fstrim_range range;
520 int ret = 0;
521
522 if (!capable(CAP_SYS_ADMIN))
523 return -EPERM;
524
525 if (!bdev_max_discard_sectors(inode->i_sb->s_bdev))
526 return -EOPNOTSUPP;
527
528 if (copy_from_user(&range, (struct fstrim_range __user *)arg, sizeof(range)))
529 return -EFAULT;
530
531 range.minlen = max_t(unsigned int, range.minlen,
532 bdev_discard_granularity(inode->i_sb->s_bdev));
533
534 ret = exfat_trim_fs(inode, &range);
535 if (ret < 0)
536 return ret;
537
538 if (copy_to_user((struct fstrim_range __user *)arg, &range, sizeof(range)))
539 return -EFAULT;
540
541 return 0;
542 }
543
exfat_ioctl_shutdown(struct super_block * sb,unsigned long arg)544 static int exfat_ioctl_shutdown(struct super_block *sb, unsigned long arg)
545 {
546 u32 flags;
547
548 if (!capable(CAP_SYS_ADMIN))
549 return -EPERM;
550
551 if (get_user(flags, (__u32 __user *)arg))
552 return -EFAULT;
553
554 return exfat_force_shutdown(sb, flags);
555 }
556
exfat_ioctl_get_volume_label(struct super_block * sb,unsigned long arg)557 static int exfat_ioctl_get_volume_label(struct super_block *sb, unsigned long arg)
558 {
559 int ret;
560 char label[FSLABEL_MAX] = {0};
561 struct exfat_uni_name uniname;
562
563 ret = exfat_read_volume_label(sb, &uniname);
564 if (ret < 0)
565 return ret;
566
567 ret = exfat_utf16_to_nls(sb, &uniname, label, sizeof(label));
568 if (ret < 0)
569 return ret;
570
571 if (copy_to_user((char __user *)arg, label, ret + 1))
572 return -EFAULT;
573
574 return 0;
575 }
576
exfat_ioctl_set_volume_label(struct super_block * sb,unsigned long arg)577 static int exfat_ioctl_set_volume_label(struct super_block *sb,
578 unsigned long arg)
579 {
580 int ret = 0, lossy, label_len;
581 char label[FSLABEL_MAX] = {0};
582 struct exfat_uni_name uniname;
583
584 if (!capable(CAP_SYS_ADMIN))
585 return -EPERM;
586
587 if (copy_from_user(label, (char __user *)arg, FSLABEL_MAX))
588 return -EFAULT;
589
590 memset(&uniname, 0, sizeof(uniname));
591 label_len = strnlen(label, FSLABEL_MAX - 1);
592 if (label[0]) {
593 ret = exfat_nls_to_utf16(sb, label, label_len,
594 &uniname, &lossy);
595 if (ret < 0)
596 return ret;
597 else if (lossy & NLS_NAME_LOSSY)
598 return -EINVAL;
599 }
600
601 uniname.name_len = ret;
602
603 return exfat_write_volume_label(sb, &uniname);
604 }
605
exfat_ioctl(struct file * filp,unsigned int cmd,unsigned long arg)606 long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
607 {
608 struct inode *inode = file_inode(filp);
609 u32 __user *user_attr = (u32 __user *)arg;
610
611 switch (cmd) {
612 case FAT_IOCTL_GET_ATTRIBUTES:
613 return exfat_ioctl_get_attributes(inode, user_attr);
614 case FAT_IOCTL_SET_ATTRIBUTES:
615 return exfat_ioctl_set_attributes(filp, user_attr);
616 case EXFAT_IOC_SHUTDOWN:
617 return exfat_ioctl_shutdown(inode->i_sb, arg);
618 case FITRIM:
619 return exfat_ioctl_fitrim(inode, arg);
620 case FS_IOC_GETFSLABEL:
621 return exfat_ioctl_get_volume_label(inode->i_sb, arg);
622 case FS_IOC_SETFSLABEL:
623 return exfat_ioctl_set_volume_label(inode->i_sb, arg);
624 default:
625 return -ENOTTY;
626 }
627 }
628
629 #ifdef CONFIG_COMPAT
exfat_compat_ioctl(struct file * filp,unsigned int cmd,unsigned long arg)630 long exfat_compat_ioctl(struct file *filp, unsigned int cmd,
631 unsigned long arg)
632 {
633 return exfat_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
634 }
635 #endif
636
exfat_file_fsync(struct file * filp,loff_t start,loff_t end,int datasync)637 int exfat_file_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
638 {
639 struct inode *inode = filp->f_mapping->host;
640 int err;
641
642 if (unlikely(exfat_forced_shutdown(inode->i_sb)))
643 return -EIO;
644
645 err = simple_fsync_noflush(filp, start, end, datasync);
646 if (err)
647 return err;
648
649 err = sync_blockdev(inode->i_sb->s_bdev);
650 if (err)
651 return err;
652
653 return blkdev_issue_flush(inode->i_sb->s_bdev);
654 }
655
656 /*
657 * exfat_zero_new_range - zero [start, end) without overwriting uptodate blocks
658 *
659 * Uptodate blocks may contain data written through a shared mapping beyond
660 * valid_size.
661 */
exfat_zero_new_range(struct inode * inode,loff_t start,loff_t end)662 static int exfat_zero_new_range(struct inode *inode, loff_t start, loff_t end)
663 {
664 struct address_space *mapping = inode->i_mapping;
665 unsigned int blocksize = i_blocksize(inode);
666 loff_t pos = start;
667 int err;
668
669 while (pos < end) {
670 loff_t next = min_t(loff_t,
671 round_down(pos, PAGE_SIZE) + PAGE_SIZE, end);
672 struct folio *folio;
673 loff_t bpos;
674
675 folio = filemap_get_folio(mapping, pos >> PAGE_SHIFT);
676 if (IS_ERR(folio)) {
677 err = iomap_zero_range(inode, pos, next - pos, NULL,
678 &exfat_iomap_ops, NULL, NULL);
679 if (err < 0)
680 return err;
681 pos = next;
682 continue;
683 }
684
685 if (folio_test_uptodate(folio)) {
686 folio_lock(folio);
687 if (folio->mapping == mapping)
688 folio_mark_dirty(folio);
689 folio_unlock(folio);
690 folio_put(folio);
691 pos = next;
692 continue;
693 }
694
695 /*
696 * Zero not-uptodate block runs. iomap_zero_range() requires an
697 * unlocked folio, so recheck ->mapping after each call.
698 */
699 folio_lock(folio);
700 bpos = pos;
701 while (bpos < next) {
702 loff_t rstart, rend;
703
704 if (folio->mapping != mapping) {
705 folio_unlock(folio);
706 err = iomap_zero_range(inode, bpos, next - bpos,
707 NULL, &exfat_iomap_ops, NULL, NULL);
708 if (err < 0) {
709 folio_put(folio);
710 return err;
711 }
712 folio_lock(folio);
713 break;
714 }
715
716 if (iomap_is_partially_uptodate(folio,
717 offset_in_folio(folio, bpos), blocksize)) {
718 bpos += blocksize;
719 continue;
720 }
721
722 rstart = bpos;
723 rend = min_t(loff_t, bpos + blocksize, next);
724 while (rend < next &&
725 !iomap_is_partially_uptodate(folio,
726 offset_in_folio(folio, rend), blocksize))
727 rend = min_t(loff_t, rend + blocksize, next);
728
729 folio_unlock(folio);
730 err = iomap_zero_range(inode, rstart, rend - rstart,
731 NULL, &exfat_iomap_ops, NULL, NULL);
732 if (err < 0) {
733 folio_put(folio);
734 return err;
735 }
736 folio_lock(folio);
737 bpos = rend;
738 }
739
740 /*
741 * Dirty only a fully uptodate folio. Dirtying a partial folio could
742 * write uninitialised cache contents over valid on-disk blocks.
743 */
744 if (folio->mapping == mapping && folio_test_uptodate(folio))
745 folio_mark_dirty(folio);
746 folio_unlock(folio);
747 folio_put(folio);
748 pos = next;
749 }
750
751 return 0;
752 }
753
exfat_extend_valid_size(struct inode * inode,loff_t new_valid_size)754 static int exfat_extend_valid_size(struct inode *inode, loff_t new_valid_size)
755 {
756 struct exfat_inode_info *ei = EXFAT_I(inode);
757 loff_t old_valid_size = ei->valid_size;
758 int ret = 0;
759
760 if (old_valid_size < new_valid_size) {
761 /* Do not re-zero blocks already covered by zeroed_size. */
762 loff_t gap_start = max(old_valid_size, ei->zeroed_size);
763
764 if (i_size_read(inode) < new_valid_size) {
765 /*
766 * Allocate clusters before increasing i_size. The gap
767 * may already be zeroed, so the subsequent zeroing
768 * can be skipped.
769 */
770 ret = exfat_cont_expand(inode, new_valid_size);
771 if (ret)
772 return ret;
773 }
774
775 /*
776 * Revoke writable PTEs while zeroing the gap. A racing mmap
777 * store re-faults through exfat_page_mkwrite() after valid_size
778 * is updated.
779 */
780 filemap_invalidate_lock(inode->i_mapping);
781 if (gap_start < new_valid_size)
782 unmap_mapping_range(inode->i_mapping, gap_start,
783 new_valid_size - gap_start, 0);
784 ret = exfat_zero_new_range(inode, gap_start, new_valid_size);
785 filemap_invalidate_unlock(inode->i_mapping);
786 if (ret) {
787 truncate_setsize(inode, old_valid_size);
788 exfat_truncate(inode);
789 return ret;
790 }
791
792 ei->valid_size = new_valid_size;
793 if (ei->zeroed_size < round_up(new_valid_size, i_blocksize(inode)))
794 ei->zeroed_size = round_up(new_valid_size, i_blocksize(inode));
795 mark_inode_dirty(inode);
796 }
797
798 return ret;
799 }
800
exfat_fallback_buffered_write(struct kiocb * iocb,struct iov_iter * from)801 static ssize_t exfat_fallback_buffered_write(struct kiocb *iocb,
802 struct iov_iter *from)
803 {
804 loff_t offset = iocb->ki_pos, end;
805 ssize_t written;
806 int ret;
807
808 iocb->ki_flags &= ~IOCB_DIRECT;
809
810 written = iomap_file_buffered_write(iocb, from, &exfat_write_iomap_ops,
811 NULL, NULL);
812 if (written < 0)
813 return written;
814
815 end = iocb->ki_pos + written - 1;
816 ret = filemap_write_and_wait_range(iocb->ki_filp->f_mapping,
817 offset, end);
818 if (ret)
819 return -EIO;
820
821 invalidate_mapping_pages(iocb->ki_filp->f_mapping,
822 offset >> PAGE_SHIFT,
823 end >> PAGE_SHIFT);
824
825 return written;
826 }
827
exfat_dio_write_iter(struct kiocb * iocb,struct iov_iter * from)828 static ssize_t exfat_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
829 {
830 ssize_t ret;
831
832 ret = iomap_dio_rw(iocb, from, &exfat_write_iomap_ops,
833 &exfat_write_dio_ops, 0, NULL, 0);
834 if (ret == -ENOTBLK)
835 ret = 0;
836 else if (ret < 0)
837 return ret;
838
839 if (iov_iter_count(from)) {
840 ssize_t written;
841
842 written = exfat_fallback_buffered_write(iocb, from);
843 if (written < 0)
844 return written;
845 ret += written;
846 }
847
848 return ret;
849 }
850
exfat_file_write_iter(struct kiocb * iocb,struct iov_iter * iter)851 static ssize_t exfat_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
852 {
853 ssize_t ret;
854 struct file *file = iocb->ki_filp;
855 struct inode *inode = file_inode(file);
856 struct exfat_inode_info *ei = EXFAT_I(inode);
857 loff_t pos = iocb->ki_pos;
858 loff_t valid_size;
859 int err;
860
861 if (unlikely(exfat_forced_shutdown(inode->i_sb)))
862 return -EIO;
863
864 inode_lock(inode);
865
866 if (pos > i_size_read(inode))
867 truncate_pagecache(inode, i_size_read(inode));
868
869 valid_size = ei->valid_size;
870
871 ret = generic_write_checks(iocb, iter);
872 if (ret <= 0)
873 goto unlock;
874
875 err = file_modified(iocb->ki_filp);
876 if (err) {
877 ret = err;
878 goto unlock;
879 }
880
881 if (pos > valid_size) {
882 ret = exfat_extend_valid_size(inode, pos);
883 if (ret < 0 && ret != -ENOSPC) {
884 exfat_err(inode->i_sb,
885 "write: fail to zero from %llu to %llu(%zd)",
886 valid_size, pos, ret);
887 }
888 if (ret < 0)
889 goto unlock;
890 }
891
892 if (iocb->ki_flags & IOCB_DIRECT)
893 ret = exfat_dio_write_iter(iocb, iter);
894 else
895 ret = iomap_file_buffered_write(iocb, iter,
896 &exfat_write_iomap_ops, NULL, NULL);
897 if (ret < 0)
898 goto unlock;
899
900 inode_unlock(inode);
901
902 if (pos > valid_size)
903 pos = valid_size;
904
905 if (iocb->ki_pos > pos) {
906 ssize_t err = generic_write_sync(iocb, iocb->ki_pos - pos);
907
908 if (err < 0)
909 return err;
910 }
911
912 return ret;
913
914 unlock:
915 inode_unlock(inode);
916
917 return ret;
918 }
919
exfat_file_read_iter(struct kiocb * iocb,struct iov_iter * iter)920 static ssize_t exfat_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
921 {
922 struct inode *inode = file_inode(iocb->ki_filp);
923 ssize_t ret;
924
925 if (unlikely(exfat_forced_shutdown(inode->i_sb)))
926 return -EIO;
927
928 inode_lock_shared(inode);
929
930 if (iocb->ki_flags & IOCB_DIRECT) {
931 file_accessed(iocb->ki_filp);
932 ret = iomap_dio_rw(iocb, iter, &exfat_iomap_ops, NULL, 0,
933 NULL, 0);
934 } else {
935 ret = generic_file_read_iter(iocb, iter);
936 }
937
938 inode_unlock_shared(inode);
939
940 return ret;
941 }
942
exfat_page_mkwrite(struct vm_fault * vmf)943 static vm_fault_t exfat_page_mkwrite(struct vm_fault *vmf)
944 {
945 struct inode *inode = file_inode(vmf->vma->vm_file);
946 struct exfat_inode_info *ei = EXFAT_I(inode);
947 vm_fault_t ret;
948 loff_t new_valid_size, mmap_valid_size, fault_page_start;
949
950 if (!inode_trylock(inode))
951 return VM_FAULT_RETRY;
952
953 mmap_valid_size = ((loff_t)vmf->pgoff + 1) << PAGE_SHIFT;
954 fault_page_start = ((loff_t)vmf->pgoff) << PAGE_SHIFT;
955 new_valid_size = min(mmap_valid_size, i_size_read(inode));
956
957 if (ei->valid_size < new_valid_size) {
958 if (ei->zeroed_size < fault_page_start) {
959 int err;
960
961 /*
962 * Zero only the gap below the faulting page. The read
963 * fault populated its folio and iomap_page_mkwrite()
964 * will dirty it.
965 */
966 err = exfat_zero_new_range(inode, ei->zeroed_size,
967 fault_page_start);
968 if (err < 0) {
969 inode_unlock(inode);
970 return vmf_fs_error(err);
971 }
972 }
973
974 /*
975 * Track zeroed_size by block, not page, because writeback stops
976 * at i_size recording blocks wholly beyond it could skip a
977 * later required zeroing.
978 */
979 if (ei->zeroed_size < round_up(new_valid_size, i_blocksize(inode)))
980 ei->zeroed_size = round_up(new_valid_size, i_blocksize(inode));
981 ei->valid_size = new_valid_size;
982 mark_inode_dirty(inode);
983 }
984
985 sb_start_pagefault(inode->i_sb);
986 file_update_time(vmf->vma->vm_file);
987
988 filemap_invalidate_lock_shared(inode->i_mapping);
989 ret = iomap_page_mkwrite(vmf, &exfat_iomap_ops, NULL);
990 filemap_invalidate_unlock_shared(inode->i_mapping);
991 sb_end_pagefault(inode->i_sb);
992 inode_unlock(inode);
993
994 return ret;
995 }
996
997 static const struct vm_operations_struct exfat_file_vm_ops = {
998 .fault = filemap_fault,
999 .page_mkwrite = exfat_page_mkwrite,
1000 };
1001
exfat_file_mmap_prepare(struct vm_area_desc * desc)1002 static int exfat_file_mmap_prepare(struct vm_area_desc *desc)
1003 {
1004 struct file *file = desc->file;
1005
1006 if (unlikely(exfat_forced_shutdown(file_inode(desc->file)->i_sb)))
1007 return -EIO;
1008
1009 file_accessed(file);
1010 desc->vm_ops = &exfat_file_vm_ops;
1011 return 0;
1012 }
1013
exfat_splice_read(struct file * in,loff_t * ppos,struct pipe_inode_info * pipe,size_t len,unsigned int flags)1014 static ssize_t exfat_splice_read(struct file *in, loff_t *ppos,
1015 struct pipe_inode_info *pipe, size_t len, unsigned int flags)
1016 {
1017 if (unlikely(exfat_forced_shutdown(file_inode(in)->i_sb)))
1018 return -EIO;
1019
1020 return filemap_splice_read(in, ppos, pipe, len, flags);
1021 }
1022
exfat_file_open(struct inode * inode,struct file * filp)1023 static int exfat_file_open(struct inode *inode, struct file *filp)
1024 {
1025 int err;
1026
1027 if (unlikely(exfat_forced_shutdown(inode->i_sb)))
1028 return -EIO;
1029
1030 err = generic_file_open(inode, filp);
1031 if (err)
1032 return err;
1033
1034 filp->f_mode |= FMODE_CAN_ODIRECT;
1035
1036 return 0;
1037 }
1038
exfat_file_llseek(struct file * file,loff_t offset,int whence)1039 static loff_t exfat_file_llseek(struct file *file, loff_t offset, int whence)
1040 {
1041 struct inode *inode = file->f_mapping->host;
1042
1043 switch (whence) {
1044 case SEEK_HOLE:
1045 inode_lock_shared(inode);
1046 offset = iomap_seek_hole(inode, offset, &exfat_iomap_ops);
1047 inode_unlock_shared(inode);
1048 break;
1049 case SEEK_DATA:
1050 inode_lock_shared(inode);
1051 offset = iomap_seek_data(inode, offset, &exfat_iomap_ops);
1052 inode_unlock_shared(inode);
1053 break;
1054 default:
1055 return generic_file_llseek(file, offset, whence);
1056 }
1057 if (offset < 0)
1058 return offset;
1059 return vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
1060 }
1061
1062 const struct file_operations exfat_file_operations = {
1063 .open = exfat_file_open,
1064 .llseek = exfat_file_llseek,
1065 .read_iter = exfat_file_read_iter,
1066 .write_iter = exfat_file_write_iter,
1067 .unlocked_ioctl = exfat_ioctl,
1068 #ifdef CONFIG_COMPAT
1069 .compat_ioctl = exfat_compat_ioctl,
1070 #endif
1071 .mmap_prepare = exfat_file_mmap_prepare,
1072 .fsync = exfat_file_fsync,
1073 .splice_read = exfat_splice_read,
1074 .splice_write = iter_file_splice_write,
1075 .fallocate = exfat_fallocate,
1076 .setlease = generic_setlease,
1077 };
1078
1079 const struct inode_operations exfat_file_inode_operations = {
1080 .setattr = exfat_setattr,
1081 .getattr = exfat_getattr,
1082 .fileattr_get = exfat_fileattr_get,
1083 };
1084