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/blkdev.h>
12 #include <linux/buffer_head.h>
13 #include <linux/compat.h>
14 #include <linux/falloc.h>
15 #include <linux/fiemap.h>
16 #include <linux/fileattr.h>
17 #include <linux/filelock.h>
18 #include <linux/iomap.h>
19
20 #include "debug.h"
21 #include "ntfs.h"
22 #include "ntfs_fs.h"
23
24 /*
25 * cifx, btrfs, exfat, ext4, f2fs use this constant.
26 * Hope this value will become common to all fs.
27 */
28 #define NTFS3_IOC_SHUTDOWN _IOR('X', 125, __u32)
29
30 /*
31 * Helper for ntfs_should_use_dio.
32 */
ntfs_dio_alignment(struct inode * inode)33 static u32 ntfs_dio_alignment(struct inode *inode)
34 {
35 struct ntfs_inode *ni = ntfs_i(inode);
36
37 if (is_resident(ni)) {
38 /* Check delalloc. */
39 if (!ni->file.run_da.count)
40 return 0;
41 }
42
43 /* In most cases this is bdev_logical_block_size(bdev). */
44 return ni->mi.sbi->bdev_blocksize;
45 }
46
47 /*
48 * Returns %true if the given DIO request should be attempted with DIO, or
49 * %false if it should fall back to buffered I/O.
50 */
ntfs_should_use_dio(struct kiocb * iocb,struct iov_iter * iter)51 static bool ntfs_should_use_dio(struct kiocb *iocb, struct iov_iter *iter)
52 {
53 struct inode *inode = file_inode(iocb->ki_filp);
54 u32 dio_align = ntfs_dio_alignment(inode);
55
56 if (!dio_align)
57 return false;
58
59 return IS_ALIGNED(iocb->ki_pos | iov_iter_alignment(iter), dio_align);
60 }
61
ntfs_ioctl_fitrim(struct ntfs_sb_info * sbi,unsigned long arg)62 static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, unsigned long arg)
63 {
64 struct fstrim_range __user *user_range;
65 struct fstrim_range range;
66 struct block_device *dev;
67 int err;
68
69 if (!capable(CAP_SYS_ADMIN))
70 return -EPERM;
71
72 dev = sbi->sb->s_bdev;
73 if (!bdev_max_discard_sectors(dev))
74 return -EOPNOTSUPP;
75
76 user_range = (struct fstrim_range __user *)arg;
77 if (copy_from_user(&range, user_range, sizeof(range)))
78 return -EFAULT;
79
80 range.minlen = max_t(u32, range.minlen, bdev_discard_granularity(dev));
81
82 err = ntfs_trim_fs(sbi, &range);
83 if (err < 0)
84 return err;
85
86 if (copy_to_user(user_range, &range, sizeof(range)))
87 return -EFAULT;
88
89 return 0;
90 }
91
ntfs_ioctl_get_volume_label(struct ntfs_sb_info * sbi,u8 __user * buf)92 static int ntfs_ioctl_get_volume_label(struct ntfs_sb_info *sbi, u8 __user *buf)
93 {
94 if (copy_to_user(buf, sbi->volume.label, FSLABEL_MAX))
95 return -EFAULT;
96
97 return 0;
98 }
99
ntfs_ioctl_set_volume_label(struct ntfs_sb_info * sbi,u8 __user * buf)100 static int ntfs_ioctl_set_volume_label(struct ntfs_sb_info *sbi, u8 __user *buf)
101 {
102 u8 user[FSLABEL_MAX] = { 0 };
103 int len;
104
105 if (!capable(CAP_SYS_ADMIN))
106 return -EPERM;
107
108 if (copy_from_user(user, buf, FSLABEL_MAX))
109 return -EFAULT;
110
111 len = strnlen(user, FSLABEL_MAX);
112
113 return ntfs_set_label(sbi, user, len);
114 }
115
116 /*
117 * ntfs_force_shutdown - helper function. Called from ioctl
118 */
ntfs_force_shutdown(struct super_block * sb,u32 flags)119 static int ntfs_force_shutdown(struct super_block *sb, u32 flags)
120 {
121 int err;
122 struct ntfs_sb_info *sbi = sb->s_fs_info;
123
124 if (unlikely(ntfs3_forced_shutdown(sb)))
125 return 0;
126
127 /* No additional options yet (flags). */
128 err = bdev_freeze(sb->s_bdev);
129 if (err)
130 return err;
131 set_bit(NTFS_FLAGS_SHUTDOWN_BIT, &sbi->flags);
132 bdev_thaw(sb->s_bdev);
133 return 0;
134 }
135
ntfs_ioctl_shutdown(struct super_block * sb,unsigned long arg)136 static int ntfs_ioctl_shutdown(struct super_block *sb, unsigned long arg)
137 {
138 u32 flags;
139
140 if (!capable(CAP_SYS_ADMIN))
141 return -EPERM;
142
143 if (get_user(flags, (__u32 __user *)arg))
144 return -EFAULT;
145
146 return ntfs_force_shutdown(sb, flags);
147 }
148
149 /*
150 * ntfs_ioctl - file_operations::unlocked_ioctl
151 */
ntfs_ioctl(struct file * filp,u32 cmd,unsigned long arg)152 long ntfs_ioctl(struct file *filp, u32 cmd, unsigned long arg)
153 {
154 struct inode *inode = file_inode(filp);
155 struct super_block *sb = inode->i_sb;
156 struct ntfs_sb_info *sbi = sb->s_fs_info;
157
158 /* Avoid any operation if inode is bad. */
159 if (unlikely(is_bad_ni(ntfs_i(inode))))
160 return -EINVAL;
161
162 switch (cmd) {
163 case FITRIM:
164 return ntfs_ioctl_fitrim(sbi, arg);
165 case FS_IOC_GETFSLABEL:
166 return ntfs_ioctl_get_volume_label(sbi, (u8 __user *)arg);
167 case FS_IOC_SETFSLABEL:
168 return ntfs_ioctl_set_volume_label(sbi, (u8 __user *)arg);
169 case NTFS3_IOC_SHUTDOWN:
170 return ntfs_ioctl_shutdown(sb, arg);
171 }
172 return -ENOTTY; /* Inappropriate ioctl for device. */
173 }
174
175 #ifdef CONFIG_COMPAT
ntfs_compat_ioctl(struct file * filp,u32 cmd,unsigned long arg)176 long ntfs_compat_ioctl(struct file *filp, u32 cmd, unsigned long arg)
177
178 {
179 return ntfs_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
180 }
181 #endif
182
183 /*
184 * ntfs_getattr - inode_operations::getattr
185 */
ntfs_getattr(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,u32 flags)186 int ntfs_getattr(struct mnt_idmap *idmap, const struct path *path,
187 struct kstat *stat, u32 request_mask, u32 flags)
188 {
189 struct inode *inode = d_inode(path->dentry);
190 struct ntfs_inode *ni = ntfs_i(inode);
191
192 /* Avoid any operation if inode is bad. */
193 if (unlikely(is_bad_ni(ni)))
194 return -EINVAL;
195
196 stat->result_mask |= STATX_BTIME;
197 stat->btime = ni->i_crtime;
198 stat->blksize = ni->mi.sbi->cluster_size; /* 512, 1K, ..., 2M */
199
200 if (inode->i_flags & S_IMMUTABLE)
201 stat->attributes |= STATX_ATTR_IMMUTABLE;
202
203 if (inode->i_flags & S_APPEND)
204 stat->attributes |= STATX_ATTR_APPEND;
205
206 if (is_compressed(ni))
207 stat->attributes |= STATX_ATTR_COMPRESSED;
208
209 if (is_encrypted(ni))
210 stat->attributes |= STATX_ATTR_ENCRYPTED;
211
212 stat->attributes_mask |= STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED |
213 STATX_ATTR_IMMUTABLE | STATX_ATTR_APPEND;
214
215 generic_fillattr(idmap, request_mask, inode, stat);
216
217 return 0;
218 }
219
ntfs_extend_initialized_size(struct file * file,struct ntfs_inode * ni,const loff_t new_valid)220 static int ntfs_extend_initialized_size(struct file *file,
221 struct ntfs_inode *ni,
222 const loff_t new_valid)
223 {
224 struct inode *inode = &ni->vfs_inode;
225 const loff_t valid = ni->i_valid;
226 int err;
227
228 if (valid >= new_valid)
229 return 0;
230
231 if (is_resident(ni)) {
232 ni->i_valid = new_valid;
233 return 0;
234 }
235
236 err = iomap_zero_range(inode, valid, new_valid - valid, NULL,
237 &ntfs_iomap_ops, &ntfs_iomap_folio_ops, NULL);
238 if (err) {
239 ni->i_valid = valid;
240 ntfs_inode_warn(inode,
241 "failed to extend initialized size to %llx.",
242 new_valid);
243 return err;
244 }
245
246 return 0;
247 }
248
ntfs_filemap_close(struct vm_area_struct * vma)249 static void ntfs_filemap_close(struct vm_area_struct *vma)
250 {
251 struct inode *inode = file_inode(vma->vm_file);
252 struct ntfs_inode *ni = ntfs_i(inode);
253 u64 from = (u64)vma->vm_pgoff << PAGE_SHIFT;
254 u64 to = min_t(u64, i_size_read(inode),
255 from + vma->vm_end - vma->vm_start);
256
257 if (ni->i_valid < to) {
258 ni->i_valid = to;
259 mark_inode_dirty(inode);
260 }
261 }
262
263 /* Copy of generic_file_vm_ops. */
264 static const struct vm_operations_struct ntfs_file_vm_ops = {
265 .close = ntfs_filemap_close,
266 .fault = filemap_fault,
267 .map_pages = filemap_map_pages,
268 .page_mkwrite = filemap_page_mkwrite,
269 };
270
271 /*
272 * ntfs_file_mmap_prepare - file_operations::mmap_prepare
273 */
ntfs_file_mmap_prepare(struct vm_area_desc * desc)274 static int ntfs_file_mmap_prepare(struct vm_area_desc *desc)
275 {
276 struct file *file = desc->file;
277 struct inode *inode = file_inode(file);
278 struct ntfs_inode *ni = ntfs_i(inode);
279 const bool rw = vma_desc_test_flags(desc, VMA_WRITE_BIT);
280 int err;
281
282 /* Avoid any operation if inode is bad. */
283 if (unlikely(is_bad_ni(ni)))
284 return -EINVAL;
285
286 if (unlikely(ntfs3_forced_shutdown(inode->i_sb)))
287 return -EIO;
288
289 if (is_encrypted(ni)) {
290 ntfs_inode_warn(inode, "mmap encrypted not supported");
291 return -EOPNOTSUPP;
292 }
293
294 if (is_dedup(ni)) {
295 ntfs_inode_warn(inode, "mmap deduplicated not supported");
296 return -EOPNOTSUPP;
297 }
298
299 if (is_compressed(ni)) {
300 if (rw) {
301 ntfs_inode_warn(inode,
302 "mmap(write) compressed not supported");
303 return -EOPNOTSUPP;
304 }
305 /* Turn off readahead for compressed files. */
306 file->f_ra.ra_pages = 0;
307 }
308
309 if (rw) {
310 u64 from = (u64)desc->pgoff << PAGE_SHIFT;
311 u64 to = min_t(u64, i_size_read(inode),
312 from + vma_desc_size(desc));
313
314 if (is_sparsed(ni)) {
315 /* Allocate clusters for rw map. */
316 struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info;
317 CLST lcn, len;
318 CLST vcn = from >> sbi->cluster_bits;
319 CLST end = bytes_to_cluster(sbi, to);
320 bool new;
321
322 for (; vcn < end; vcn += len) {
323 err = attr_data_get_block(ni, vcn, 1, &lcn,
324 &len, &new, true,
325 NULL, false);
326 if (err)
327 goto out;
328 }
329 }
330
331 if (ni->i_valid < to) {
332 if (!inode_trylock(inode)) {
333 err = -EAGAIN;
334 goto out;
335 }
336 err = ntfs_extend_initialized_size(file, ni, to);
337 inode_unlock(inode);
338 if (err)
339 goto out;
340 }
341 }
342
343 err = generic_file_mmap_prepare(desc);
344 if (!err && rw)
345 desc->vm_ops = &ntfs_file_vm_ops;
346 out:
347 return err;
348 }
349
ntfs_extend(struct inode * inode,loff_t pos,size_t count,struct file * file)350 static int ntfs_extend(struct inode *inode, loff_t pos, size_t count,
351 struct file *file)
352 {
353 struct ntfs_inode *ni = ntfs_i(inode);
354 struct address_space *mapping = inode->i_mapping;
355 loff_t end = pos + count;
356 bool extend_init = file && pos > ni->i_valid;
357 int err;
358
359 if (end <= inode->i_size && !extend_init)
360 return 0;
361
362 /* Mark rw ntfs as dirty. It will be cleared at umount. */
363 ntfs_set_state(ni->mi.sbi, NTFS_DIRTY_DIRTY);
364
365 if (end > inode->i_size) {
366 /*
367 * Normal files: increase file size, allocate space.
368 * Sparse/Compressed: increase file size. No space allocated.
369 */
370 err = ntfs_set_size(inode, end);
371 if (err)
372 goto out;
373 }
374
375 if (extend_init && !is_compressed(ni)) {
376 err = ntfs_extend_initialized_size(file, ni, pos);
377 if (err)
378 goto out;
379 } else {
380 err = 0;
381 }
382
383 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
384 mark_inode_dirty(inode);
385
386 if (IS_SYNC(inode)) {
387 int err2;
388
389 err = filemap_fdatawrite_range(mapping, pos, end - 1);
390 err2 = sync_mapping_buffers(mapping);
391 if (!err)
392 err = err2;
393 err2 = write_inode_now(inode, 1);
394 if (!err)
395 err = err2;
396 if (!err)
397 err = filemap_fdatawait_range(mapping, pos, end - 1);
398 }
399
400 out:
401 return err;
402 }
403
ntfs_truncate(struct inode * inode,loff_t new_size)404 static int ntfs_truncate(struct inode *inode, loff_t new_size)
405 {
406 int err;
407 struct ntfs_inode *ni = ntfs_i(inode);
408 u64 new_valid = min_t(u64, ni->i_valid, new_size);
409
410 truncate_setsize(inode, new_size);
411
412 ni_lock(ni);
413
414 down_write(&ni->file.run_lock);
415 err = attr_set_size_ex(ni, ATTR_DATA, NULL, 0, &ni->file.run, new_size,
416 &new_valid, ni->mi.sbi->options->prealloc, NULL,
417 false);
418 up_write(&ni->file.run_lock);
419
420 ni->i_valid = new_valid;
421
422 ni_unlock(ni);
423
424 if (err)
425 return err;
426
427 ni->std_fa |= FILE_ATTRIBUTE_ARCHIVE;
428 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
429 if (!IS_DIRSYNC(inode)) {
430 mark_inode_dirty(inode);
431 } else {
432 err = ntfs_sync_inode(inode);
433 if (err)
434 return err;
435 }
436
437 return 0;
438 }
439
440 /*
441 * ntfs_fallocate - file_operations::ntfs_fallocate
442 *
443 * Preallocate space for a file. This implements ntfs's fallocate file
444 * operation, which gets called from sys_fallocate system call. User
445 * space requests 'len' bytes at 'vbo'. If FALLOC_FL_KEEP_SIZE is set
446 * we just allocate clusters without zeroing them out. Otherwise we
447 * allocate and zero out clusters via an expanding truncate.
448 */
ntfs_fallocate(struct file * file,int mode,loff_t vbo,loff_t len)449 static long ntfs_fallocate(struct file *file, int mode, loff_t vbo, loff_t len)
450 {
451 struct inode *inode = file_inode(file);
452 struct address_space *mapping = inode->i_mapping;
453 struct super_block *sb = inode->i_sb;
454 struct ntfs_sb_info *sbi = sb->s_fs_info;
455 struct ntfs_inode *ni = ntfs_i(inode);
456 loff_t end = vbo + len;
457 loff_t vbo_down = round_down(vbo, max_t(unsigned long,
458 sbi->cluster_size, PAGE_SIZE));
459 bool is_supported_holes = is_sparsed(ni) || is_compressed(ni);
460 loff_t i_size, new_size;
461 bool map_locked;
462 int err;
463
464 /* No support for dir. */
465 if (!S_ISREG(inode->i_mode))
466 return -EOPNOTSUPP;
467
468 /*
469 * vfs_fallocate checks all possible combinations of mode.
470 * Do additional checks here before ntfs_set_state(dirty).
471 */
472 if (mode & FALLOC_FL_PUNCH_HOLE) {
473 if (!is_supported_holes)
474 return -EOPNOTSUPP;
475 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
476 } else if (mode & FALLOC_FL_INSERT_RANGE) {
477 if (!is_supported_holes)
478 return -EOPNOTSUPP;
479 } else if (mode &
480 ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
481 FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_INSERT_RANGE)) {
482 ntfs_inode_warn(inode, "fallocate(0x%x) is not supported",
483 mode);
484 return -EOPNOTSUPP;
485 }
486
487 ntfs_set_state(sbi, NTFS_DIRTY_DIRTY);
488
489 inode_lock(inode);
490 i_size = inode->i_size;
491 new_size = max(end, i_size);
492 map_locked = false;
493
494 if (WARN_ON(ni->ni_flags & NI_FLAG_COMPRESSED_MASK)) {
495 /* Should never be here, see ntfs_file_open. */
496 err = -EOPNOTSUPP;
497 goto out;
498 }
499
500 if (mode & (FALLOC_FL_PUNCH_HOLE | FALLOC_FL_COLLAPSE_RANGE |
501 FALLOC_FL_INSERT_RANGE)) {
502 inode_dio_wait(inode);
503 filemap_invalidate_lock(mapping);
504 map_locked = true;
505 }
506
507 if (mode & FALLOC_FL_PUNCH_HOLE) {
508 u32 frame_size;
509 loff_t mask, vbo_a, end_a, tmp, from;
510
511 err = filemap_write_and_wait_range(mapping, vbo_down,
512 LLONG_MAX);
513 if (err)
514 goto out;
515
516 truncate_pagecache(inode, vbo_down);
517
518 ni_lock(ni);
519 err = attr_punch_hole(ni, vbo, len, &frame_size);
520 ni_unlock(ni);
521 if (!err)
522 goto ok;
523
524 if (err != E_NTFS_NOTALIGNED)
525 goto out;
526
527 /* Process not aligned punch. */
528 err = 0;
529 if (end > i_size)
530 end = i_size;
531 mask = frame_size - 1;
532 vbo_a = (vbo + mask) & ~mask;
533 end_a = end & ~mask;
534
535 tmp = min(vbo_a, end);
536 from = min_t(loff_t, ni->i_valid, vbo);
537 /* Zero head of punch. */
538 if (tmp > from) {
539 err = iomap_zero_range(inode, from, tmp - from, NULL,
540 &ntfs_iomap_ops,
541 &ntfs_iomap_folio_ops, NULL);
542 if (err)
543 goto out;
544 }
545
546 /* Aligned punch_hole. Deallocate clusters. */
547 if (end_a > vbo_a) {
548 ni_lock(ni);
549 err = attr_punch_hole(ni, vbo_a, end_a - vbo_a, NULL);
550 ni_unlock(ni);
551 if (err)
552 goto out;
553 }
554
555 /* Zero tail of punch. */
556 if (vbo < end_a && end_a < end) {
557 err = iomap_zero_range(inode, end_a, end - end_a, NULL,
558 &ntfs_iomap_ops,
559 &ntfs_iomap_folio_ops, NULL);
560 if (err)
561 goto out;
562 }
563 } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
564 /*
565 * Write tail of the last page before removed range since
566 * it will get removed from the page cache below.
567 */
568 err = filemap_write_and_wait_range(mapping, vbo_down, vbo);
569 if (err)
570 goto out;
571
572 /*
573 * Write data that will be shifted to preserve them
574 * when discarding page cache below.
575 */
576 err = filemap_write_and_wait_range(mapping, end, LLONG_MAX);
577 if (err)
578 goto out;
579
580 truncate_pagecache(inode, vbo_down);
581
582 ni_lock(ni);
583 err = attr_collapse_range(ni, vbo, len);
584 ni_unlock(ni);
585 if (err)
586 goto out;
587 } else if (mode & FALLOC_FL_INSERT_RANGE) {
588 /* Check new size. */
589 err = inode_newsize_ok(inode, new_size);
590 if (err)
591 goto out;
592
593 /* Write out all dirty pages. */
594 err = filemap_write_and_wait_range(mapping, vbo_down,
595 LLONG_MAX);
596 if (err)
597 goto out;
598 truncate_pagecache(inode, vbo_down);
599
600 ni_lock(ni);
601 err = attr_insert_range(ni, vbo, len);
602 ni_unlock(ni);
603 if (err)
604 goto out;
605 } else {
606 /* Check new size. */
607 u8 cluster_bits = sbi->cluster_bits;
608
609 /* Be sure file is non resident. */
610 if (is_resident(ni)) {
611 ni_lock(ni);
612 err = attr_force_nonresident(ni);
613 ni_unlock(ni);
614 if (err)
615 goto out;
616 }
617
618 /* generic/213: expected -ENOSPC instead of -EFBIG. */
619 if (!is_supported_holes) {
620 loff_t to_alloc = new_size - inode_get_bytes(inode);
621
622 if (to_alloc > 0 &&
623 (to_alloc >> cluster_bits) >
624 wnd_zeroes(&sbi->used.bitmap)) {
625 err = -ENOSPC;
626 goto out;
627 }
628 }
629
630 err = inode_newsize_ok(inode, new_size);
631 if (err)
632 goto out;
633
634 if (new_size > i_size) {
635 /*
636 * Allocate clusters, do not change 'valid' size.
637 */
638 err = ntfs_set_size(inode, new_size);
639 if (err)
640 goto out;
641 }
642
643 if (is_supported_holes) {
644 CLST vcn = vbo >> cluster_bits;
645 CLST cend = bytes_to_cluster(sbi, end);
646 CLST cend_v = bytes_to_cluster(sbi, ni->i_valid);
647 CLST lcn, clen;
648 bool new;
649
650 if (cend_v > cend)
651 cend_v = cend;
652
653 /*
654 * Allocate and zero new clusters.
655 * Zeroing these clusters may be too long.
656 */
657 for (; vcn < cend_v; vcn += clen) {
658 err = attr_data_get_block(ni, vcn, cend_v - vcn,
659 &lcn, &clen, &new,
660 true, NULL, false);
661 if (err)
662 goto out;
663 }
664
665 /*
666 * Moving up 'valid size'.
667 */
668 err = ntfs_extend_initialized_size(
669 file, ni, (u64)cend_v << cluster_bits);
670 if (err)
671 goto out;
672
673 /*
674 * Allocate but not zero new clusters.
675 */
676 for (; vcn < cend; vcn += clen) {
677 err = attr_data_get_block(ni, vcn, cend - vcn,
678 &lcn, &clen, &new,
679 false, NULL, false);
680 if (err)
681 goto out;
682 }
683 }
684
685 if (mode & FALLOC_FL_KEEP_SIZE) {
686 ni_lock(ni);
687 /* True - Keep preallocated. */
688 err = attr_set_size(ni, ATTR_DATA, NULL, 0,
689 &ni->file.run, i_size, &ni->i_valid,
690 true);
691 ni_unlock(ni);
692 if (err)
693 goto out;
694 i_size_write(inode, i_size);
695 } else if (new_size > i_size) {
696 i_size_write(inode, new_size);
697 }
698 }
699
700 ok:
701 err = file_modified(file);
702 if (err)
703 goto out;
704
705 out:
706 if (map_locked)
707 filemap_invalidate_unlock(mapping);
708
709 if (!err) {
710 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
711 mark_inode_dirty(inode);
712 }
713
714 inode_unlock(inode);
715 return err;
716 }
717
718 /*
719 * ntfs_setattr - inode_operations::setattr
720 */
ntfs_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)721 int ntfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
722 struct iattr *attr)
723 {
724 struct inode *inode = d_inode(dentry);
725 struct ntfs_inode *ni = ntfs_i(inode);
726 u32 ia_valid = attr->ia_valid;
727 umode_t mode = inode->i_mode;
728 int err;
729
730 /* Avoid any operation if inode is bad. */
731 if (unlikely(is_bad_ni(ni)))
732 return -EINVAL;
733
734 if (unlikely(ntfs3_forced_shutdown(inode->i_sb)))
735 return -EIO;
736
737 err = setattr_prepare(idmap, dentry, attr);
738 if (err)
739 goto out;
740
741 if (ia_valid & ATTR_SIZE) {
742 loff_t newsize, oldsize;
743
744 if (WARN_ON(ni->ni_flags & NI_FLAG_COMPRESSED_MASK)) {
745 /* Should never be here, see ntfs_file_open(). */
746 err = -EOPNOTSUPP;
747 goto out;
748 }
749 inode_dio_wait(inode);
750 oldsize = i_size_read(inode);
751 newsize = attr->ia_size;
752
753 if (newsize <= oldsize)
754 err = ntfs_truncate(inode, newsize);
755 else
756 err = ntfs_extend(inode, newsize, 0, NULL);
757
758 if (err)
759 goto out;
760
761 ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
762 i_size_write(inode, newsize);
763 }
764
765 setattr_copy(idmap, inode, attr);
766
767 if (mode != inode->i_mode) {
768 err = ntfs_acl_chmod(idmap, dentry);
769 if (err)
770 goto out;
771
772 /* Linux 'w' -> Windows 'ro'. */
773 if (0222 & inode->i_mode)
774 ni->std_fa &= ~FILE_ATTRIBUTE_READONLY;
775 else
776 ni->std_fa |= FILE_ATTRIBUTE_READONLY;
777 }
778
779 if (ia_valid & (ATTR_UID | ATTR_GID | ATTR_MODE))
780 ntfs_save_wsl_perm(inode, NULL);
781 mark_inode_dirty(inode);
782 out:
783 return err;
784 }
785
786 /*
787 * check_read_restriction:
788 * common code for ntfs_file_read_iter and ntfs_file_splice_read
789 */
check_read_restriction(struct inode * inode)790 static int check_read_restriction(struct inode *inode)
791 {
792 struct ntfs_inode *ni = ntfs_i(inode);
793
794 /* Avoid any operation if inode is bad. */
795 if (unlikely(is_bad_ni(ni)))
796 return -EINVAL;
797
798 if (unlikely(ntfs3_forced_shutdown(inode->i_sb)))
799 return -EIO;
800
801 if (is_encrypted(ni)) {
802 ntfs_inode_warn(inode, "encrypted i/o not supported");
803 return -EOPNOTSUPP;
804 }
805
806 #ifndef CONFIG_NTFS3_LZX_XPRESS
807 if (ni->ni_flags & NI_FLAG_COMPRESSED_MASK) {
808 ntfs_inode_warn(
809 inode,
810 "activate CONFIG_NTFS3_LZX_XPRESS to read external compressed files");
811 return -EOPNOTSUPP;
812 }
813 #endif
814
815 if (is_dedup(ni)) {
816 ntfs_inode_warn(inode, "read deduplicated not supported");
817 return -EOPNOTSUPP;
818 }
819
820 return 0;
821 }
822
823 /*
824 * ntfs_file_read_iter - file_operations::read_iter
825 */
ntfs_file_read_iter(struct kiocb * iocb,struct iov_iter * iter)826 static ssize_t ntfs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
827 {
828 struct file *file = iocb->ki_filp;
829 struct inode *inode = file_inode(file);
830 struct ntfs_inode *ni = ntfs_i(inode);
831 size_t bytes = iov_iter_count(iter);
832 loff_t valid, i_size, vbo, end;
833 unsigned int dio_flags;
834 ssize_t err;
835
836 err = check_read_restriction(inode);
837 if (err)
838 return err;
839
840 if (!bytes)
841 return 0; /* skip atime */
842
843 if (is_compressed(ni)) {
844 if (iocb->ki_flags & IOCB_DIRECT) {
845 ntfs_inode_warn(
846 inode, "direct i/o + compressed not supported");
847 return -EOPNOTSUPP;
848 }
849 /* Turn off readahead for compressed files. */
850 file->f_ra.ra_pages = 0;
851 }
852
853 /* Fallback to buffered I/O if the inode does not support direct I/O. */
854 if (!(iocb->ki_flags & IOCB_DIRECT) ||
855 !ntfs_should_use_dio(iocb, iter)) {
856 iocb->ki_flags &= ~IOCB_DIRECT;
857 return generic_file_read_iter(iocb, iter);
858 }
859
860 if (iocb->ki_flags & IOCB_NOWAIT) {
861 if (!inode_trylock_shared(inode))
862 return -EAGAIN;
863 } else {
864 inode_lock_shared(inode);
865 }
866
867 vbo = iocb->ki_pos;
868 end = vbo + bytes;
869 dio_flags = 0;
870 valid = ni->i_valid;
871 i_size = inode->i_size;
872
873 if (vbo < valid) {
874 if (valid < end) {
875 /* read cross 'valid' size. */
876 dio_flags |= IOMAP_DIO_FORCE_WAIT;
877 }
878
879 if (ni->file.run_da.count) {
880 /* Direct I/O is not compatible with delalloc. */
881 err = ni_allocate_da_blocks(ni);
882 if (err)
883 goto out;
884 }
885
886 err = iomap_dio_rw(iocb, iter, &ntfs_iomap_ops, NULL, dio_flags,
887 NULL, 0);
888
889 if (err <= 0)
890 goto out;
891 end = vbo + err;
892 if (valid < end) {
893 size_t to_zero = end - valid;
894 /* Fix iter. */
895 iov_iter_revert(iter, to_zero);
896 iov_iter_zero(to_zero, iter);
897 }
898 } else if (vbo < i_size) {
899 if (end > i_size)
900 bytes = i_size - vbo;
901 iov_iter_zero(bytes, iter);
902 iocb->ki_pos += bytes;
903 err = bytes;
904 }
905
906 out:
907 inode_unlock_shared(inode);
908 file_accessed(iocb->ki_filp);
909 return err;
910 }
911
912 /*
913 * ntfs_file_splice_read - file_operations::splice_read
914 */
ntfs_file_splice_read(struct file * in,loff_t * ppos,struct pipe_inode_info * pipe,size_t len,unsigned int flags)915 static ssize_t ntfs_file_splice_read(struct file *in, loff_t *ppos,
916 struct pipe_inode_info *pipe, size_t len,
917 unsigned int flags)
918 {
919 struct inode *inode = file_inode(in);
920 ssize_t err;
921
922 err = check_read_restriction(inode);
923 if (err)
924 return err;
925
926 if (is_compressed(ntfs_i(inode))) {
927 /* Turn off readahead for compressed files. */
928 in->f_ra.ra_pages = 0;
929 }
930
931 return filemap_splice_read(in, ppos, pipe, len, flags);
932 }
933
934 /*
935 * ntfs_get_frame_pages
936 *
937 * Return: Array of locked pages.
938 */
ntfs_get_frame_pages(struct address_space * mapping,pgoff_t index,struct page ** pages,u32 pages_per_frame,bool * frame_uptodate)939 static int ntfs_get_frame_pages(struct address_space *mapping, pgoff_t index,
940 struct page **pages, u32 pages_per_frame,
941 bool *frame_uptodate)
942 {
943 gfp_t gfp_mask = mapping_gfp_mask(mapping);
944 u32 npages;
945
946 *frame_uptodate = true;
947
948 for (npages = 0; npages < pages_per_frame; npages++, index++) {
949 struct folio *folio;
950
951 folio = __filemap_get_folio(mapping, index,
952 FGP_LOCK | FGP_ACCESSED | FGP_CREAT,
953 gfp_mask | __GFP_ZERO);
954 if (IS_ERR(folio)) {
955 while (npages--) {
956 folio = page_folio(pages[npages]);
957 folio_unlock(folio);
958 folio_put(folio);
959 }
960
961 return -ENOMEM;
962 }
963
964 if (!folio_test_uptodate(folio))
965 *frame_uptodate = false;
966
967 pages[npages] = &folio->page;
968 }
969
970 return 0;
971 }
972
973 /*
974 * ntfs_compress_write - Helper for ntfs_file_write_iter() (compressed files).
975 */
ntfs_compress_write(struct kiocb * iocb,struct iov_iter * from)976 static ssize_t ntfs_compress_write(struct kiocb *iocb, struct iov_iter *from)
977 {
978 int err;
979 struct file *file = iocb->ki_filp;
980 size_t count = iov_iter_count(from);
981 loff_t pos = iocb->ki_pos;
982 struct inode *inode = file_inode(file);
983 loff_t i_size = i_size_read(inode);
984 struct address_space *mapping = inode->i_mapping;
985 struct ntfs_inode *ni = ntfs_i(inode);
986 u64 valid = ni->i_valid;
987 struct ntfs_sb_info *sbi = ni->mi.sbi;
988 struct page **pages = NULL;
989 struct folio *folio;
990 size_t written = 0;
991 u8 frame_bits = NTFS_LZNT_CUNIT + sbi->cluster_bits;
992 u32 frame_size = 1u << frame_bits;
993 u32 pages_per_frame = frame_size >> PAGE_SHIFT;
994 u32 ip, off;
995 CLST frame;
996 u64 frame_vbo;
997 pgoff_t index;
998 bool frame_uptodate;
999
1000 if (frame_size < PAGE_SIZE) {
1001 /*
1002 * frame_size == 8K if cluster 512
1003 * frame_size == 64K if cluster 4096
1004 */
1005 ntfs_inode_warn(inode, "page size is bigger than frame size");
1006 return -EOPNOTSUPP;
1007 }
1008
1009 pages = kmalloc_objs(struct page *, pages_per_frame, GFP_NOFS);
1010 if (!pages)
1011 return -ENOMEM;
1012
1013 err = file_remove_privs(file);
1014 if (err)
1015 goto out;
1016
1017 err = file_update_time(file);
1018 if (err)
1019 goto out;
1020
1021 /* Zero range [valid : pos). */
1022 while (valid < pos) {
1023 CLST lcn, clen;
1024
1025 frame = valid >> frame_bits;
1026 frame_vbo = valid & ~(frame_size - 1);
1027 off = valid & (frame_size - 1);
1028
1029 err = attr_data_get_block(ni, frame << NTFS_LZNT_CUNIT, 1, &lcn,
1030 &clen, NULL, false, NULL, false);
1031 if (err)
1032 goto out;
1033
1034 if (lcn == SPARSE_LCN) {
1035 ni->i_valid = valid =
1036 frame_vbo + ((u64)clen << sbi->cluster_bits);
1037 continue;
1038 }
1039
1040 /* Load full frame. */
1041 err = ntfs_get_frame_pages(mapping, frame_vbo >> PAGE_SHIFT,
1042 pages, pages_per_frame,
1043 &frame_uptodate);
1044 if (err)
1045 goto out;
1046
1047 if (!frame_uptodate && off) {
1048 err = ni_read_frame(ni, frame_vbo, pages,
1049 pages_per_frame, 0);
1050 if (err) {
1051 for (ip = 0; ip < pages_per_frame; ip++) {
1052 folio = page_folio(pages[ip]);
1053 folio_unlock(folio);
1054 folio_put(folio);
1055 }
1056 goto out;
1057 }
1058 }
1059
1060 ip = off >> PAGE_SHIFT;
1061 off = offset_in_page(valid);
1062 for (; ip < pages_per_frame; ip++, off = 0) {
1063 folio = page_folio(pages[ip]);
1064 folio_zero_segment(folio, off, PAGE_SIZE);
1065 flush_dcache_folio(folio);
1066 folio_mark_uptodate(folio);
1067 }
1068
1069 ni_lock(ni);
1070 err = ni_write_frame(ni, pages, pages_per_frame);
1071 ni_unlock(ni);
1072
1073 for (ip = 0; ip < pages_per_frame; ip++) {
1074 folio = page_folio(pages[ip]);
1075 folio_mark_uptodate(folio);
1076 folio_unlock(folio);
1077 folio_put(folio);
1078 }
1079
1080 if (err)
1081 goto out;
1082
1083 ni->i_valid = valid = frame_vbo + frame_size;
1084 }
1085
1086 /* Copy user data [pos : pos + count). */
1087 while (count) {
1088 size_t copied, bytes;
1089
1090 off = pos & (frame_size - 1);
1091 bytes = frame_size - off;
1092 if (bytes > count)
1093 bytes = count;
1094
1095 frame_vbo = pos & ~(frame_size - 1);
1096 index = frame_vbo >> PAGE_SHIFT;
1097
1098 if (unlikely(fault_in_iov_iter_readable(from, bytes))) {
1099 err = -EFAULT;
1100 goto out;
1101 }
1102
1103 /* Load full frame. */
1104 err = ntfs_get_frame_pages(mapping, index, pages,
1105 pages_per_frame, &frame_uptodate);
1106 if (err)
1107 goto out;
1108
1109 if (!frame_uptodate) {
1110 loff_t to = pos + bytes;
1111
1112 if (off || (to < i_size && (to & (frame_size - 1)))) {
1113 err = ni_read_frame(ni, frame_vbo, pages,
1114 pages_per_frame, 0);
1115 if (err) {
1116 for (ip = 0; ip < pages_per_frame;
1117 ip++) {
1118 folio = page_folio(pages[ip]);
1119 folio_unlock(folio);
1120 folio_put(folio);
1121 }
1122 goto out;
1123 }
1124 }
1125 }
1126
1127 WARN_ON(!bytes);
1128 copied = 0;
1129 ip = off >> PAGE_SHIFT;
1130 off = offset_in_page(pos);
1131
1132 /* Copy user data to pages. */
1133 for (;;) {
1134 size_t cp, tail = PAGE_SIZE - off;
1135
1136 folio = page_folio(pages[ip]);
1137 cp = copy_folio_from_iter_atomic(
1138 folio, off, min(tail, bytes), from);
1139 flush_dcache_folio(folio);
1140
1141 copied += cp;
1142 bytes -= cp;
1143 if (!bytes || !cp)
1144 break;
1145
1146 if (cp < tail) {
1147 off += cp;
1148 } else {
1149 ip++;
1150 off = 0;
1151 }
1152 }
1153
1154 ni_lock(ni);
1155 err = ni_write_frame(ni, pages, pages_per_frame);
1156 ni_unlock(ni);
1157
1158 for (ip = 0; ip < pages_per_frame; ip++) {
1159 folio = page_folio(pages[ip]);
1160 folio_clear_dirty(folio);
1161 folio_mark_uptodate(folio);
1162 folio_unlock(folio);
1163 folio_put(folio);
1164 }
1165
1166 if (err)
1167 goto out;
1168
1169 /*
1170 * We can loop for a long time in here. Be nice and allow
1171 * us to schedule out to avoid softlocking if preempt
1172 * is disabled.
1173 */
1174 cond_resched();
1175
1176 pos += copied;
1177 written += copied;
1178
1179 count = iov_iter_count(from);
1180 }
1181
1182 out:
1183 kfree(pages);
1184
1185 if (err < 0)
1186 return err;
1187
1188 iocb->ki_pos += written;
1189 if (iocb->ki_pos > ni->i_valid)
1190 ni->i_valid = iocb->ki_pos;
1191 if (iocb->ki_pos > i_size)
1192 i_size_write(inode, iocb->ki_pos);
1193
1194 return written;
1195 }
1196
1197 /*
1198 * check_write_restriction:
1199 * common code for ntfs_file_write_iter and ntfs_file_splice_write
1200 */
check_write_restriction(struct inode * inode)1201 static int check_write_restriction(struct inode *inode)
1202 {
1203 struct ntfs_inode *ni = ntfs_i(inode);
1204
1205 /* Avoid any operation if inode is bad. */
1206 if (unlikely(is_bad_ni(ni)))
1207 return -EINVAL;
1208
1209 if (unlikely(ntfs3_forced_shutdown(inode->i_sb)))
1210 return -EIO;
1211
1212 if (is_encrypted(ni)) {
1213 ntfs_inode_warn(inode, "encrypted i/o not supported");
1214 return -EOPNOTSUPP;
1215 }
1216
1217 if (is_dedup(ni)) {
1218 ntfs_inode_warn(inode, "write into deduplicated not supported");
1219 return -EOPNOTSUPP;
1220 }
1221
1222 if (unlikely(IS_IMMUTABLE(inode)))
1223 return -EPERM;
1224
1225 return 0;
1226 }
1227
1228 /*
1229 * ntfs_file_write_iter - file_operations::write_iter
1230 */
ntfs_file_write_iter(struct kiocb * iocb,struct iov_iter * from)1231 static ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1232 {
1233 struct file *file = iocb->ki_filp;
1234 struct inode *inode = file_inode(file);
1235 struct ntfs_inode *ni = ntfs_i(inode);
1236 ssize_t ret, err;
1237
1238 if (!inode_trylock(inode)) {
1239 if (iocb->ki_flags & IOCB_NOWAIT)
1240 return -EAGAIN;
1241 inode_lock(inode);
1242 }
1243
1244 ret = check_write_restriction(inode);
1245 if (ret)
1246 goto out;
1247
1248 if (is_compressed(ni) && (iocb->ki_flags & IOCB_DIRECT)) {
1249 ntfs_inode_warn(inode, "direct i/o + compressed not supported");
1250 ret = -EOPNOTSUPP;
1251 goto out;
1252 }
1253
1254 ret = generic_write_checks(iocb, from);
1255 if (ret <= 0)
1256 goto out;
1257
1258 err = file_modified(iocb->ki_filp);
1259 if (err) {
1260 ret = err;
1261 goto out;
1262 }
1263
1264 if (WARN_ON(ni->ni_flags & NI_FLAG_COMPRESSED_MASK)) {
1265 /* Should never be here, see ntfs_file_open(). */
1266 ret = -EOPNOTSUPP;
1267 goto out;
1268 }
1269
1270 ret = ntfs_extend(inode, iocb->ki_pos, ret, file);
1271 if (ret)
1272 goto out;
1273
1274 if (is_compressed(ni)) {
1275 ret = ntfs_compress_write(iocb, from);
1276 goto out;
1277 }
1278
1279 /* Fallback to buffered I/O if the inode does not support direct I/O. */
1280 if (!(iocb->ki_flags & IOCB_DIRECT) ||
1281 !ntfs_should_use_dio(iocb, from)) {
1282 iocb->ki_flags &= ~IOCB_DIRECT;
1283
1284 ret = iomap_file_buffered_write(iocb, from, &ntfs_iomap_ops,
1285 &ntfs_iomap_folio_ops, NULL);
1286 inode_unlock(inode);
1287
1288 if (likely(ret > 0))
1289 ret = generic_write_sync(iocb, ret);
1290
1291 return ret;
1292 }
1293
1294 if (ni->file.run_da.count) {
1295 /* Direct I/O is not compatible with delalloc. */
1296 ret = ni_allocate_da_blocks(ni);
1297 if (ret)
1298 goto out;
1299 }
1300
1301 ret = iomap_dio_rw(iocb, from, &ntfs_iomap_ops, NULL, 0, NULL, 0);
1302
1303 if (ret == -ENOTBLK) {
1304 /* Returns -ENOTBLK in case of a page invalidation failure for writes.*/
1305 /* The callers needs to fall back to buffered I/O in this case. */
1306 ret = 0;
1307 }
1308
1309 if (ret >= 0 && iov_iter_count(from)) {
1310 loff_t offset = iocb->ki_pos, endbyte;
1311
1312 iocb->ki_flags &= ~IOCB_DIRECT;
1313 err = iomap_file_buffered_write(iocb, from, &ntfs_iomap_ops,
1314 &ntfs_iomap_folio_ops, NULL);
1315 if (err < 0) {
1316 ret = err;
1317 goto out;
1318 }
1319
1320 /*
1321 * We need to ensure that the pages within the page cache for
1322 * the range covered by this I/O are written to disk and
1323 * invalidated. This is in attempt to preserve the expected
1324 * direct I/O semantics in the case we fallback to buffered I/O
1325 * to complete off the I/O request.
1326 */
1327 ret += err;
1328 endbyte = offset + err - 1;
1329 err = filemap_write_and_wait_range(inode->i_mapping, offset,
1330 endbyte);
1331 if (err) {
1332 ret = err;
1333 goto out;
1334 }
1335
1336 invalidate_mapping_pages(inode->i_mapping, offset >> PAGE_SHIFT,
1337 endbyte >> PAGE_SHIFT);
1338 }
1339
1340 out:
1341 inode_unlock(inode);
1342
1343 return ret;
1344 }
1345
1346 /*
1347 * ntfs_file_open - file_operations::open
1348 */
ntfs_file_open(struct inode * inode,struct file * file)1349 int ntfs_file_open(struct inode *inode, struct file *file)
1350 {
1351 struct ntfs_inode *ni = ntfs_i(inode);
1352
1353 /* Avoid any operation if inode is bad. */
1354 if (unlikely(is_bad_ni(ni)))
1355 return -EINVAL;
1356
1357 if (unlikely(ntfs3_forced_shutdown(inode->i_sb)))
1358 return -EIO;
1359
1360 if (unlikely((is_compressed(ni) || is_encrypted(ni)) &&
1361 (file->f_flags & O_DIRECT))) {
1362 return -EOPNOTSUPP;
1363 }
1364
1365 /* Decompress "external compressed" file if opened for rw. */
1366 if ((ni->ni_flags & NI_FLAG_COMPRESSED_MASK) &&
1367 (file->f_flags & (O_WRONLY | O_RDWR | O_TRUNC))) {
1368 #ifdef CONFIG_NTFS3_LZX_XPRESS
1369 int err = ni_decompress_file(ni);
1370
1371 if (err)
1372 return err;
1373 #else
1374 ntfs_inode_warn(
1375 inode,
1376 "activate CONFIG_NTFS3_LZX_XPRESS to write external compressed files");
1377 return -EOPNOTSUPP;
1378 #endif
1379 }
1380
1381 file->f_mode |= FMODE_NOWAIT | FMODE_CAN_ODIRECT;
1382
1383 return generic_file_open(inode, file);
1384 }
1385
1386 /*
1387 * ntfs_file_release - file_operations::release
1388 *
1389 * Called when an inode is released. Note that this is different
1390 * from ntfs_file_open: open gets called at every open, but release
1391 * gets called only when /all/ the files are closed.
1392 */
ntfs_file_release(struct inode * inode,struct file * file)1393 static int ntfs_file_release(struct inode *inode, struct file *file)
1394 {
1395 int err;
1396 struct ntfs_inode *ni;
1397
1398 if (!(file->f_mode & FMODE_WRITE) ||
1399 atomic_read(&inode->i_writecount) != 1 ||
1400 inode->i_ino == MFT_REC_MFT) {
1401 return 0;
1402 }
1403
1404 /* Close the last writer on the inode. */
1405 ni = ntfs_i(inode);
1406
1407 /* Allocate delayed blocks (clusters). */
1408 err = ni_allocate_da_blocks(ni);
1409 if (err)
1410 goto out;
1411
1412 if (ni->mi.sbi->options->prealloc) {
1413 ni_lock(ni);
1414 down_write(&ni->file.run_lock);
1415
1416 /* Deallocate preallocated. */
1417 err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run,
1418 inode->i_size, &ni->i_valid, false);
1419
1420 up_write(&ni->file.run_lock);
1421 ni_unlock(ni);
1422 }
1423 out:
1424 return err;
1425 }
1426
1427 /*
1428 * ntfs_fiemap - inode_operations::fiemap
1429 */
ntfs_fiemap(struct inode * inode,struct fiemap_extent_info * fieinfo,__u64 start,__u64 len)1430 int ntfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
1431 __u64 start, __u64 len)
1432 {
1433 int err;
1434 struct ntfs_inode *ni = ntfs_i(inode);
1435
1436 /* Avoid any operation if inode is bad. */
1437 if (unlikely(is_bad_ni(ni)))
1438 return -EINVAL;
1439
1440 if (is_compressed(ni)) {
1441 /* Unfortunately cp -r incorrectly treats compressed clusters. */
1442 ntfs_inode_warn(inode,
1443 "fiemap is not supported for compressed file");
1444 return -EOPNOTSUPP;
1445 }
1446
1447 if (S_ISDIR(inode->i_mode)) {
1448 /* TODO: add support for dirs (ATTR_ALLOC). */
1449 ntfs_inode_warn(inode,
1450 "fiemap is not supported for directories");
1451 return -EOPNOTSUPP;
1452 }
1453
1454 if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
1455 ntfs_inode_warn(inode, "fiemap(xattr) is not supported");
1456 return -EOPNOTSUPP;
1457 }
1458
1459 inode_lock_shared(inode);
1460
1461 err = iomap_fiemap(inode, fieinfo, start, len, &ntfs_iomap_ops);
1462
1463 inode_unlock_shared(inode);
1464 return err;
1465 }
1466
1467 /*
1468 * ntfs_file_splice_write - file_operations::splice_write
1469 */
ntfs_file_splice_write(struct pipe_inode_info * pipe,struct file * file,loff_t * ppos,size_t len,unsigned int flags)1470 static ssize_t ntfs_file_splice_write(struct pipe_inode_info *pipe,
1471 struct file *file, loff_t *ppos,
1472 size_t len, unsigned int flags)
1473 {
1474 ssize_t err;
1475 struct inode *inode = file_inode(file);
1476
1477 err = check_write_restriction(inode);
1478 if (err)
1479 return err;
1480
1481 return iter_file_splice_write(pipe, file, ppos, len, flags);
1482 }
1483
1484 /*
1485 * ntfs_file_fsync - file_operations::fsync
1486 */
ntfs_file_fsync(struct file * file,loff_t start,loff_t end,int datasync)1487 int ntfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1488 {
1489 struct inode *inode = file_inode(file);
1490 struct super_block *sb = inode->i_sb;
1491 struct ntfs_sb_info *sbi = sb->s_fs_info;
1492 int err, ret;
1493
1494 if (unlikely(ntfs3_forced_shutdown(sb)))
1495 return -EIO;
1496
1497 ret = file_write_and_wait_range(file, start, end);
1498 if (ret)
1499 return ret;
1500
1501 ret = write_inode_now(inode, !datasync);
1502
1503 if (!ret) {
1504 ret = ni_write_parents(ntfs_i(inode), !datasync);
1505 }
1506
1507 if (!ret) {
1508 ntfs_set_state(sbi, NTFS_DIRTY_CLEAR);
1509 ntfs_update_mftmirr(sbi);
1510 }
1511
1512 err = sync_blockdev(sb->s_bdev);
1513 if (unlikely(err && !ret))
1514 ret = err;
1515 if (!ret)
1516 blkdev_issue_flush(sb->s_bdev);
1517 return ret;
1518 }
1519
1520 /*
1521 * ntfs_llseek - file_operations::llseek
1522 */
ntfs_llseek(struct file * file,loff_t offset,int whence)1523 static loff_t ntfs_llseek(struct file *file, loff_t offset, int whence)
1524 {
1525 struct inode *inode = file->f_mapping->host;
1526 struct ntfs_inode *ni = ntfs_i(inode);
1527 loff_t maxbytes = ntfs_get_maxbytes(ni);
1528 loff_t ret;
1529
1530 if (whence == SEEK_DATA || whence == SEEK_HOLE) {
1531 inode_lock_shared(inode);
1532 /* Scan file for hole or data. */
1533 ret = ni_seek_data_or_hole(ni, offset, whence == SEEK_DATA);
1534 inode_unlock_shared(inode);
1535
1536 if (ret >= 0)
1537 ret = vfs_setpos(file, ret, maxbytes);
1538 } else {
1539 ret = generic_file_llseek_size(file, offset, whence, maxbytes,
1540 i_size_read(inode));
1541 }
1542 return ret;
1543 }
1544
1545 // clang-format off
1546 const struct inode_operations ntfs_file_inode_operations = {
1547 .getattr = ntfs_getattr,
1548 .setattr = ntfs_setattr,
1549 .listxattr = ntfs_listxattr,
1550 .get_acl = ntfs_get_acl,
1551 .set_acl = ntfs_set_acl,
1552 .fiemap = ntfs_fiemap,
1553 };
1554
1555 const struct file_operations ntfs_file_operations = {
1556 .llseek = ntfs_llseek,
1557 .read_iter = ntfs_file_read_iter,
1558 .write_iter = ntfs_file_write_iter,
1559 .unlocked_ioctl = ntfs_ioctl,
1560 #ifdef CONFIG_COMPAT
1561 .compat_ioctl = ntfs_compat_ioctl,
1562 #endif
1563 .splice_read = ntfs_file_splice_read,
1564 .splice_write = ntfs_file_splice_write,
1565 .mmap_prepare = ntfs_file_mmap_prepare,
1566 .open = ntfs_file_open,
1567 .fsync = ntfs_file_fsync,
1568 .fallocate = ntfs_fallocate,
1569 .release = ntfs_file_release,
1570 .setlease = generic_setlease,
1571 };
1572
1573 #if IS_ENABLED(CONFIG_NTFS_FS)
1574 const struct file_operations ntfs_legacy_file_operations = {
1575 .llseek = generic_file_llseek,
1576 .read_iter = ntfs_file_read_iter,
1577 .splice_read = ntfs_file_splice_read,
1578 .open = ntfs_file_open,
1579 .release = ntfs_file_release,
1580 .setlease = generic_setlease,
1581 };
1582 #endif
1583 // clang-format on
1584