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