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