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 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 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 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 */ 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 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 */ 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 */ 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 (is_encrypted(ni)) { 264 ntfs_inode_warn(inode, "mmap encrypted not supported"); 265 return -EOPNOTSUPP; 266 } 267 268 if (is_dedup(ni)) { 269 ntfs_inode_warn(inode, "mmap deduplicated not supported"); 270 return -EOPNOTSUPP; 271 } 272 273 if (is_compressed(ni) && rw) { 274 ntfs_inode_warn(inode, "mmap(write) compressed not supported"); 275 return -EOPNOTSUPP; 276 } 277 278 if (rw) { 279 u64 to = min_t(loff_t, i_size_read(inode), 280 from + vma->vm_end - vma->vm_start); 281 282 if (is_sparsed(ni)) { 283 /* Allocate clusters for rw map. */ 284 struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info; 285 CLST lcn, len; 286 CLST vcn = from >> sbi->cluster_bits; 287 CLST end = bytes_to_cluster(sbi, to); 288 bool new; 289 290 for (; vcn < end; vcn += len) { 291 err = attr_data_get_block(ni, vcn, 1, &lcn, 292 &len, &new, true); 293 if (err) 294 goto out; 295 } 296 } 297 298 if (ni->i_valid < to) { 299 if (!inode_trylock(inode)) { 300 err = -EAGAIN; 301 goto out; 302 } 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 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 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 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 */ 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 } else if (mode & FALLOC_FL_INSERT_RANGE) { 557 /* Check new size. */ 558 err = inode_newsize_ok(inode, new_size); 559 if (err) 560 goto out; 561 562 /* Write out all dirty pages. */ 563 err = filemap_write_and_wait_range(mapping, vbo_down, 564 LLONG_MAX); 565 if (err) 566 goto out; 567 truncate_pagecache(inode, vbo_down); 568 569 ni_lock(ni); 570 err = attr_insert_range(ni, vbo, len); 571 ni_unlock(ni); 572 if (err) 573 goto out; 574 } else { 575 /* Check new size. */ 576 u8 cluster_bits = sbi->cluster_bits; 577 578 /* generic/213: expected -ENOSPC instead of -EFBIG. */ 579 if (!is_supported_holes) { 580 loff_t to_alloc = new_size - inode_get_bytes(inode); 581 582 if (to_alloc > 0 && 583 (to_alloc >> cluster_bits) > 584 wnd_zeroes(&sbi->used.bitmap)) { 585 err = -ENOSPC; 586 goto out; 587 } 588 } 589 590 err = inode_newsize_ok(inode, new_size); 591 if (err) 592 goto out; 593 594 if (new_size > i_size) { 595 /* 596 * Allocate clusters, do not change 'valid' size. 597 */ 598 err = ntfs_set_size(inode, new_size); 599 if (err) 600 goto out; 601 } 602 603 if (is_supported_holes) { 604 CLST vcn = vbo >> cluster_bits; 605 CLST cend = bytes_to_cluster(sbi, end); 606 CLST cend_v = bytes_to_cluster(sbi, ni->i_valid); 607 CLST lcn, clen; 608 bool new; 609 610 if (cend_v > cend) 611 cend_v = cend; 612 613 /* 614 * Allocate and zero new clusters. 615 * Zeroing these clusters may be too long. 616 */ 617 for (; vcn < cend_v; vcn += clen) { 618 err = attr_data_get_block(ni, vcn, cend_v - vcn, 619 &lcn, &clen, &new, 620 true); 621 if (err) 622 goto out; 623 } 624 /* 625 * Allocate but not zero new clusters. 626 */ 627 for (; vcn < cend; vcn += clen) { 628 err = attr_data_get_block(ni, vcn, cend - vcn, 629 &lcn, &clen, &new, 630 false); 631 if (err) 632 goto out; 633 } 634 } 635 636 if (mode & FALLOC_FL_KEEP_SIZE) { 637 ni_lock(ni); 638 /* True - Keep preallocated. */ 639 err = attr_set_size(ni, ATTR_DATA, NULL, 0, 640 &ni->file.run, i_size, &ni->i_valid, 641 true, NULL); 642 ni_unlock(ni); 643 if (err) 644 goto out; 645 } else if (new_size > i_size) { 646 inode->i_size = new_size; 647 } 648 } 649 650 ok: 651 err = file_modified(file); 652 if (err) 653 goto out; 654 655 out: 656 if (map_locked) 657 filemap_invalidate_unlock(mapping); 658 659 if (!err) { 660 inode->i_mtime = inode_set_ctime_current(inode); 661 mark_inode_dirty(inode); 662 } 663 664 inode_unlock(inode); 665 return err; 666 } 667 668 /* 669 * ntfs3_setattr - inode_operations::setattr 670 */ 671 int ntfs3_setattr(struct mnt_idmap *idmap, struct dentry *dentry, 672 struct iattr *attr) 673 { 674 struct inode *inode = d_inode(dentry); 675 struct ntfs_inode *ni = ntfs_i(inode); 676 u32 ia_valid = attr->ia_valid; 677 umode_t mode = inode->i_mode; 678 int err; 679 680 err = setattr_prepare(idmap, dentry, attr); 681 if (err) 682 goto out; 683 684 if (ia_valid & ATTR_SIZE) { 685 loff_t newsize, oldsize; 686 687 if (WARN_ON(ni->ni_flags & NI_FLAG_COMPRESSED_MASK)) { 688 /* Should never be here, see ntfs_file_open(). */ 689 err = -EOPNOTSUPP; 690 goto out; 691 } 692 inode_dio_wait(inode); 693 oldsize = inode->i_size; 694 newsize = attr->ia_size; 695 696 if (newsize <= oldsize) 697 err = ntfs_truncate(inode, newsize); 698 else 699 err = ntfs_extend(inode, newsize, 0, NULL); 700 701 if (err) 702 goto out; 703 704 ni->ni_flags |= NI_FLAG_UPDATE_PARENT; 705 inode->i_size = newsize; 706 } 707 708 setattr_copy(idmap, inode, attr); 709 710 if (mode != inode->i_mode) { 711 err = ntfs_acl_chmod(idmap, dentry); 712 if (err) 713 goto out; 714 715 /* Linux 'w' -> Windows 'ro'. */ 716 if (0222 & inode->i_mode) 717 ni->std_fa &= ~FILE_ATTRIBUTE_READONLY; 718 else 719 ni->std_fa |= FILE_ATTRIBUTE_READONLY; 720 } 721 722 if (ia_valid & (ATTR_UID | ATTR_GID | ATTR_MODE)) 723 ntfs_save_wsl_perm(inode, NULL); 724 mark_inode_dirty(inode); 725 out: 726 return err; 727 } 728 729 static ssize_t ntfs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) 730 { 731 struct file *file = iocb->ki_filp; 732 struct inode *inode = file->f_mapping->host; 733 struct ntfs_inode *ni = ntfs_i(inode); 734 735 if (is_encrypted(ni)) { 736 ntfs_inode_warn(inode, "encrypted i/o not supported"); 737 return -EOPNOTSUPP; 738 } 739 740 if (is_compressed(ni) && (iocb->ki_flags & IOCB_DIRECT)) { 741 ntfs_inode_warn(inode, "direct i/o + compressed not supported"); 742 return -EOPNOTSUPP; 743 } 744 745 #ifndef CONFIG_NTFS3_LZX_XPRESS 746 if (ni->ni_flags & NI_FLAG_COMPRESSED_MASK) { 747 ntfs_inode_warn( 748 inode, 749 "activate CONFIG_NTFS3_LZX_XPRESS to read external compressed files"); 750 return -EOPNOTSUPP; 751 } 752 #endif 753 754 if (is_dedup(ni)) { 755 ntfs_inode_warn(inode, "read deduplicated not supported"); 756 return -EOPNOTSUPP; 757 } 758 759 return generic_file_read_iter(iocb, iter); 760 } 761 762 static ssize_t ntfs_file_splice_read(struct file *in, loff_t *ppos, 763 struct pipe_inode_info *pipe, size_t len, 764 unsigned int flags) 765 { 766 struct inode *inode = in->f_mapping->host; 767 struct ntfs_inode *ni = ntfs_i(inode); 768 769 if (is_encrypted(ni)) { 770 ntfs_inode_warn(inode, "encrypted i/o not supported"); 771 return -EOPNOTSUPP; 772 } 773 774 #ifndef CONFIG_NTFS3_LZX_XPRESS 775 if (ni->ni_flags & NI_FLAG_COMPRESSED_MASK) { 776 ntfs_inode_warn( 777 inode, 778 "activate CONFIG_NTFS3_LZX_XPRESS to read external compressed files"); 779 return -EOPNOTSUPP; 780 } 781 #endif 782 783 if (is_dedup(ni)) { 784 ntfs_inode_warn(inode, "read deduplicated not supported"); 785 return -EOPNOTSUPP; 786 } 787 788 return filemap_splice_read(in, ppos, pipe, len, flags); 789 } 790 791 /* 792 * ntfs_get_frame_pages 793 * 794 * Return: Array of locked pages. 795 */ 796 static int ntfs_get_frame_pages(struct address_space *mapping, pgoff_t index, 797 struct page **pages, u32 pages_per_frame, 798 bool *frame_uptodate) 799 { 800 gfp_t gfp_mask = mapping_gfp_mask(mapping); 801 u32 npages; 802 803 *frame_uptodate = true; 804 805 for (npages = 0; npages < pages_per_frame; npages++, index++) { 806 struct page *page; 807 808 page = find_or_create_page(mapping, index, gfp_mask); 809 if (!page) { 810 while (npages--) { 811 page = pages[npages]; 812 unlock_page(page); 813 put_page(page); 814 } 815 816 return -ENOMEM; 817 } 818 819 if (!PageUptodate(page)) 820 *frame_uptodate = false; 821 822 pages[npages] = page; 823 } 824 825 return 0; 826 } 827 828 /* 829 * ntfs_compress_write - Helper for ntfs_file_write_iter() (compressed files). 830 */ 831 static ssize_t ntfs_compress_write(struct kiocb *iocb, struct iov_iter *from) 832 { 833 int err; 834 struct file *file = iocb->ki_filp; 835 size_t count = iov_iter_count(from); 836 loff_t pos = iocb->ki_pos; 837 struct inode *inode = file_inode(file); 838 loff_t i_size = inode->i_size; 839 struct address_space *mapping = inode->i_mapping; 840 struct ntfs_inode *ni = ntfs_i(inode); 841 u64 valid = ni->i_valid; 842 struct ntfs_sb_info *sbi = ni->mi.sbi; 843 struct page *page, **pages = NULL; 844 size_t written = 0; 845 u8 frame_bits = NTFS_LZNT_CUNIT + sbi->cluster_bits; 846 u32 frame_size = 1u << frame_bits; 847 u32 pages_per_frame = frame_size >> PAGE_SHIFT; 848 u32 ip, off; 849 CLST frame; 850 u64 frame_vbo; 851 pgoff_t index; 852 bool frame_uptodate; 853 854 if (frame_size < PAGE_SIZE) { 855 /* 856 * frame_size == 8K if cluster 512 857 * frame_size == 64K if cluster 4096 858 */ 859 ntfs_inode_warn(inode, "page size is bigger than frame size"); 860 return -EOPNOTSUPP; 861 } 862 863 pages = kmalloc_array(pages_per_frame, sizeof(struct page *), GFP_NOFS); 864 if (!pages) 865 return -ENOMEM; 866 867 err = file_remove_privs(file); 868 if (err) 869 goto out; 870 871 err = file_update_time(file); 872 if (err) 873 goto out; 874 875 /* Zero range [valid : pos). */ 876 while (valid < pos) { 877 CLST lcn, clen; 878 879 frame = valid >> frame_bits; 880 frame_vbo = valid & ~(frame_size - 1); 881 off = valid & (frame_size - 1); 882 883 err = attr_data_get_block(ni, frame << NTFS_LZNT_CUNIT, 1, &lcn, 884 &clen, NULL, false); 885 if (err) 886 goto out; 887 888 if (lcn == SPARSE_LCN) { 889 ni->i_valid = valid = 890 frame_vbo + ((u64)clen << sbi->cluster_bits); 891 continue; 892 } 893 894 /* Load full frame. */ 895 err = ntfs_get_frame_pages(mapping, frame_vbo >> PAGE_SHIFT, 896 pages, pages_per_frame, 897 &frame_uptodate); 898 if (err) 899 goto out; 900 901 if (!frame_uptodate && off) { 902 err = ni_read_frame(ni, frame_vbo, pages, 903 pages_per_frame); 904 if (err) { 905 for (ip = 0; ip < pages_per_frame; ip++) { 906 page = pages[ip]; 907 unlock_page(page); 908 put_page(page); 909 } 910 goto out; 911 } 912 } 913 914 ip = off >> PAGE_SHIFT; 915 off = offset_in_page(valid); 916 for (; ip < pages_per_frame; ip++, off = 0) { 917 page = pages[ip]; 918 zero_user_segment(page, off, PAGE_SIZE); 919 flush_dcache_page(page); 920 SetPageUptodate(page); 921 } 922 923 ni_lock(ni); 924 err = ni_write_frame(ni, pages, pages_per_frame); 925 ni_unlock(ni); 926 927 for (ip = 0; ip < pages_per_frame; ip++) { 928 page = pages[ip]; 929 SetPageUptodate(page); 930 unlock_page(page); 931 put_page(page); 932 } 933 934 if (err) 935 goto out; 936 937 ni->i_valid = valid = frame_vbo + frame_size; 938 } 939 940 /* Copy user data [pos : pos + count). */ 941 while (count) { 942 size_t copied, bytes; 943 944 off = pos & (frame_size - 1); 945 bytes = frame_size - off; 946 if (bytes > count) 947 bytes = count; 948 949 frame_vbo = pos & ~(frame_size - 1); 950 index = frame_vbo >> PAGE_SHIFT; 951 952 if (unlikely(fault_in_iov_iter_readable(from, bytes))) { 953 err = -EFAULT; 954 goto out; 955 } 956 957 /* Load full frame. */ 958 err = ntfs_get_frame_pages(mapping, index, pages, 959 pages_per_frame, &frame_uptodate); 960 if (err) 961 goto out; 962 963 if (!frame_uptodate) { 964 loff_t to = pos + bytes; 965 966 if (off || (to < i_size && (to & (frame_size - 1)))) { 967 err = ni_read_frame(ni, frame_vbo, pages, 968 pages_per_frame); 969 if (err) { 970 for (ip = 0; ip < pages_per_frame; 971 ip++) { 972 page = pages[ip]; 973 unlock_page(page); 974 put_page(page); 975 } 976 goto out; 977 } 978 } 979 } 980 981 WARN_ON(!bytes); 982 copied = 0; 983 ip = off >> PAGE_SHIFT; 984 off = offset_in_page(pos); 985 986 /* Copy user data to pages. */ 987 for (;;) { 988 size_t cp, tail = PAGE_SIZE - off; 989 990 page = pages[ip]; 991 cp = copy_page_from_iter_atomic(page, off, 992 min(tail, bytes), from); 993 flush_dcache_page(page); 994 995 copied += cp; 996 bytes -= cp; 997 if (!bytes || !cp) 998 break; 999 1000 if (cp < tail) { 1001 off += cp; 1002 } else { 1003 ip++; 1004 off = 0; 1005 } 1006 } 1007 1008 ni_lock(ni); 1009 err = ni_write_frame(ni, pages, pages_per_frame); 1010 ni_unlock(ni); 1011 1012 for (ip = 0; ip < pages_per_frame; ip++) { 1013 page = pages[ip]; 1014 ClearPageDirty(page); 1015 SetPageUptodate(page); 1016 unlock_page(page); 1017 put_page(page); 1018 } 1019 1020 if (err) 1021 goto out; 1022 1023 /* 1024 * We can loop for a long time in here. Be nice and allow 1025 * us to schedule out to avoid softlocking if preempt 1026 * is disabled. 1027 */ 1028 cond_resched(); 1029 1030 pos += copied; 1031 written += copied; 1032 1033 count = iov_iter_count(from); 1034 } 1035 1036 out: 1037 kfree(pages); 1038 1039 if (err < 0) 1040 return err; 1041 1042 iocb->ki_pos += written; 1043 if (iocb->ki_pos > ni->i_valid) 1044 ni->i_valid = iocb->ki_pos; 1045 1046 return written; 1047 } 1048 1049 /* 1050 * ntfs_file_write_iter - file_operations::write_iter 1051 */ 1052 static ssize_t ntfs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 1053 { 1054 struct file *file = iocb->ki_filp; 1055 struct address_space *mapping = file->f_mapping; 1056 struct inode *inode = mapping->host; 1057 ssize_t ret; 1058 int err; 1059 struct ntfs_inode *ni = ntfs_i(inode); 1060 1061 if (is_encrypted(ni)) { 1062 ntfs_inode_warn(inode, "encrypted i/o not supported"); 1063 return -EOPNOTSUPP; 1064 } 1065 1066 if (is_compressed(ni) && (iocb->ki_flags & IOCB_DIRECT)) { 1067 ntfs_inode_warn(inode, "direct i/o + compressed not supported"); 1068 return -EOPNOTSUPP; 1069 } 1070 1071 if (is_dedup(ni)) { 1072 ntfs_inode_warn(inode, "write into deduplicated not supported"); 1073 return -EOPNOTSUPP; 1074 } 1075 1076 if (!inode_trylock(inode)) { 1077 if (iocb->ki_flags & IOCB_NOWAIT) 1078 return -EAGAIN; 1079 inode_lock(inode); 1080 } 1081 1082 ret = generic_write_checks(iocb, from); 1083 if (ret <= 0) 1084 goto out; 1085 1086 err = file_modified(iocb->ki_filp); 1087 if (err) { 1088 ret = err; 1089 goto out; 1090 } 1091 1092 if (WARN_ON(ni->ni_flags & NI_FLAG_COMPRESSED_MASK)) { 1093 /* Should never be here, see ntfs_file_open(). */ 1094 ret = -EOPNOTSUPP; 1095 goto out; 1096 } 1097 1098 ret = ntfs_extend(inode, iocb->ki_pos, ret, file); 1099 if (ret) 1100 goto out; 1101 1102 ret = is_compressed(ni) ? ntfs_compress_write(iocb, from) : 1103 __generic_file_write_iter(iocb, from); 1104 1105 out: 1106 inode_unlock(inode); 1107 1108 if (ret > 0) 1109 ret = generic_write_sync(iocb, ret); 1110 1111 return ret; 1112 } 1113 1114 /* 1115 * ntfs_file_open - file_operations::open 1116 */ 1117 int ntfs_file_open(struct inode *inode, struct file *file) 1118 { 1119 struct ntfs_inode *ni = ntfs_i(inode); 1120 1121 if (unlikely((is_compressed(ni) || is_encrypted(ni)) && 1122 (file->f_flags & O_DIRECT))) { 1123 return -EOPNOTSUPP; 1124 } 1125 1126 /* Decompress "external compressed" file if opened for rw. */ 1127 if ((ni->ni_flags & NI_FLAG_COMPRESSED_MASK) && 1128 (file->f_flags & (O_WRONLY | O_RDWR | O_TRUNC))) { 1129 #ifdef CONFIG_NTFS3_LZX_XPRESS 1130 int err = ni_decompress_file(ni); 1131 1132 if (err) 1133 return err; 1134 #else 1135 ntfs_inode_warn( 1136 inode, 1137 "activate CONFIG_NTFS3_LZX_XPRESS to write external compressed files"); 1138 return -EOPNOTSUPP; 1139 #endif 1140 } 1141 1142 return generic_file_open(inode, file); 1143 } 1144 1145 /* 1146 * ntfs_file_release - file_operations::release 1147 */ 1148 static int ntfs_file_release(struct inode *inode, struct file *file) 1149 { 1150 struct ntfs_inode *ni = ntfs_i(inode); 1151 struct ntfs_sb_info *sbi = ni->mi.sbi; 1152 int err = 0; 1153 1154 /* If we are last writer on the inode, drop the block reservation. */ 1155 if (sbi->options->prealloc && 1156 ((file->f_mode & FMODE_WRITE) && 1157 atomic_read(&inode->i_writecount) == 1)) { 1158 ni_lock(ni); 1159 down_write(&ni->file.run_lock); 1160 1161 err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, 1162 inode->i_size, &ni->i_valid, false, NULL); 1163 1164 up_write(&ni->file.run_lock); 1165 ni_unlock(ni); 1166 } 1167 return err; 1168 } 1169 1170 /* 1171 * ntfs_fiemap - file_operations::fiemap 1172 */ 1173 int ntfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 1174 __u64 start, __u64 len) 1175 { 1176 int err; 1177 struct ntfs_inode *ni = ntfs_i(inode); 1178 1179 err = fiemap_prep(inode, fieinfo, start, &len, ~FIEMAP_FLAG_XATTR); 1180 if (err) 1181 return err; 1182 1183 ni_lock(ni); 1184 1185 err = ni_fiemap(ni, fieinfo, start, len); 1186 1187 ni_unlock(ni); 1188 1189 return err; 1190 } 1191 1192 // clang-format off 1193 const struct inode_operations ntfs_file_inode_operations = { 1194 .getattr = ntfs_getattr, 1195 .setattr = ntfs3_setattr, 1196 .listxattr = ntfs_listxattr, 1197 .get_acl = ntfs_get_acl, 1198 .set_acl = ntfs_set_acl, 1199 .fiemap = ntfs_fiemap, 1200 }; 1201 1202 const struct file_operations ntfs_file_operations = { 1203 .llseek = generic_file_llseek, 1204 .read_iter = ntfs_file_read_iter, 1205 .write_iter = ntfs_file_write_iter, 1206 .unlocked_ioctl = ntfs_ioctl, 1207 #ifdef CONFIG_COMPAT 1208 .compat_ioctl = ntfs_compat_ioctl, 1209 #endif 1210 .splice_read = ntfs_file_splice_read, 1211 .mmap = ntfs_file_mmap, 1212 .open = ntfs_file_open, 1213 .fsync = generic_file_fsync, 1214 .splice_write = iter_file_splice_write, 1215 .fallocate = ntfs_fallocate, 1216 .release = ntfs_file_release, 1217 }; 1218 // clang-format on 1219