file.c revision dd854e4b
1// SPDX-License-Identifier: GPL-2.0
2/*
3 *
4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
5 *
6 *  Regular file handling primitives for NTFS-based filesystems.
7 *
8 */
9
10#include <linux/backing-dev.h>
11#include <linux/buffer_head.h>
12#include <linux/compat.h>
13#include <linux/falloc.h>
14#include <linux/fiemap.h>
15#include <linux/nls.h>
16
17#include "debug.h"
18#include "ntfs.h"
19#include "ntfs_fs.h"
20
21static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, unsigned long arg)
22{
23	struct fstrim_range __user *user_range;
24	struct fstrim_range range;
25	struct request_queue *q = bdev_get_queue(sbi->sb->s_bdev);
26	int err;
27
28	if (!capable(CAP_SYS_ADMIN))
29		return -EPERM;
30
31	if (!blk_queue_discard(q))
32		return -EOPNOTSUPP;
33
34	user_range = (struct fstrim_range __user *)arg;
35	if (copy_from_user(&range, user_range, sizeof(range)))
36		return -EFAULT;
37
38	range.minlen = max_t(u32, range.minlen, q->limits.discard_granularity);
39
40	err = ntfs_trim_fs(sbi, &range);
41	if (err < 0)
42		return err;
43
44	if (copy_to_user(user_range, &range, sizeof(range)))
45		return -EFAULT;
46
47	return 0;
48}
49
50static long ntfs_ioctl(struct file *filp, u32 cmd, unsigned long arg)
51{
52	struct inode *inode = file_inode(filp);
53	struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info;
54
55	switch (cmd) {
56	case FITRIM:
57		return ntfs_ioctl_fitrim(sbi, arg);
58	}
59	return -ENOTTY; /* Inappropriate ioctl for device. */
60}
61
62#ifdef CONFIG_COMPAT
63static long ntfs_compat_ioctl(struct file *filp, u32 cmd, unsigned long arg)
64
65{
66	return ntfs_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
67}
68#endif
69
70/*
71 * ntfs_getattr - inode_operations::getattr
72 */
73int ntfs_getattr(struct user_namespace *mnt_userns, const struct path *path,
74		 struct kstat *stat, u32 request_mask, u32 flags)
75{
76	struct inode *inode = d_inode(path->dentry);
77	struct ntfs_inode *ni = ntfs_i(inode);
78
79	if (is_compressed(ni))
80		stat->attributes |= STATX_ATTR_COMPRESSED;
81
82	if (is_encrypted(ni))
83		stat->attributes |= STATX_ATTR_ENCRYPTED;
84
85	stat->attributes_mask |= STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED;
86
87	generic_fillattr(mnt_userns, inode, stat);
88
89	stat->result_mask |= STATX_BTIME;
90	stat->btime = ni->i_crtime;
91	stat->blksize = ni->mi.sbi->cluster_size; /* 512, 1K, ..., 2M */
92
93	return 0;
94}
95
96static int ntfs_extend_initialized_size(struct file *file,
97					struct ntfs_inode *ni,
98					const loff_t valid,
99					const loff_t new_valid)
100{
101	struct inode *inode = &ni->vfs_inode;
102	struct address_space *mapping = inode->i_mapping;
103	struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info;
104	loff_t pos = valid;
105	int err;
106
107	if (is_resident(ni)) {
108		ni->i_valid = new_valid;
109		return 0;
110	}
111
112	WARN_ON(is_compressed(ni));
113	WARN_ON(valid >= new_valid);
114
115	for (;;) {
116		u32 zerofrom, len;
117		struct page *page;
118		void *fsdata;
119		u8 bits;
120		CLST vcn, lcn, clen;
121
122		if (is_sparsed(ni)) {
123			bits = sbi->cluster_bits;
124			vcn = pos >> bits;
125
126			err = attr_data_get_block(ni, vcn, 0, &lcn, &clen,
127						  NULL);
128			if (err)
129				goto out;
130
131			if (lcn == SPARSE_LCN) {
132				loff_t vbo = (loff_t)vcn << bits;
133				loff_t to = vbo + ((loff_t)clen << bits);
134
135				if (to <= new_valid) {
136					ni->i_valid = to;
137					pos = to;
138					goto next;
139				}
140
141				if (vbo < pos) {
142					pos = vbo;
143				} else {
144					to = (new_valid >> bits) << bits;
145					if (pos < to) {
146						ni->i_valid = to;
147						pos = to;
148						goto next;
149					}
150				}
151			}
152		}
153
154		zerofrom = pos & (PAGE_SIZE - 1);
155		len = PAGE_SIZE - zerofrom;
156
157		if (pos + len > new_valid)
158			len = new_valid - pos;
159
160		err = pagecache_write_begin(file, mapping, pos, len, 0, &page,
161					    &fsdata);
162		if (err)
163			goto out;
164
165		zero_user_segment(page, zerofrom, PAGE_SIZE);
166
167		/* This function in any case puts page. */
168		err = pagecache_write_end(file, mapping, pos, len, len, page,
169					  fsdata);
170		if (err < 0)
171			goto out;
172		pos += len;
173
174next:
175		if (pos >= new_valid)
176			break;
177
178		balance_dirty_pages_ratelimited(mapping);
179		cond_resched();
180	}
181
182	return 0;
183
184out:
185	ni->i_valid = valid;
186	ntfs_inode_warn(inode, "failed to extend initialized size to %llx.",
187			new_valid);
188	return err;
189}
190
191/*
192 * ntfs_zero_range - Helper function for punch_hole.
193 *
194 * It zeroes a range [vbo, vbo_to).
195 */
196static int ntfs_zero_range(struct inode *inode, u64 vbo, u64 vbo_to)
197{
198	int err = 0;
199	struct address_space *mapping = inode->i_mapping;
200	u32 blocksize = 1 << inode->i_blkbits;
201	pgoff_t idx = vbo >> PAGE_SHIFT;
202	u32 z_start = vbo & (PAGE_SIZE - 1);
203	pgoff_t idx_end = (vbo_to + PAGE_SIZE - 1) >> PAGE_SHIFT;
204	loff_t page_off;
205	struct buffer_head *head, *bh;
206	u32 bh_next, bh_off, z_end;
207	sector_t iblock;
208	struct page *page;
209
210	for (; idx < idx_end; idx += 1, z_start = 0) {
211		page_off = (loff_t)idx << PAGE_SHIFT;
212		z_end = (page_off + PAGE_SIZE) > vbo_to ? (vbo_to - page_off)
213							: PAGE_SIZE;
214		iblock = page_off >> inode->i_blkbits;
215
216		page = find_or_create_page(mapping, idx,
217					   mapping_gfp_constraint(mapping,
218								  ~__GFP_FS));
219		if (!page)
220			return -ENOMEM;
221
222		if (!page_has_buffers(page))
223			create_empty_buffers(page, blocksize, 0);
224
225		bh = head = page_buffers(page);
226		bh_off = 0;
227		do {
228			bh_next = bh_off + blocksize;
229
230			if (bh_next <= z_start || bh_off >= z_end)
231				continue;
232
233			if (!buffer_mapped(bh)) {
234				ntfs_get_block(inode, iblock, bh, 0);
235				/* Unmapped? It's a hole - nothing to do. */
236				if (!buffer_mapped(bh))
237					continue;
238			}
239
240			/* Ok, it's mapped. Make sure it's up-to-date. */
241			if (PageUptodate(page))
242				set_buffer_uptodate(bh);
243
244			if (!buffer_uptodate(bh)) {
245				lock_buffer(bh);
246				bh->b_end_io = end_buffer_read_sync;
247				get_bh(bh);
248				submit_bh(REQ_OP_READ, 0, bh);
249
250				wait_on_buffer(bh);
251				if (!buffer_uptodate(bh)) {
252					unlock_page(page);
253					put_page(page);
254					err = -EIO;
255					goto out;
256				}
257			}
258
259			mark_buffer_dirty(bh);
260
261		} while (bh_off = bh_next, iblock += 1,
262			 head != (bh = bh->b_this_page));
263
264		zero_user_segment(page, z_start, z_end);
265
266		unlock_page(page);
267		put_page(page);
268		cond_resched();
269	}
270out:
271	mark_inode_dirty(inode);
272	return err;
273}
274
275/*
276 * ntfs_sparse_cluster - Helper function to zero a new allocated clusters.
277 *
278 * NOTE: 512 <= cluster size <= 2M
279 */
280void ntfs_sparse_cluster(struct inode *inode, struct page *page0, CLST vcn,
281			 CLST len)
282{
283	struct address_space *mapping = inode->i_mapping;
284	struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info;
285	u64 vbo = (u64)vcn << sbi->cluster_bits;
286	u64 bytes = (u64)len << sbi->cluster_bits;
287	u32 blocksize = 1 << inode->i_blkbits;
288	pgoff_t idx0 = page0 ? page0->index : -1;
289	loff_t vbo_clst = vbo & sbi->cluster_mask_inv;
290	loff_t end = ntfs_up_cluster(sbi, vbo + bytes);
291	pgoff_t idx = vbo_clst >> PAGE_SHIFT;
292	u32 from = vbo_clst & (PAGE_SIZE - 1);
293	pgoff_t idx_end = (end + PAGE_SIZE - 1) >> PAGE_SHIFT;
294	loff_t page_off;
295	u32 to;
296	bool partial;
297	struct page *page;
298
299	for (; idx < idx_end; idx += 1, from = 0) {
300		page = idx == idx0 ? page0 : grab_cache_page(mapping, idx);
301
302		if (!page)
303			continue;
304
305		page_off = (loff_t)idx << PAGE_SHIFT;
306		to = (page_off + PAGE_SIZE) > end ? (end - page_off)
307						  : PAGE_SIZE;
308		partial = false;
309
310		if ((from || PAGE_SIZE != to) &&
311		    likely(!page_has_buffers(page))) {
312			create_empty_buffers(page, blocksize, 0);
313		}
314
315		if (page_has_buffers(page)) {
316			struct buffer_head *head, *bh;
317			u32 bh_off = 0;
318
319			bh = head = page_buffers(page);
320			do {
321				u32 bh_next = bh_off + blocksize;
322
323				if (from <= bh_off && bh_next <= to) {
324					set_buffer_uptodate(bh);
325					mark_buffer_dirty(bh);
326				} else if (!buffer_uptodate(bh)) {
327					partial = true;
328				}
329				bh_off = bh_next;
330			} while (head != (bh = bh->b_this_page));
331		}
332
333		zero_user_segment(page, from, to);
334
335		if (!partial) {
336			if (!PageUptodate(page))
337				SetPageUptodate(page);
338			set_page_dirty(page);
339		}
340
341		if (idx != idx0) {
342			unlock_page(page);
343			put_page(page);
344		}
345		cond_resched();
346	}
347	mark_inode_dirty(inode);
348}
349
350/*
351 * ntfs_file_mmap - file_operations::mmap
352 */
353static int ntfs_file_mmap(struct file *file, struct vm_area_struct *vma)
354{
355	struct address_space *mapping = file->f_mapping;
356	struct inode *inode = mapping->host;
357	struct ntfs_inode *ni = ntfs_i(inode);
358	u64 from = ((u64)vma->vm_pgoff << PAGE_SHIFT);
359	bool rw = vma->vm_flags & VM_WRITE;
360	int err;
361
362	if (is_encrypted(ni)) {
363		ntfs_inode_warn(inode, "mmap encrypted not supported");
364		return -EOPNOTSUPP;
365	}
366
367	if (is_dedup(ni)) {
368		ntfs_inode_warn(inode, "mmap deduplicated not supported");
369		return -EOPNOTSUPP;
370	}
371
372	if (is_compressed(ni) && rw) {
373		ntfs_inode_warn(inode, "mmap(write) compressed not supported");
374		return -EOPNOTSUPP;
375	}
376
377	if (rw) {
378		u64 to = min_t(loff_t, i_size_read(inode),
379			       from + vma->vm_end - vma->vm_start);
380
381		if (is_sparsed(ni)) {
382			/* Allocate clusters for rw map. */
383			struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info;
384			CLST lcn, len;
385			CLST vcn = from >> sbi->cluster_bits;
386			CLST end = bytes_to_cluster(sbi, to);
387			bool new;
388
389			for (; vcn < end; vcn += len) {
390				err = attr_data_get_block(ni, vcn, 1, &lcn,
391							  &len, &new);
392				if (err)
393					goto out;
394
395				if (!new)
396					continue;
397				ntfs_sparse_cluster(inode, NULL, vcn, 1);
398			}
399		}
400
401		if (ni->i_valid < to) {
402			if (!inode_trylock(inode)) {
403				err = -EAGAIN;
404				goto out;
405			}
406			err = ntfs_extend_initialized_size(file, ni,
407							   ni->i_valid, to);
408			inode_unlock(inode);
409			if (err)
410				goto out;
411		}
412	}
413
414	err = generic_file_mmap(file, vma);
415out:
416	return err;
417}
418
419static int ntfs_extend(struct inode *inode, loff_t pos, size_t count,
420		       struct file *file)
421{
422	struct ntfs_inode *ni = ntfs_i(inode);
423	struct address_space *mapping = inode->i_mapping;
424	loff_t end = pos + count;
425	bool extend_init = file && pos > ni->i_valid;
426	int err;
427
428	if (end <= inode->i_size && !extend_init)
429		return 0;
430
431	/* Mark rw ntfs as dirty. It will be cleared at umount. */
432	ntfs_set_state(ni->mi.sbi, NTFS_DIRTY_DIRTY);
433
434	if (end > inode->i_size) {
435		err = ntfs_set_size(inode, end);
436		if (err)
437			goto out;
438		inode->i_size = end;
439	}
440
441	if (extend_init && !is_compressed(ni)) {
442		err = ntfs_extend_initialized_size(file, ni, ni->i_valid, pos);
443		if (err)
444			goto out;
445	} else {
446		err = 0;
447	}
448
449	inode->i_ctime = inode->i_mtime = current_time(inode);
450	mark_inode_dirty(inode);
451
452	if (IS_SYNC(inode)) {
453		int err2;
454
455		err = filemap_fdatawrite_range(mapping, pos, end - 1);
456		err2 = sync_mapping_buffers(mapping);
457		if (!err)
458			err = err2;
459		err2 = write_inode_now(inode, 1);
460		if (!err)
461			err = err2;
462		if (!err)
463			err = filemap_fdatawait_range(mapping, pos, end - 1);
464	}
465
466out:
467	return err;
468}
469
470static int ntfs_truncate(struct inode *inode, loff_t new_size)
471{
472	struct super_block *sb = inode->i_sb;
473	struct ntfs_inode *ni = ntfs_i(inode);
474	int err, dirty = 0;
475	u64 new_valid;
476
477	if (!S_ISREG(inode->i_mode))
478		return 0;
479
480	if (is_compressed(ni)) {
481		if (ni->i_valid > new_size)
482			ni->i_valid = new_size;
483	} else {
484		err = block_truncate_page(inode->i_mapping, new_size,
485					  ntfs_get_block);
486		if (err)
487			return err;
488	}
489
490	new_valid = ntfs_up_block(sb, min_t(u64, ni->i_valid, new_size));
491
492	ni_lock(ni);
493
494	truncate_setsize(inode, new_size);
495
496	down_write(&ni->file.run_lock);
497	err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, new_size,
498			    &new_valid, true, NULL);
499	up_write(&ni->file.run_lock);
500
501	if (new_valid < ni->i_valid)
502		ni->i_valid = new_valid;
503
504	ni_unlock(ni);
505
506	ni->std_fa |= FILE_ATTRIBUTE_ARCHIVE;
507	inode->i_ctime = inode->i_mtime = current_time(inode);
508	if (!IS_DIRSYNC(inode)) {
509		dirty = 1;
510	} else {
511		err = ntfs_sync_inode(inode);
512		if (err)
513			return err;
514	}
515
516	if (dirty)
517		mark_inode_dirty(inode);
518
519	/*ntfs_flush_inodes(inode->i_sb, inode, NULL);*/
520
521	return 0;
522}
523
524/*
525 * ntfs_fallocate
526 *
527 * Preallocate space for a file. This implements ntfs's fallocate file
528 * operation, which gets called from sys_fallocate system call. User
529 * space requests 'len' bytes at 'vbo'. If FALLOC_FL_KEEP_SIZE is set
530 * we just allocate clusters without zeroing them out. Otherwise we
531 * allocate and zero out clusters via an expanding truncate.
532 */
533static long ntfs_fallocate(struct file *file, int mode, loff_t vbo, loff_t len)
534{
535	struct inode *inode = file->f_mapping->host;
536	struct super_block *sb = inode->i_sb;
537	struct ntfs_sb_info *sbi = sb->s_fs_info;
538	struct ntfs_inode *ni = ntfs_i(inode);
539	loff_t end = vbo + len;
540	loff_t vbo_down = round_down(vbo, PAGE_SIZE);
541	loff_t i_size;
542	int err;
543
544	/* No support for dir. */
545	if (!S_ISREG(inode->i_mode))
546		return -EOPNOTSUPP;
547
548	/* Return error if mode is not supported. */
549	if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
550		     FALLOC_FL_COLLAPSE_RANGE)) {
551		ntfs_inode_warn(inode, "fallocate(0x%x) is not supported",
552				mode);
553		return -EOPNOTSUPP;
554	}
555
556	ntfs_set_state(sbi, NTFS_DIRTY_DIRTY);
557
558	inode_lock(inode);
559	i_size = inode->i_size;
560
561	if (WARN_ON(ni->ni_flags & NI_FLAG_COMPRESSED_MASK)) {
562		/* Should never be here, see ntfs_file_open. */
563		err = -EOPNOTSUPP;
564		goto out;
565	}
566
567	if (mode & FALLOC_FL_PUNCH_HOLE) {
568		u32 frame_size;
569		loff_t mask, vbo_a, end_a, tmp;
570
571		if (!(mode & FALLOC_FL_KEEP_SIZE)) {
572			err = -EINVAL;
573			goto out;
574		}
575
576		err = filemap_write_and_wait_range(inode->i_mapping, vbo,
577						   end - 1);
578		if (err)
579			goto out;
580
581		err = filemap_write_and_wait_range(inode->i_mapping, end,
582						   LLONG_MAX);
583		if (err)
584			goto out;
585
586		inode_dio_wait(inode);
587
588		truncate_pagecache(inode, vbo_down);
589
590		if (!is_sparsed(ni) && !is_compressed(ni)) {
591			/* Normal file. */
592			err = ntfs_zero_range(inode, vbo, end);
593			goto out;
594		}
595
596		ni_lock(ni);
597		err = attr_punch_hole(ni, vbo, len, &frame_size);
598		ni_unlock(ni);
599		if (err != E_NTFS_NOTALIGNED)
600			goto out;
601
602		/* Process not aligned punch. */
603		mask = frame_size - 1;
604		vbo_a = (vbo + mask) & ~mask;
605		end_a = end & ~mask;
606
607		tmp = min(vbo_a, end);
608		if (tmp > vbo) {
609			err = ntfs_zero_range(inode, vbo, tmp);
610			if (err)
611				goto out;
612		}
613
614		if (vbo < end_a && end_a < end) {
615			err = ntfs_zero_range(inode, end_a, end);
616			if (err)
617				goto out;
618		}
619
620		/* Aligned punch_hole */
621		if (end_a > vbo_a) {
622			ni_lock(ni);
623			err = attr_punch_hole(ni, vbo_a, end_a - vbo_a, NULL);
624			ni_unlock(ni);
625		}
626	} else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
627		if (mode & ~FALLOC_FL_COLLAPSE_RANGE) {
628			err = -EINVAL;
629			goto out;
630		}
631
632		/*
633		 * Write tail of the last page before removed range since
634		 * it will get removed from the page cache below.
635		 */
636		err = filemap_write_and_wait_range(inode->i_mapping, vbo_down,
637						   vbo);
638		if (err)
639			goto out;
640
641		/*
642		 * Write data that will be shifted to preserve them
643		 * when discarding page cache below.
644		 */
645		err = filemap_write_and_wait_range(inode->i_mapping, end,
646						   LLONG_MAX);
647		if (err)
648			goto out;
649
650		/* Wait for existing dio to complete. */
651		inode_dio_wait(inode);
652
653		truncate_pagecache(inode, vbo_down);
654
655		ni_lock(ni);
656		err = attr_collapse_range(ni, vbo, len);
657		ni_unlock(ni);
658	} else {
659		/*
660		 * Normal file: Allocate clusters, do not change 'valid' size.
661		 */
662		err = ntfs_set_size(inode, max(end, i_size));
663		if (err)
664			goto out;
665
666		if (is_sparsed(ni) || is_compressed(ni)) {
667			CLST vcn_v = ni->i_valid >> sbi->cluster_bits;
668			CLST vcn = vbo >> sbi->cluster_bits;
669			CLST cend = bytes_to_cluster(sbi, end);
670			CLST lcn, clen;
671			bool new;
672
673			/*
674			 * Allocate but do not zero new clusters. (see below comments)
675			 * This breaks security: One can read unused on-disk areas.
676			 * Zeroing these clusters may be too long.
677			 * Maybe we should check here for root rights?
678			 */
679			for (; vcn < cend; vcn += clen) {
680				err = attr_data_get_block(ni, vcn, cend - vcn,
681							  &lcn, &clen, &new);
682				if (err)
683					goto out;
684				if (!new || vcn >= vcn_v)
685					continue;
686
687				/*
688				 * Unwritten area.
689				 * NTFS is not able to store several unwritten areas.
690				 * Activate 'ntfs_sparse_cluster' to zero new allocated clusters.
691				 *
692				 * Dangerous in case:
693				 * 1G of sparsed clusters + 1 cluster of data =>
694				 * valid_size == 1G + 1 cluster
695				 * fallocate(1G) will zero 1G and this can be very long
696				 * xfstest 016/086 will fail without 'ntfs_sparse_cluster'.
697				 */
698				ntfs_sparse_cluster(inode, NULL, vcn,
699						    min(vcn_v - vcn, clen));
700			}
701		}
702
703		if (mode & FALLOC_FL_KEEP_SIZE) {
704			ni_lock(ni);
705			/* True - Keep preallocated. */
706			err = attr_set_size(ni, ATTR_DATA, NULL, 0,
707					    &ni->file.run, i_size, &ni->i_valid,
708					    true, NULL);
709			ni_unlock(ni);
710		}
711	}
712
713out:
714	if (err == -EFBIG)
715		err = -ENOSPC;
716
717	if (!err) {
718		inode->i_ctime = inode->i_mtime = current_time(inode);
719		mark_inode_dirty(inode);
720	}
721
722	inode_unlock(inode);
723	return err;
724}
725
726/*
727 * ntfs3_setattr - inode_operations::setattr
728 */
729int ntfs3_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
730		  struct iattr *attr)
731{
732	struct super_block *sb = dentry->d_sb;
733	struct ntfs_sb_info *sbi = sb->s_fs_info;
734	struct inode *inode = d_inode(dentry);
735	struct ntfs_inode *ni = ntfs_i(inode);
736	u32 ia_valid = attr->ia_valid;
737	umode_t mode = inode->i_mode;
738	int err;
739
740	if (sbi->options.no_acs_rules) {
741		/* "No access rules" - Force any changes of time etc. */
742		attr->ia_valid |= ATTR_FORCE;
743		/* and disable for editing some attributes. */
744		attr->ia_valid &= ~(ATTR_UID | ATTR_GID | ATTR_MODE);
745		ia_valid = attr->ia_valid;
746	}
747
748	err = setattr_prepare(mnt_userns, dentry, attr);
749	if (err)
750		goto out;
751
752	if (ia_valid & ATTR_SIZE) {
753		loff_t oldsize = inode->i_size;
754
755		if (WARN_ON(ni->ni_flags & NI_FLAG_COMPRESSED_MASK)) {
756			/* Should never be here, see ntfs_file_open(). */
757			err = -EOPNOTSUPP;
758			goto out;
759		}
760		inode_dio_wait(inode);
761
762		if (attr->ia_size < oldsize)
763			err = ntfs_truncate(inode, attr->ia_size);
764		else if (attr->ia_size > oldsize)
765			err = ntfs_extend(inode, attr->ia_size, 0, NULL);
766
767		if (err)
768			goto out;
769
770		ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
771	}
772
773	setattr_copy(mnt_userns, inode, attr);
774
775	if (mode != inode->i_mode) {
776		err = ntfs_acl_chmod(mnt_userns, inode);
777		if (err)
778			goto out;
779
780		/* Linux 'w' -> Windows 'ro'. */
781		if (0222 & inode->i_mode)
782			ni->std_fa &= ~FILE_ATTRIBUTE_READONLY;
783		else
784			ni->std_fa |= FILE_ATTRIBUTE_READONLY;
785	}
786
787	if (ia_valid & (ATTR_UID | ATTR_GID | ATTR_MODE))
788		ntfs_save_wsl_perm(inode);
789	mark_inode_dirty(inode);
790out:
791	return err;
792}
793
794static ssize_t ntfs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
795{
796	struct file *file = iocb->ki_filp;
797	struct inode *inode = file->f_mapping->host;
798	struct ntfs_inode *ni = ntfs_i(inode);
799
800	if (is_encrypted(ni)) {
801		ntfs_inode_warn(inode, "encrypted i/o not supported");
802		return -EOPNOTSUPP;
803	}
804
805	if (is_compressed(ni) && (iocb->ki_flags & IOCB_DIRECT)) {
806		ntfs_inode_warn(inode, "direct i/o + compressed not supported");
807		return -EOPNOTSUPP;
808	}
809
810#ifndef CONFIG_NTFS3_LZX_XPRESS
811	if (ni->ni_flags & NI_FLAG_COMPRESSED_MASK) {
812		ntfs_inode_warn(
813			inode,
814			"activate CONFIG_NTFS3_LZX_XPRESS to read external compressed files");
815		return -EOPNOTSUPP;
816	}
817#endif
818
819	if (is_dedup(ni)) {
820		ntfs_inode_warn(inode, "read deduplicated not supported");
821		return -EOPNOTSUPP;
822	}
823
824	return generic_file_read_iter(iocb, iter);
825}
826
827/*
828 * ntfs_get_frame_pages
829 *
830 * Return: Array of locked pages.
831 */
832static int ntfs_get_frame_pages(struct address_space *mapping, pgoff_t index,
833				struct page **pages, u32 pages_per_frame,
834				bool *frame_uptodate)
835{
836	gfp_t gfp_mask = mapping_gfp_mask(mapping);
837	u32 npages;
838
839	*frame_uptodate = true;
840
841	for (npages = 0; npages < pages_per_frame; npages++, index++) {
842		struct page *page;
843
844		page = find_or_create_page(mapping, index, gfp_mask);
845		if (!page) {
846			while (npages--) {
847				page = pages[npages];
848				unlock_page(page);
849				put_page(page);
850			}
851
852			return -ENOMEM;
853		}
854
855		if (!PageUptodate(page))
856			*frame_uptodate = false;
857
858		pages[npages] = page;
859	}
860
861	return 0;
862}
863
864/*
865 * ntfs_compress_write - Helper for ntfs_file_write_iter() (compressed files).
866 */
867static ssize_t ntfs_compress_write(struct kiocb *iocb, struct iov_iter *from)
868{
869	int err;
870	struct file *file = iocb->ki_filp;
871	size_t count = iov_iter_count(from);
872	loff_t pos = iocb->ki_pos;
873	struct inode *inode = file_inode(file);
874	loff_t i_size = inode->i_size;
875	struct address_space *mapping = inode->i_mapping;
876	struct ntfs_inode *ni = ntfs_i(inode);
877	u64 valid = ni->i_valid;
878	struct ntfs_sb_info *sbi = ni->mi.sbi;
879	struct page *page, **pages = NULL;
880	size_t written = 0;
881	u8 frame_bits = NTFS_LZNT_CUNIT + sbi->cluster_bits;
882	u32 frame_size = 1u << frame_bits;
883	u32 pages_per_frame = frame_size >> PAGE_SHIFT;
884	u32 ip, off;
885	CLST frame;
886	u64 frame_vbo;
887	pgoff_t index;
888	bool frame_uptodate;
889
890	if (frame_size < PAGE_SIZE) {
891		/*
892		 * frame_size == 8K if cluster 512
893		 * frame_size == 64K if cluster 4096
894		 */
895		ntfs_inode_warn(inode, "page size is bigger than frame size");
896		return -EOPNOTSUPP;
897	}
898
899	pages = kmalloc_array(pages_per_frame, sizeof(struct page *), GFP_NOFS);
900	if (!pages)
901		return -ENOMEM;
902
903	current->backing_dev_info = inode_to_bdi(inode);
904	err = file_remove_privs(file);
905	if (err)
906		goto out;
907
908	err = file_update_time(file);
909	if (err)
910		goto out;
911
912	/* Zero range [valid : pos). */
913	while (valid < pos) {
914		CLST lcn, clen;
915
916		frame = valid >> frame_bits;
917		frame_vbo = valid & ~(frame_size - 1);
918		off = valid & (frame_size - 1);
919
920		err = attr_data_get_block(ni, frame << NTFS_LZNT_CUNIT, 0, &lcn,
921					  &clen, NULL);
922		if (err)
923			goto out;
924
925		if (lcn == SPARSE_LCN) {
926			ni->i_valid = valid =
927				frame_vbo + ((u64)clen << sbi->cluster_bits);
928			continue;
929		}
930
931		/* Load full frame. */
932		err = ntfs_get_frame_pages(mapping, frame_vbo >> PAGE_SHIFT,
933					   pages, pages_per_frame,
934					   &frame_uptodate);
935		if (err)
936			goto out;
937
938		if (!frame_uptodate && off) {
939			err = ni_read_frame(ni, frame_vbo, pages,
940					    pages_per_frame);
941			if (err) {
942				for (ip = 0; ip < pages_per_frame; ip++) {
943					page = pages[ip];
944					unlock_page(page);
945					put_page(page);
946				}
947				goto out;
948			}
949		}
950
951		ip = off >> PAGE_SHIFT;
952		off = offset_in_page(valid);
953		for (; ip < pages_per_frame; ip++, off = 0) {
954			page = pages[ip];
955			zero_user_segment(page, off, PAGE_SIZE);
956			flush_dcache_page(page);
957			SetPageUptodate(page);
958		}
959
960		ni_lock(ni);
961		err = ni_write_frame(ni, pages, pages_per_frame);
962		ni_unlock(ni);
963
964		for (ip = 0; ip < pages_per_frame; ip++) {
965			page = pages[ip];
966			SetPageUptodate(page);
967			unlock_page(page);
968			put_page(page);
969		}
970
971		if (err)
972			goto out;
973
974		ni->i_valid = valid = frame_vbo + frame_size;
975	}
976
977	/* Copy user data [pos : pos + count). */
978	while (count) {
979		size_t copied, bytes;
980
981		off = pos & (frame_size - 1);
982		bytes = frame_size - off;
983		if (bytes > count)
984			bytes = count;
985
986		frame = pos >> frame_bits;
987		frame_vbo = pos & ~(frame_size - 1);
988		index = frame_vbo >> PAGE_SHIFT;
989
990		if (unlikely(iov_iter_fault_in_readable(from, bytes))) {
991			err = -EFAULT;
992			goto out;
993		}
994
995		/* Load full frame. */
996		err = ntfs_get_frame_pages(mapping, index, pages,
997					   pages_per_frame, &frame_uptodate);
998		if (err)
999			goto out;
1000
1001		if (!frame_uptodate) {
1002			loff_t to = pos + bytes;
1003
1004			if (off || (to < i_size && (to & (frame_size - 1)))) {
1005				err = ni_read_frame(ni, frame_vbo, pages,
1006						    pages_per_frame);
1007				if (err) {
1008					for (ip = 0; ip < pages_per_frame;
1009					     ip++) {
1010						page = pages[ip];
1011						unlock_page(page);
1012						put_page(page);
1013					}
1014					goto out;
1015				}
1016			}
1017		}
1018
1019		WARN_ON(!bytes);
1020		copied = 0;
1021		ip = off >> PAGE_SHIFT;
1022		off = offset_in_page(pos);
1023
1024		/* Copy user data to pages. */
1025		for (;;) {
1026			size_t cp, tail = PAGE_SIZE - off;
1027
1028			page = pages[ip];
1029			cp = copy_page_from_iter_atomic(page, off,
1030							min(tail, bytes), from);
1031			flush_dcache_page(page);
1032
1033			copied += cp;
1034			bytes -= cp;
1035			if (!bytes || !cp)
1036				break;
1037
1038			if (cp < tail) {
1039				off += cp;
1040			} else {
1041				ip++;
1042				off = 0;
1043			}
1044		}
1045
1046		ni_lock(ni);
1047		err = ni_write_frame(ni, pages, pages_per_frame);
1048		ni_unlock(ni);
1049
1050		for (ip = 0; ip < pages_per_frame; ip++) {
1051			page = pages[ip];
1052			ClearPageDirty(page);
1053			SetPageUptodate(page);
1054			unlock_page(page);
1055			put_page(page);
1056		}
1057
1058		if (err)
1059			goto out;
1060
1061		/*
1062		 * We can loop for a long time in here. Be nice and allow
1063		 * us to schedule out to avoid softlocking if preempt
1064		 * is disabled.
1065		 */
1066		cond_resched();
1067
1068		pos += copied;
1069		written += copied;
1070
1071		count = iov_iter_count(from);
1072	}
1073
1074out:
1075	kfree(pages);
1076
1077	current->backing_dev_info = NULL;
1078
1079	if (err < 0)
1080		return err;
1081
1082	iocb->ki_pos += written;
1083	if (iocb->ki_pos > ni->i_valid)
1084		ni->i_valid = iocb->ki_pos;
1085
1086	return written;
1087}
1088
1089/*
1090 * ntfs_file_write_iter - file_operations::write_iter
1091 */
1092static ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1093{
1094	struct file *file = iocb->ki_filp;
1095	struct address_space *mapping = file->f_mapping;
1096	struct inode *inode = mapping->host;
1097	ssize_t ret;
1098	struct ntfs_inode *ni = ntfs_i(inode);
1099
1100	if (is_encrypted(ni)) {
1101		ntfs_inode_warn(inode, "encrypted i/o not supported");
1102		return -EOPNOTSUPP;
1103	}
1104
1105	if (is_compressed(ni) && (iocb->ki_flags & IOCB_DIRECT)) {
1106		ntfs_inode_warn(inode, "direct i/o + compressed not supported");
1107		return -EOPNOTSUPP;
1108	}
1109
1110	if (is_dedup(ni)) {
1111		ntfs_inode_warn(inode, "write into deduplicated not supported");
1112		return -EOPNOTSUPP;
1113	}
1114
1115	if (!inode_trylock(inode)) {
1116		if (iocb->ki_flags & IOCB_NOWAIT)
1117			return -EAGAIN;
1118		inode_lock(inode);
1119	}
1120
1121	ret = generic_write_checks(iocb, from);
1122	if (ret <= 0)
1123		goto out;
1124
1125	if (WARN_ON(ni->ni_flags & NI_FLAG_COMPRESSED_MASK)) {
1126		/* Should never be here, see ntfs_file_open(). */
1127		ret = -EOPNOTSUPP;
1128		goto out;
1129	}
1130
1131	ret = ntfs_extend(inode, iocb->ki_pos, ret, file);
1132	if (ret)
1133		goto out;
1134
1135	ret = is_compressed(ni) ? ntfs_compress_write(iocb, from)
1136				: __generic_file_write_iter(iocb, from);
1137
1138out:
1139	inode_unlock(inode);
1140
1141	if (ret > 0)
1142		ret = generic_write_sync(iocb, ret);
1143
1144	return ret;
1145}
1146
1147/*
1148 * ntfs_file_open - file_operations::open
1149 */
1150int ntfs_file_open(struct inode *inode, struct file *file)
1151{
1152	struct ntfs_inode *ni = ntfs_i(inode);
1153
1154	if (unlikely((is_compressed(ni) || is_encrypted(ni)) &&
1155		     (file->f_flags & O_DIRECT))) {
1156		return -EOPNOTSUPP;
1157	}
1158
1159	/* Decompress "external compressed" file if opened for rw. */
1160	if ((ni->ni_flags & NI_FLAG_COMPRESSED_MASK) &&
1161	    (file->f_flags & (O_WRONLY | O_RDWR | O_TRUNC))) {
1162#ifdef CONFIG_NTFS3_LZX_XPRESS
1163		int err = ni_decompress_file(ni);
1164
1165		if (err)
1166			return err;
1167#else
1168		ntfs_inode_warn(
1169			inode,
1170			"activate CONFIG_NTFS3_LZX_XPRESS to write external compressed files");
1171		return -EOPNOTSUPP;
1172#endif
1173	}
1174
1175	return generic_file_open(inode, file);
1176}
1177
1178/*
1179 * ntfs_file_release - file_operations::release
1180 */
1181static int ntfs_file_release(struct inode *inode, struct file *file)
1182{
1183	struct ntfs_inode *ni = ntfs_i(inode);
1184	struct ntfs_sb_info *sbi = ni->mi.sbi;
1185	int err = 0;
1186
1187	/* If we are last writer on the inode, drop the block reservation. */
1188	if (sbi->options.prealloc && ((file->f_mode & FMODE_WRITE) &&
1189				      atomic_read(&inode->i_writecount) == 1)) {
1190		ni_lock(ni);
1191		down_write(&ni->file.run_lock);
1192
1193		err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run,
1194				    inode->i_size, &ni->i_valid, false, NULL);
1195
1196		up_write(&ni->file.run_lock);
1197		ni_unlock(ni);
1198	}
1199	return err;
1200}
1201
1202/*
1203 * ntfs_fiemap - file_operations::fiemap
1204 */
1205int ntfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1206		__u64 start, __u64 len)
1207{
1208	int err;
1209	struct ntfs_inode *ni = ntfs_i(inode);
1210
1211	err = fiemap_prep(inode, fieinfo, start, &len, ~FIEMAP_FLAG_XATTR);
1212	if (err)
1213		return err;
1214
1215	ni_lock(ni);
1216
1217	err = ni_fiemap(ni, fieinfo, start, len);
1218
1219	ni_unlock(ni);
1220
1221	return err;
1222}
1223
1224// clang-format off
1225const struct inode_operations ntfs_file_inode_operations = {
1226	.getattr	= ntfs_getattr,
1227	.setattr	= ntfs3_setattr,
1228	.listxattr	= ntfs_listxattr,
1229	.permission	= ntfs_permission,
1230	.get_acl	= ntfs_get_acl,
1231	.set_acl	= ntfs_set_acl,
1232	.fiemap		= ntfs_fiemap,
1233};
1234
1235const struct file_operations ntfs_file_operations = {
1236	.llseek		= generic_file_llseek,
1237	.read_iter	= ntfs_file_read_iter,
1238	.write_iter	= ntfs_file_write_iter,
1239	.unlocked_ioctl = ntfs_ioctl,
1240#ifdef CONFIG_COMPAT
1241	.compat_ioctl	= ntfs_compat_ioctl,
1242#endif
1243	.splice_read	= generic_file_splice_read,
1244	.mmap		= ntfs_file_mmap,
1245	.open		= ntfs_file_open,
1246	.fsync		= generic_file_fsync,
1247	.splice_write	= iter_file_splice_write,
1248	.fallocate	= ntfs_fallocate,
1249	.release	= ntfs_file_release,
1250};
1251// clang-format on
1252