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