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