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