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