1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * 4 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved. 5 * 6 */ 7 8 #include <linux/buffer_head.h> 9 #include <linux/fs.h> 10 #include <linux/mpage.h> 11 #include <linux/namei.h> 12 #include <linux/nls.h> 13 #include <linux/uio.h> 14 #include <linux/writeback.h> 15 16 #include "debug.h" 17 #include "ntfs.h" 18 #include "ntfs_fs.h" 19 20 /* 21 * ntfs_read_mft - Read record and parses MFT. 22 */ 23 static struct inode *ntfs_read_mft(struct inode *inode, 24 const struct cpu_str *name, 25 const struct MFT_REF *ref) 26 { 27 int err = 0; 28 struct ntfs_inode *ni = ntfs_i(inode); 29 struct super_block *sb = inode->i_sb; 30 struct ntfs_sb_info *sbi = sb->s_fs_info; 31 mode_t mode = 0; 32 struct ATTR_STD_INFO5 *std5 = NULL; 33 struct ATTR_LIST_ENTRY *le; 34 struct ATTRIB *attr; 35 bool is_match = false; 36 bool is_root = false; 37 bool is_dir; 38 unsigned long ino = inode->i_ino; 39 u32 rp_fa = 0, asize, t32; 40 u16 roff, rsize, names = 0; 41 const struct ATTR_FILE_NAME *fname = NULL; 42 const struct INDEX_ROOT *root; 43 struct REPARSE_DATA_BUFFER rp; // 0x18 bytes 44 u64 t64; 45 struct MFT_REC *rec; 46 struct runs_tree *run; 47 48 inode->i_op = NULL; 49 /* Setup 'uid' and 'gid' */ 50 inode->i_uid = sbi->options->fs_uid; 51 inode->i_gid = sbi->options->fs_gid; 52 53 err = mi_init(&ni->mi, sbi, ino); 54 if (err) 55 goto out; 56 57 if (!sbi->mft.ni && ino == MFT_REC_MFT && !sb->s_root) { 58 t64 = sbi->mft.lbo >> sbi->cluster_bits; 59 t32 = bytes_to_cluster(sbi, MFT_REC_VOL * sbi->record_size); 60 sbi->mft.ni = ni; 61 init_rwsem(&ni->file.run_lock); 62 63 if (!run_add_entry(&ni->file.run, 0, t64, t32, true)) { 64 err = -ENOMEM; 65 goto out; 66 } 67 } 68 69 err = mi_read(&ni->mi, ino == MFT_REC_MFT); 70 71 if (err) 72 goto out; 73 74 rec = ni->mi.mrec; 75 76 if (sbi->flags & NTFS_FLAGS_LOG_REPLAYING) { 77 ; 78 } else if (ref->seq != rec->seq) { 79 err = -EINVAL; 80 ntfs_err(sb, "MFT: r=%lx, expect seq=%x instead of %x!", ino, 81 le16_to_cpu(ref->seq), le16_to_cpu(rec->seq)); 82 goto out; 83 } else if (!is_rec_inuse(rec)) { 84 err = -ESTALE; 85 ntfs_err(sb, "Inode r=%x is not in use!", (u32)ino); 86 goto out; 87 } 88 89 if (le32_to_cpu(rec->total) != sbi->record_size) { 90 /* Bad inode? */ 91 err = -EINVAL; 92 goto out; 93 } 94 95 if (!is_rec_base(rec)) { 96 err = -EINVAL; 97 goto out; 98 } 99 100 /* Record should contain $I30 root. */ 101 is_dir = rec->flags & RECORD_FLAG_DIR; 102 103 inode->i_generation = le16_to_cpu(rec->seq); 104 105 /* Enumerate all struct Attributes MFT. */ 106 le = NULL; 107 attr = NULL; 108 109 /* 110 * To reduce tab pressure use goto instead of 111 * while( (attr = ni_enum_attr_ex(ni, attr, &le, NULL) )) 112 */ 113 next_attr: 114 run = NULL; 115 err = -EINVAL; 116 attr = ni_enum_attr_ex(ni, attr, &le, NULL); 117 if (!attr) 118 goto end_enum; 119 120 if (le && le->vcn) { 121 /* This is non primary attribute segment. Ignore if not MFT. */ 122 if (ino != MFT_REC_MFT || attr->type != ATTR_DATA) 123 goto next_attr; 124 125 run = &ni->file.run; 126 asize = le32_to_cpu(attr->size); 127 goto attr_unpack_run; 128 } 129 130 roff = attr->non_res ? 0 : le16_to_cpu(attr->res.data_off); 131 rsize = attr->non_res ? 0 : le32_to_cpu(attr->res.data_size); 132 asize = le32_to_cpu(attr->size); 133 134 if (le16_to_cpu(attr->name_off) + attr->name_len > asize) 135 goto out; 136 137 if (attr->non_res) { 138 t64 = le64_to_cpu(attr->nres.alloc_size); 139 if (le64_to_cpu(attr->nres.data_size) > t64 || 140 le64_to_cpu(attr->nres.valid_size) > t64) 141 goto out; 142 } 143 144 switch (attr->type) { 145 case ATTR_STD: 146 if (attr->non_res || 147 asize < sizeof(struct ATTR_STD_INFO) + roff || 148 rsize < sizeof(struct ATTR_STD_INFO)) 149 goto out; 150 151 if (std5) 152 goto next_attr; 153 154 std5 = Add2Ptr(attr, roff); 155 156 #ifdef STATX_BTIME 157 nt2kernel(std5->cr_time, &ni->i_crtime); 158 #endif 159 nt2kernel(std5->a_time, &inode->i_atime); 160 nt2kernel(std5->c_time, &inode->i_ctime); 161 nt2kernel(std5->m_time, &inode->i_mtime); 162 163 ni->std_fa = std5->fa; 164 165 if (asize >= sizeof(struct ATTR_STD_INFO5) + roff && 166 rsize >= sizeof(struct ATTR_STD_INFO5)) 167 ni->std_security_id = std5->security_id; 168 goto next_attr; 169 170 case ATTR_LIST: 171 if (attr->name_len || le || ino == MFT_REC_LOG) 172 goto out; 173 174 err = ntfs_load_attr_list(ni, attr); 175 if (err) 176 goto out; 177 178 le = NULL; 179 attr = NULL; 180 goto next_attr; 181 182 case ATTR_NAME: 183 if (attr->non_res || asize < SIZEOF_ATTRIBUTE_FILENAME + roff || 184 rsize < SIZEOF_ATTRIBUTE_FILENAME) 185 goto out; 186 187 fname = Add2Ptr(attr, roff); 188 if (fname->type == FILE_NAME_DOS) 189 goto next_attr; 190 191 names += 1; 192 if (name && name->len == fname->name_len && 193 !ntfs_cmp_names_cpu(name, (struct le_str *)&fname->name_len, 194 NULL, false)) 195 is_match = true; 196 197 goto next_attr; 198 199 case ATTR_DATA: 200 if (is_dir) { 201 /* Ignore data attribute in dir record. */ 202 goto next_attr; 203 } 204 205 if (ino == MFT_REC_BADCLUST && !attr->non_res) 206 goto next_attr; 207 208 if (attr->name_len && 209 ((ino != MFT_REC_BADCLUST || !attr->non_res || 210 attr->name_len != ARRAY_SIZE(BAD_NAME) || 211 memcmp(attr_name(attr), BAD_NAME, sizeof(BAD_NAME))) && 212 (ino != MFT_REC_SECURE || !attr->non_res || 213 attr->name_len != ARRAY_SIZE(SDS_NAME) || 214 memcmp(attr_name(attr), SDS_NAME, sizeof(SDS_NAME))))) { 215 /* File contains stream attribute. Ignore it. */ 216 goto next_attr; 217 } 218 219 if (is_attr_sparsed(attr)) 220 ni->std_fa |= FILE_ATTRIBUTE_SPARSE_FILE; 221 else 222 ni->std_fa &= ~FILE_ATTRIBUTE_SPARSE_FILE; 223 224 if (is_attr_compressed(attr)) 225 ni->std_fa |= FILE_ATTRIBUTE_COMPRESSED; 226 else 227 ni->std_fa &= ~FILE_ATTRIBUTE_COMPRESSED; 228 229 if (is_attr_encrypted(attr)) 230 ni->std_fa |= FILE_ATTRIBUTE_ENCRYPTED; 231 else 232 ni->std_fa &= ~FILE_ATTRIBUTE_ENCRYPTED; 233 234 if (!attr->non_res) { 235 ni->i_valid = inode->i_size = rsize; 236 inode_set_bytes(inode, rsize); 237 } 238 239 mode = S_IFREG | (0777 & sbi->options->fs_fmask_inv); 240 241 if (!attr->non_res) { 242 ni->ni_flags |= NI_FLAG_RESIDENT; 243 goto next_attr; 244 } 245 246 inode_set_bytes(inode, attr_ondisk_size(attr)); 247 248 ni->i_valid = le64_to_cpu(attr->nres.valid_size); 249 inode->i_size = le64_to_cpu(attr->nres.data_size); 250 if (!attr->nres.alloc_size) 251 goto next_attr; 252 253 run = ino == MFT_REC_BITMAP ? &sbi->used.bitmap.run 254 : &ni->file.run; 255 break; 256 257 case ATTR_ROOT: 258 if (attr->non_res) 259 goto out; 260 261 root = Add2Ptr(attr, roff); 262 is_root = true; 263 264 if (attr->name_len != ARRAY_SIZE(I30_NAME) || 265 memcmp(attr_name(attr), I30_NAME, sizeof(I30_NAME))) 266 goto next_attr; 267 268 if (root->type != ATTR_NAME || 269 root->rule != NTFS_COLLATION_TYPE_FILENAME) 270 goto out; 271 272 if (!is_dir) 273 goto next_attr; 274 275 ni->ni_flags |= NI_FLAG_DIR; 276 277 err = indx_init(&ni->dir, sbi, attr, INDEX_MUTEX_I30); 278 if (err) 279 goto out; 280 281 mode = sb->s_root 282 ? (S_IFDIR | (0777 & sbi->options->fs_dmask_inv)) 283 : (S_IFDIR | 0777); 284 goto next_attr; 285 286 case ATTR_ALLOC: 287 if (!is_root || attr->name_len != ARRAY_SIZE(I30_NAME) || 288 memcmp(attr_name(attr), I30_NAME, sizeof(I30_NAME))) 289 goto next_attr; 290 291 inode->i_size = le64_to_cpu(attr->nres.data_size); 292 ni->i_valid = le64_to_cpu(attr->nres.valid_size); 293 inode_set_bytes(inode, le64_to_cpu(attr->nres.alloc_size)); 294 295 run = &ni->dir.alloc_run; 296 break; 297 298 case ATTR_BITMAP: 299 if (ino == MFT_REC_MFT) { 300 if (!attr->non_res) 301 goto out; 302 #ifndef CONFIG_NTFS3_64BIT_CLUSTER 303 /* 0x20000000 = 2^32 / 8 */ 304 if (le64_to_cpu(attr->nres.alloc_size) >= 0x20000000) 305 goto out; 306 #endif 307 run = &sbi->mft.bitmap.run; 308 break; 309 } else if (is_dir && attr->name_len == ARRAY_SIZE(I30_NAME) && 310 !memcmp(attr_name(attr), I30_NAME, 311 sizeof(I30_NAME)) && 312 attr->non_res) { 313 run = &ni->dir.bitmap_run; 314 break; 315 } 316 goto next_attr; 317 318 case ATTR_REPARSE: 319 if (attr->name_len) 320 goto next_attr; 321 322 rp_fa = ni_parse_reparse(ni, attr, &rp); 323 switch (rp_fa) { 324 case REPARSE_LINK: 325 /* 326 * Normal symlink. 327 * Assume one unicode symbol == one utf8. 328 */ 329 inode->i_size = le16_to_cpu(rp.SymbolicLinkReparseBuffer 330 .PrintNameLength) / 331 sizeof(u16); 332 333 ni->i_valid = inode->i_size; 334 335 /* Clear directory bit. */ 336 if (ni->ni_flags & NI_FLAG_DIR) { 337 indx_clear(&ni->dir); 338 memset(&ni->dir, 0, sizeof(ni->dir)); 339 ni->ni_flags &= ~NI_FLAG_DIR; 340 } else { 341 run_close(&ni->file.run); 342 } 343 mode = S_IFLNK | 0777; 344 is_dir = false; 345 if (attr->non_res) { 346 run = &ni->file.run; 347 goto attr_unpack_run; // Double break. 348 } 349 break; 350 351 case REPARSE_COMPRESSED: 352 break; 353 354 case REPARSE_DEDUPLICATED: 355 break; 356 } 357 goto next_attr; 358 359 case ATTR_EA_INFO: 360 if (!attr->name_len && 361 resident_data_ex(attr, sizeof(struct EA_INFO))) { 362 ni->ni_flags |= NI_FLAG_EA; 363 /* 364 * ntfs_get_wsl_perm updates inode->i_uid, inode->i_gid, inode->i_mode 365 */ 366 inode->i_mode = mode; 367 ntfs_get_wsl_perm(inode); 368 mode = inode->i_mode; 369 } 370 goto next_attr; 371 372 default: 373 goto next_attr; 374 } 375 376 attr_unpack_run: 377 roff = le16_to_cpu(attr->nres.run_off); 378 379 if (roff > asize) { 380 err = -EINVAL; 381 goto out; 382 } 383 384 t64 = le64_to_cpu(attr->nres.svcn); 385 386 err = run_unpack_ex(run, sbi, ino, t64, le64_to_cpu(attr->nres.evcn), 387 t64, Add2Ptr(attr, roff), asize - roff); 388 if (err < 0) 389 goto out; 390 err = 0; 391 goto next_attr; 392 393 end_enum: 394 395 if (!std5) 396 goto out; 397 398 if (!is_match && name) { 399 /* Reuse rec as buffer for ascii name. */ 400 err = -ENOENT; 401 goto out; 402 } 403 404 if (std5->fa & FILE_ATTRIBUTE_READONLY) 405 mode &= ~0222; 406 407 if (!names) { 408 err = -EINVAL; 409 goto out; 410 } 411 412 if (names != le16_to_cpu(rec->hard_links)) { 413 /* Correct minor error on the fly. Do not mark inode as dirty. */ 414 rec->hard_links = cpu_to_le16(names); 415 ni->mi.dirty = true; 416 } 417 418 set_nlink(inode, names); 419 420 if (S_ISDIR(mode)) { 421 ni->std_fa |= FILE_ATTRIBUTE_DIRECTORY; 422 423 /* 424 * Dot and dot-dot should be included in count but was not 425 * included in enumeration. 426 * Usually a hard links to directories are disabled. 427 */ 428 inode->i_op = &ntfs_dir_inode_operations; 429 inode->i_fop = &ntfs_dir_operations; 430 ni->i_valid = 0; 431 } else if (S_ISLNK(mode)) { 432 ni->std_fa &= ~FILE_ATTRIBUTE_DIRECTORY; 433 inode->i_op = &ntfs_link_inode_operations; 434 inode->i_fop = NULL; 435 inode_nohighmem(inode); 436 } else if (S_ISREG(mode)) { 437 ni->std_fa &= ~FILE_ATTRIBUTE_DIRECTORY; 438 inode->i_op = &ntfs_file_inode_operations; 439 inode->i_fop = &ntfs_file_operations; 440 inode->i_mapping->a_ops = 441 is_compressed(ni) ? &ntfs_aops_cmpr : &ntfs_aops; 442 if (ino != MFT_REC_MFT) 443 init_rwsem(&ni->file.run_lock); 444 } else if (S_ISCHR(mode) || S_ISBLK(mode) || S_ISFIFO(mode) || 445 S_ISSOCK(mode)) { 446 inode->i_op = &ntfs_special_inode_operations; 447 init_special_inode(inode, mode, inode->i_rdev); 448 } else if (fname && fname->home.low == cpu_to_le32(MFT_REC_EXTEND) && 449 fname->home.seq == cpu_to_le16(MFT_REC_EXTEND)) { 450 /* Records in $Extend are not a files or general directories. */ 451 inode->i_op = &ntfs_file_inode_operations; 452 } else { 453 err = -EINVAL; 454 goto out; 455 } 456 457 if ((sbi->options->sys_immutable && 458 (std5->fa & FILE_ATTRIBUTE_SYSTEM)) && 459 !S_ISFIFO(mode) && !S_ISSOCK(mode) && !S_ISLNK(mode)) { 460 inode->i_flags |= S_IMMUTABLE; 461 } else { 462 inode->i_flags &= ~S_IMMUTABLE; 463 } 464 465 inode->i_mode = mode; 466 if (!(ni->ni_flags & NI_FLAG_EA)) { 467 /* If no xattr then no security (stored in xattr). */ 468 inode->i_flags |= S_NOSEC; 469 } 470 471 if (ino == MFT_REC_MFT && !sb->s_root) 472 sbi->mft.ni = NULL; 473 474 unlock_new_inode(inode); 475 476 return inode; 477 478 out: 479 if (ino == MFT_REC_MFT && !sb->s_root) 480 sbi->mft.ni = NULL; 481 482 iget_failed(inode); 483 return ERR_PTR(err); 484 } 485 486 /* 487 * ntfs_test_inode 488 * 489 * Return: 1 if match. 490 */ 491 static int ntfs_test_inode(struct inode *inode, void *data) 492 { 493 struct MFT_REF *ref = data; 494 495 return ino_get(ref) == inode->i_ino; 496 } 497 498 static int ntfs_set_inode(struct inode *inode, void *data) 499 { 500 const struct MFT_REF *ref = data; 501 502 inode->i_ino = ino_get(ref); 503 return 0; 504 } 505 506 struct inode *ntfs_iget5(struct super_block *sb, const struct MFT_REF *ref, 507 const struct cpu_str *name) 508 { 509 struct inode *inode; 510 511 inode = iget5_locked(sb, ino_get(ref), ntfs_test_inode, ntfs_set_inode, 512 (void *)ref); 513 if (unlikely(!inode)) 514 return ERR_PTR(-ENOMEM); 515 516 /* If this is a freshly allocated inode, need to read it now. */ 517 if (inode->i_state & I_NEW) 518 inode = ntfs_read_mft(inode, name, ref); 519 else if (ref->seq != ntfs_i(inode)->mi.mrec->seq) { 520 /* Inode overlaps? */ 521 _ntfs_bad_inode(inode); 522 } 523 524 if (IS_ERR(inode) && name) 525 ntfs_set_state(sb->s_fs_info, NTFS_DIRTY_ERROR); 526 527 return inode; 528 } 529 530 enum get_block_ctx { 531 GET_BLOCK_GENERAL = 0, 532 GET_BLOCK_WRITE_BEGIN = 1, 533 GET_BLOCK_DIRECT_IO_R = 2, 534 GET_BLOCK_DIRECT_IO_W = 3, 535 GET_BLOCK_BMAP = 4, 536 }; 537 538 static noinline int ntfs_get_block_vbo(struct inode *inode, u64 vbo, 539 struct buffer_head *bh, int create, 540 enum get_block_ctx ctx) 541 { 542 struct super_block *sb = inode->i_sb; 543 struct ntfs_sb_info *sbi = sb->s_fs_info; 544 struct ntfs_inode *ni = ntfs_i(inode); 545 struct page *page = bh->b_page; 546 u8 cluster_bits = sbi->cluster_bits; 547 u32 block_size = sb->s_blocksize; 548 u64 bytes, lbo, valid; 549 u32 off; 550 int err; 551 CLST vcn, lcn, len; 552 bool new; 553 554 /* Clear previous state. */ 555 clear_buffer_new(bh); 556 clear_buffer_uptodate(bh); 557 558 if (is_resident(ni)) { 559 ni_lock(ni); 560 err = attr_data_read_resident(ni, page); 561 ni_unlock(ni); 562 563 if (!err) 564 set_buffer_uptodate(bh); 565 bh->b_size = block_size; 566 return err; 567 } 568 569 vcn = vbo >> cluster_bits; 570 off = vbo & sbi->cluster_mask; 571 new = false; 572 573 err = attr_data_get_block(ni, vcn, 1, &lcn, &len, create ? &new : NULL, 574 create && sbi->cluster_size > PAGE_SIZE); 575 if (err) 576 goto out; 577 578 if (!len) 579 return 0; 580 581 bytes = ((u64)len << cluster_bits) - off; 582 583 if (lcn == SPARSE_LCN) { 584 if (!create) { 585 if (bh->b_size > bytes) 586 bh->b_size = bytes; 587 return 0; 588 } 589 WARN_ON(1); 590 } 591 592 if (new) 593 set_buffer_new(bh); 594 595 lbo = ((u64)lcn << cluster_bits) + off; 596 597 set_buffer_mapped(bh); 598 bh->b_bdev = sb->s_bdev; 599 bh->b_blocknr = lbo >> sb->s_blocksize_bits; 600 601 valid = ni->i_valid; 602 603 if (ctx == GET_BLOCK_DIRECT_IO_W) { 604 /* ntfs_direct_IO will update ni->i_valid. */ 605 if (vbo >= valid) 606 set_buffer_new(bh); 607 } else if (create) { 608 /* Normal write. */ 609 if (bytes > bh->b_size) 610 bytes = bh->b_size; 611 612 if (vbo >= valid) 613 set_buffer_new(bh); 614 615 if (vbo + bytes > valid) { 616 ni->i_valid = vbo + bytes; 617 mark_inode_dirty(inode); 618 } 619 } else if (vbo >= valid) { 620 /* Read out of valid data. */ 621 clear_buffer_mapped(bh); 622 } else if (vbo + bytes <= valid) { 623 /* Normal read. */ 624 } else if (vbo + block_size <= valid) { 625 /* Normal short read. */ 626 bytes = block_size; 627 } else { 628 /* 629 * Read across valid size: vbo < valid && valid < vbo + block_size 630 */ 631 bytes = block_size; 632 633 if (page) { 634 u32 voff = valid - vbo; 635 636 bh->b_size = block_size; 637 off = vbo & (PAGE_SIZE - 1); 638 set_bh_page(bh, page, off); 639 err = bh_read(bh, 0); 640 if (err < 0) 641 goto out; 642 zero_user_segment(page, off + voff, off + block_size); 643 } 644 } 645 646 if (bh->b_size > bytes) 647 bh->b_size = bytes; 648 649 #ifndef __LP64__ 650 if (ctx == GET_BLOCK_DIRECT_IO_W || ctx == GET_BLOCK_DIRECT_IO_R) { 651 static_assert(sizeof(size_t) < sizeof(loff_t)); 652 if (bytes > 0x40000000u) 653 bh->b_size = 0x40000000u; 654 } 655 #endif 656 657 return 0; 658 659 out: 660 return err; 661 } 662 663 int ntfs_get_block(struct inode *inode, sector_t vbn, 664 struct buffer_head *bh_result, int create) 665 { 666 return ntfs_get_block_vbo(inode, (u64)vbn << inode->i_blkbits, 667 bh_result, create, GET_BLOCK_GENERAL); 668 } 669 670 static int ntfs_get_block_bmap(struct inode *inode, sector_t vsn, 671 struct buffer_head *bh_result, int create) 672 { 673 return ntfs_get_block_vbo(inode, 674 (u64)vsn << inode->i_sb->s_blocksize_bits, 675 bh_result, create, GET_BLOCK_BMAP); 676 } 677 678 static sector_t ntfs_bmap(struct address_space *mapping, sector_t block) 679 { 680 return generic_block_bmap(mapping, block, ntfs_get_block_bmap); 681 } 682 683 static int ntfs_read_folio(struct file *file, struct folio *folio) 684 { 685 struct page *page = &folio->page; 686 int err; 687 struct address_space *mapping = page->mapping; 688 struct inode *inode = mapping->host; 689 struct ntfs_inode *ni = ntfs_i(inode); 690 691 if (is_resident(ni)) { 692 ni_lock(ni); 693 err = attr_data_read_resident(ni, page); 694 ni_unlock(ni); 695 if (err != E_NTFS_NONRESIDENT) { 696 unlock_page(page); 697 return err; 698 } 699 } 700 701 if (is_compressed(ni)) { 702 ni_lock(ni); 703 err = ni_readpage_cmpr(ni, page); 704 ni_unlock(ni); 705 return err; 706 } 707 708 /* Normal + sparse files. */ 709 return mpage_read_folio(folio, ntfs_get_block); 710 } 711 712 static void ntfs_readahead(struct readahead_control *rac) 713 { 714 struct address_space *mapping = rac->mapping; 715 struct inode *inode = mapping->host; 716 struct ntfs_inode *ni = ntfs_i(inode); 717 u64 valid; 718 loff_t pos; 719 720 if (is_resident(ni)) { 721 /* No readahead for resident. */ 722 return; 723 } 724 725 if (is_compressed(ni)) { 726 /* No readahead for compressed. */ 727 return; 728 } 729 730 valid = ni->i_valid; 731 pos = readahead_pos(rac); 732 733 if (valid < i_size_read(inode) && pos <= valid && 734 valid < pos + readahead_length(rac)) { 735 /* Range cross 'valid'. Read it page by page. */ 736 return; 737 } 738 739 mpage_readahead(rac, ntfs_get_block); 740 } 741 742 static int ntfs_get_block_direct_IO_R(struct inode *inode, sector_t iblock, 743 struct buffer_head *bh_result, int create) 744 { 745 return ntfs_get_block_vbo(inode, (u64)iblock << inode->i_blkbits, 746 bh_result, create, GET_BLOCK_DIRECT_IO_R); 747 } 748 749 static int ntfs_get_block_direct_IO_W(struct inode *inode, sector_t iblock, 750 struct buffer_head *bh_result, int create) 751 { 752 return ntfs_get_block_vbo(inode, (u64)iblock << inode->i_blkbits, 753 bh_result, create, GET_BLOCK_DIRECT_IO_W); 754 } 755 756 static ssize_t ntfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) 757 { 758 struct file *file = iocb->ki_filp; 759 struct address_space *mapping = file->f_mapping; 760 struct inode *inode = mapping->host; 761 struct ntfs_inode *ni = ntfs_i(inode); 762 loff_t vbo = iocb->ki_pos; 763 loff_t end; 764 int wr = iov_iter_rw(iter) & WRITE; 765 size_t iter_count = iov_iter_count(iter); 766 loff_t valid; 767 ssize_t ret; 768 769 if (is_resident(ni)) { 770 /* Switch to buffered write. */ 771 ret = 0; 772 goto out; 773 } 774 775 ret = blockdev_direct_IO(iocb, inode, iter, 776 wr ? ntfs_get_block_direct_IO_W 777 : ntfs_get_block_direct_IO_R); 778 779 if (ret > 0) 780 end = vbo + ret; 781 else if (wr && ret == -EIOCBQUEUED) 782 end = vbo + iter_count; 783 else 784 goto out; 785 786 valid = ni->i_valid; 787 if (wr) { 788 if (end > valid && !S_ISBLK(inode->i_mode)) { 789 ni->i_valid = end; 790 mark_inode_dirty(inode); 791 } 792 } else if (vbo < valid && valid < end) { 793 /* Fix page. */ 794 iov_iter_revert(iter, end - valid); 795 iov_iter_zero(end - valid, iter); 796 } 797 798 out: 799 return ret; 800 } 801 802 int ntfs_set_size(struct inode *inode, u64 new_size) 803 { 804 struct super_block *sb = inode->i_sb; 805 struct ntfs_sb_info *sbi = sb->s_fs_info; 806 struct ntfs_inode *ni = ntfs_i(inode); 807 int err; 808 809 /* Check for maximum file size. */ 810 if (is_sparsed(ni) || is_compressed(ni)) { 811 if (new_size > sbi->maxbytes_sparse) { 812 err = -EFBIG; 813 goto out; 814 } 815 } else if (new_size > sbi->maxbytes) { 816 err = -EFBIG; 817 goto out; 818 } 819 820 ni_lock(ni); 821 down_write(&ni->file.run_lock); 822 823 err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, new_size, 824 &ni->i_valid, true, NULL); 825 826 up_write(&ni->file.run_lock); 827 ni_unlock(ni); 828 829 mark_inode_dirty(inode); 830 831 out: 832 return err; 833 } 834 835 static int ntfs_writepage(struct page *page, struct writeback_control *wbc) 836 { 837 struct address_space *mapping = page->mapping; 838 struct inode *inode = mapping->host; 839 struct ntfs_inode *ni = ntfs_i(inode); 840 int err; 841 842 if (is_resident(ni)) { 843 ni_lock(ni); 844 err = attr_data_write_resident(ni, page); 845 ni_unlock(ni); 846 if (err != E_NTFS_NONRESIDENT) { 847 unlock_page(page); 848 return err; 849 } 850 } 851 852 return block_write_full_page(page, ntfs_get_block, wbc); 853 } 854 855 static int ntfs_writepages(struct address_space *mapping, 856 struct writeback_control *wbc) 857 { 858 /* Redirect call to 'ntfs_writepage' for resident files. */ 859 if (is_resident(ntfs_i(mapping->host))) 860 return generic_writepages(mapping, wbc); 861 return mpage_writepages(mapping, wbc, ntfs_get_block); 862 } 863 864 static int ntfs_get_block_write_begin(struct inode *inode, sector_t vbn, 865 struct buffer_head *bh_result, int create) 866 { 867 return ntfs_get_block_vbo(inode, (u64)vbn << inode->i_blkbits, 868 bh_result, create, GET_BLOCK_WRITE_BEGIN); 869 } 870 871 int ntfs_write_begin(struct file *file, struct address_space *mapping, 872 loff_t pos, u32 len, struct page **pagep, void **fsdata) 873 { 874 int err; 875 struct inode *inode = mapping->host; 876 struct ntfs_inode *ni = ntfs_i(inode); 877 878 *pagep = NULL; 879 if (is_resident(ni)) { 880 struct page *page = grab_cache_page_write_begin( 881 mapping, pos >> PAGE_SHIFT); 882 883 if (!page) { 884 err = -ENOMEM; 885 goto out; 886 } 887 888 ni_lock(ni); 889 err = attr_data_read_resident(ni, page); 890 ni_unlock(ni); 891 892 if (!err) { 893 *pagep = page; 894 goto out; 895 } 896 unlock_page(page); 897 put_page(page); 898 899 if (err != E_NTFS_NONRESIDENT) 900 goto out; 901 } 902 903 err = block_write_begin(mapping, pos, len, pagep, 904 ntfs_get_block_write_begin); 905 906 out: 907 return err; 908 } 909 910 /* 911 * ntfs_write_end - Address_space_operations::write_end. 912 */ 913 int ntfs_write_end(struct file *file, struct address_space *mapping, 914 loff_t pos, u32 len, u32 copied, struct page *page, 915 void *fsdata) 916 { 917 struct inode *inode = mapping->host; 918 struct ntfs_inode *ni = ntfs_i(inode); 919 u64 valid = ni->i_valid; 920 bool dirty = false; 921 int err; 922 923 if (is_resident(ni)) { 924 ni_lock(ni); 925 err = attr_data_write_resident(ni, page); 926 ni_unlock(ni); 927 if (!err) { 928 dirty = true; 929 /* Clear any buffers in page. */ 930 if (page_has_buffers(page)) { 931 struct buffer_head *head, *bh; 932 933 bh = head = page_buffers(page); 934 do { 935 clear_buffer_dirty(bh); 936 clear_buffer_mapped(bh); 937 set_buffer_uptodate(bh); 938 } while (head != (bh = bh->b_this_page)); 939 } 940 SetPageUptodate(page); 941 err = copied; 942 } 943 unlock_page(page); 944 put_page(page); 945 } else { 946 err = generic_write_end(file, mapping, pos, len, copied, page, 947 fsdata); 948 } 949 950 if (err >= 0) { 951 if (!(ni->std_fa & FILE_ATTRIBUTE_ARCHIVE)) { 952 inode->i_ctime = inode->i_mtime = current_time(inode); 953 ni->std_fa |= FILE_ATTRIBUTE_ARCHIVE; 954 dirty = true; 955 } 956 957 if (valid != ni->i_valid) { 958 /* ni->i_valid is changed in ntfs_get_block_vbo. */ 959 dirty = true; 960 } 961 962 if (pos + err > inode->i_size) { 963 inode->i_size = pos + err; 964 dirty = true; 965 } 966 967 if (dirty) 968 mark_inode_dirty(inode); 969 } 970 971 return err; 972 } 973 974 int reset_log_file(struct inode *inode) 975 { 976 int err; 977 loff_t pos = 0; 978 u32 log_size = inode->i_size; 979 struct address_space *mapping = inode->i_mapping; 980 981 for (;;) { 982 u32 len; 983 void *kaddr; 984 struct page *page; 985 986 len = pos + PAGE_SIZE > log_size ? (log_size - pos) : PAGE_SIZE; 987 988 err = block_write_begin(mapping, pos, len, &page, 989 ntfs_get_block_write_begin); 990 if (err) 991 goto out; 992 993 kaddr = kmap_atomic(page); 994 memset(kaddr, -1, len); 995 kunmap_atomic(kaddr); 996 flush_dcache_page(page); 997 998 err = block_write_end(NULL, mapping, pos, len, len, page, NULL); 999 if (err < 0) 1000 goto out; 1001 pos += len; 1002 1003 if (pos >= log_size) 1004 break; 1005 balance_dirty_pages_ratelimited(mapping); 1006 } 1007 out: 1008 mark_inode_dirty_sync(inode); 1009 1010 return err; 1011 } 1012 1013 int ntfs3_write_inode(struct inode *inode, struct writeback_control *wbc) 1014 { 1015 return _ni_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL); 1016 } 1017 1018 int ntfs_sync_inode(struct inode *inode) 1019 { 1020 return _ni_write_inode(inode, 1); 1021 } 1022 1023 /* 1024 * writeback_inode - Helper function for ntfs_flush_inodes(). 1025 * 1026 * This writes both the inode and the file data blocks, waiting 1027 * for in flight data blocks before the start of the call. It 1028 * does not wait for any io started during the call. 1029 */ 1030 static int writeback_inode(struct inode *inode) 1031 { 1032 int ret = sync_inode_metadata(inode, 0); 1033 1034 if (!ret) 1035 ret = filemap_fdatawrite(inode->i_mapping); 1036 return ret; 1037 } 1038 1039 /* 1040 * ntfs_flush_inodes 1041 * 1042 * Write data and metadata corresponding to i1 and i2. The io is 1043 * started but we do not wait for any of it to finish. 1044 * 1045 * filemap_flush() is used for the block device, so if there is a dirty 1046 * page for a block already in flight, we will not wait and start the 1047 * io over again. 1048 */ 1049 int ntfs_flush_inodes(struct super_block *sb, struct inode *i1, 1050 struct inode *i2) 1051 { 1052 int ret = 0; 1053 1054 if (i1) 1055 ret = writeback_inode(i1); 1056 if (!ret && i2) 1057 ret = writeback_inode(i2); 1058 if (!ret) 1059 ret = sync_blockdev_nowait(sb->s_bdev); 1060 return ret; 1061 } 1062 1063 int inode_write_data(struct inode *inode, const void *data, size_t bytes) 1064 { 1065 pgoff_t idx; 1066 1067 /* Write non resident data. */ 1068 for (idx = 0; bytes; idx++) { 1069 size_t op = bytes > PAGE_SIZE ? PAGE_SIZE : bytes; 1070 struct page *page = ntfs_map_page(inode->i_mapping, idx); 1071 1072 if (IS_ERR(page)) 1073 return PTR_ERR(page); 1074 1075 lock_page(page); 1076 WARN_ON(!PageUptodate(page)); 1077 ClearPageUptodate(page); 1078 1079 memcpy(page_address(page), data, op); 1080 1081 flush_dcache_page(page); 1082 SetPageUptodate(page); 1083 unlock_page(page); 1084 1085 ntfs_unmap_page(page); 1086 1087 bytes -= op; 1088 data = Add2Ptr(data, PAGE_SIZE); 1089 } 1090 return 0; 1091 } 1092 1093 /* 1094 * ntfs_reparse_bytes 1095 * 1096 * Number of bytes for REPARSE_DATA_BUFFER(IO_REPARSE_TAG_SYMLINK) 1097 * for unicode string of @uni_len length. 1098 */ 1099 static inline u32 ntfs_reparse_bytes(u32 uni_len) 1100 { 1101 /* Header + unicode string + decorated unicode string. */ 1102 return sizeof(short) * (2 * uni_len + 4) + 1103 offsetof(struct REPARSE_DATA_BUFFER, 1104 SymbolicLinkReparseBuffer.PathBuffer); 1105 } 1106 1107 static struct REPARSE_DATA_BUFFER * 1108 ntfs_create_reparse_buffer(struct ntfs_sb_info *sbi, const char *symname, 1109 u32 size, u16 *nsize) 1110 { 1111 int i, err; 1112 struct REPARSE_DATA_BUFFER *rp; 1113 __le16 *rp_name; 1114 typeof(rp->SymbolicLinkReparseBuffer) *rs; 1115 1116 rp = kzalloc(ntfs_reparse_bytes(2 * size + 2), GFP_NOFS); 1117 if (!rp) 1118 return ERR_PTR(-ENOMEM); 1119 1120 rs = &rp->SymbolicLinkReparseBuffer; 1121 rp_name = rs->PathBuffer; 1122 1123 /* Convert link name to UTF-16. */ 1124 err = ntfs_nls_to_utf16(sbi, symname, size, 1125 (struct cpu_str *)(rp_name - 1), 2 * size, 1126 UTF16_LITTLE_ENDIAN); 1127 if (err < 0) 1128 goto out; 1129 1130 /* err = the length of unicode name of symlink. */ 1131 *nsize = ntfs_reparse_bytes(err); 1132 1133 if (*nsize > sbi->reparse.max_size) { 1134 err = -EFBIG; 1135 goto out; 1136 } 1137 1138 /* Translate Linux '/' into Windows '\'. */ 1139 for (i = 0; i < err; i++) { 1140 if (rp_name[i] == cpu_to_le16('/')) 1141 rp_name[i] = cpu_to_le16('\\'); 1142 } 1143 1144 rp->ReparseTag = IO_REPARSE_TAG_SYMLINK; 1145 rp->ReparseDataLength = 1146 cpu_to_le16(*nsize - offsetof(struct REPARSE_DATA_BUFFER, 1147 SymbolicLinkReparseBuffer)); 1148 1149 /* PrintName + SubstituteName. */ 1150 rs->SubstituteNameOffset = cpu_to_le16(sizeof(short) * err); 1151 rs->SubstituteNameLength = cpu_to_le16(sizeof(short) * err + 8); 1152 rs->PrintNameLength = rs->SubstituteNameOffset; 1153 1154 /* 1155 * TODO: Use relative path if possible to allow Windows to 1156 * parse this path. 1157 * 0-absolute path 1- relative path (SYMLINK_FLAG_RELATIVE). 1158 */ 1159 rs->Flags = 0; 1160 1161 memmove(rp_name + err + 4, rp_name, sizeof(short) * err); 1162 1163 /* Decorate SubstituteName. */ 1164 rp_name += err; 1165 rp_name[0] = cpu_to_le16('\\'); 1166 rp_name[1] = cpu_to_le16('?'); 1167 rp_name[2] = cpu_to_le16('?'); 1168 rp_name[3] = cpu_to_le16('\\'); 1169 1170 return rp; 1171 out: 1172 kfree(rp); 1173 return ERR_PTR(err); 1174 } 1175 1176 /* 1177 * ntfs_create_inode 1178 * 1179 * Helper function for: 1180 * - ntfs_create 1181 * - ntfs_mknod 1182 * - ntfs_symlink 1183 * - ntfs_mkdir 1184 * - ntfs_atomic_open 1185 * 1186 * NOTE: if fnd != NULL (ntfs_atomic_open) then @dir is locked 1187 */ 1188 struct inode *ntfs_create_inode(struct mnt_idmap *idmap, 1189 struct inode *dir, struct dentry *dentry, 1190 const struct cpu_str *uni, umode_t mode, 1191 dev_t dev, const char *symname, u32 size, 1192 struct ntfs_fnd *fnd) 1193 { 1194 int err; 1195 struct super_block *sb = dir->i_sb; 1196 struct ntfs_sb_info *sbi = sb->s_fs_info; 1197 const struct qstr *name = &dentry->d_name; 1198 CLST ino = 0; 1199 struct ntfs_inode *dir_ni = ntfs_i(dir); 1200 struct ntfs_inode *ni = NULL; 1201 struct inode *inode = NULL; 1202 struct ATTRIB *attr; 1203 struct ATTR_STD_INFO5 *std5; 1204 struct ATTR_FILE_NAME *fname; 1205 struct MFT_REC *rec; 1206 u32 asize, dsize, sd_size; 1207 enum FILE_ATTRIBUTE fa; 1208 __le32 security_id = SECURITY_ID_INVALID; 1209 CLST vcn; 1210 const void *sd; 1211 u16 t16, nsize = 0, aid = 0; 1212 struct INDEX_ROOT *root, *dir_root; 1213 struct NTFS_DE *e, *new_de = NULL; 1214 struct REPARSE_DATA_BUFFER *rp = NULL; 1215 bool rp_inserted = false; 1216 1217 if (!fnd) 1218 ni_lock_dir(dir_ni); 1219 1220 dir_root = indx_get_root(&dir_ni->dir, dir_ni, NULL, NULL); 1221 if (!dir_root) { 1222 err = -EINVAL; 1223 goto out1; 1224 } 1225 1226 if (S_ISDIR(mode)) { 1227 /* Use parent's directory attributes. */ 1228 fa = dir_ni->std_fa | FILE_ATTRIBUTE_DIRECTORY | 1229 FILE_ATTRIBUTE_ARCHIVE; 1230 /* 1231 * By default child directory inherits parent attributes. 1232 * Root directory is hidden + system. 1233 * Make an exception for children in root. 1234 */ 1235 if (dir->i_ino == MFT_REC_ROOT) 1236 fa &= ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM); 1237 } else if (S_ISLNK(mode)) { 1238 /* It is good idea that link should be the same type (file/dir) as target */ 1239 fa = FILE_ATTRIBUTE_REPARSE_POINT; 1240 1241 /* 1242 * Linux: there are dir/file/symlink and so on. 1243 * NTFS: symlinks are "dir + reparse" or "file + reparse" 1244 * It is good idea to create: 1245 * dir + reparse if 'symname' points to directory 1246 * or 1247 * file + reparse if 'symname' points to file 1248 * Unfortunately kern_path hangs if symname contains 'dir'. 1249 */ 1250 1251 /* 1252 * struct path path; 1253 * 1254 * if (!kern_path(symname, LOOKUP_FOLLOW, &path)){ 1255 * struct inode *target = d_inode(path.dentry); 1256 * 1257 * if (S_ISDIR(target->i_mode)) 1258 * fa |= FILE_ATTRIBUTE_DIRECTORY; 1259 * // if ( target->i_sb == sb ){ 1260 * // use relative path? 1261 * // } 1262 * path_put(&path); 1263 * } 1264 */ 1265 } else if (S_ISREG(mode)) { 1266 if (sbi->options->sparse) { 1267 /* Sparsed regular file, cause option 'sparse'. */ 1268 fa = FILE_ATTRIBUTE_SPARSE_FILE | 1269 FILE_ATTRIBUTE_ARCHIVE; 1270 } else if (dir_ni->std_fa & FILE_ATTRIBUTE_COMPRESSED) { 1271 /* Compressed regular file, if parent is compressed. */ 1272 fa = FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ARCHIVE; 1273 } else { 1274 /* Regular file, default attributes. */ 1275 fa = FILE_ATTRIBUTE_ARCHIVE; 1276 } 1277 } else { 1278 fa = FILE_ATTRIBUTE_ARCHIVE; 1279 } 1280 1281 /* If option "hide_dot_files" then set hidden attribute for dot files. */ 1282 if (sbi->options->hide_dot_files && name->name[0] == '.') 1283 fa |= FILE_ATTRIBUTE_HIDDEN; 1284 1285 if (!(mode & 0222)) 1286 fa |= FILE_ATTRIBUTE_READONLY; 1287 1288 /* Allocate PATH_MAX bytes. */ 1289 new_de = __getname(); 1290 if (!new_de) { 1291 err = -ENOMEM; 1292 goto out1; 1293 } 1294 1295 /* Mark rw ntfs as dirty. it will be cleared at umount. */ 1296 ntfs_set_state(sbi, NTFS_DIRTY_DIRTY); 1297 1298 /* Step 1: allocate and fill new mft record. */ 1299 err = ntfs_look_free_mft(sbi, &ino, false, NULL, NULL); 1300 if (err) 1301 goto out2; 1302 1303 ni = ntfs_new_inode(sbi, ino, fa & FILE_ATTRIBUTE_DIRECTORY); 1304 if (IS_ERR(ni)) { 1305 err = PTR_ERR(ni); 1306 ni = NULL; 1307 goto out3; 1308 } 1309 inode = &ni->vfs_inode; 1310 inode_init_owner(idmap, inode, dir, mode); 1311 mode = inode->i_mode; 1312 1313 inode->i_atime = inode->i_mtime = inode->i_ctime = ni->i_crtime = 1314 current_time(inode); 1315 1316 rec = ni->mi.mrec; 1317 rec->hard_links = cpu_to_le16(1); 1318 attr = Add2Ptr(rec, le16_to_cpu(rec->attr_off)); 1319 1320 /* Get default security id. */ 1321 sd = s_default_security; 1322 sd_size = sizeof(s_default_security); 1323 1324 if (is_ntfs3(sbi)) { 1325 security_id = dir_ni->std_security_id; 1326 if (le32_to_cpu(security_id) < SECURITY_ID_FIRST) { 1327 security_id = sbi->security.def_security_id; 1328 1329 if (security_id == SECURITY_ID_INVALID && 1330 !ntfs_insert_security(sbi, sd, sd_size, 1331 &security_id, NULL)) 1332 sbi->security.def_security_id = security_id; 1333 } 1334 } 1335 1336 /* Insert standard info. */ 1337 std5 = Add2Ptr(attr, SIZEOF_RESIDENT); 1338 1339 if (security_id == SECURITY_ID_INVALID) { 1340 dsize = sizeof(struct ATTR_STD_INFO); 1341 } else { 1342 dsize = sizeof(struct ATTR_STD_INFO5); 1343 std5->security_id = security_id; 1344 ni->std_security_id = security_id; 1345 } 1346 asize = SIZEOF_RESIDENT + dsize; 1347 1348 attr->type = ATTR_STD; 1349 attr->size = cpu_to_le32(asize); 1350 attr->id = cpu_to_le16(aid++); 1351 attr->res.data_off = SIZEOF_RESIDENT_LE; 1352 attr->res.data_size = cpu_to_le32(dsize); 1353 1354 std5->cr_time = std5->m_time = std5->c_time = std5->a_time = 1355 kernel2nt(&inode->i_atime); 1356 1357 ni->std_fa = fa; 1358 std5->fa = fa; 1359 1360 attr = Add2Ptr(attr, asize); 1361 1362 /* Insert file name. */ 1363 err = fill_name_de(sbi, new_de, name, uni); 1364 if (err) 1365 goto out4; 1366 1367 mi_get_ref(&ni->mi, &new_de->ref); 1368 1369 fname = (struct ATTR_FILE_NAME *)(new_de + 1); 1370 1371 if (sbi->options->windows_names && 1372 !valid_windows_name(sbi, (struct le_str *)&fname->name_len)) { 1373 err = -EINVAL; 1374 goto out4; 1375 } 1376 1377 mi_get_ref(&dir_ni->mi, &fname->home); 1378 fname->dup.cr_time = fname->dup.m_time = fname->dup.c_time = 1379 fname->dup.a_time = std5->cr_time; 1380 fname->dup.alloc_size = fname->dup.data_size = 0; 1381 fname->dup.fa = std5->fa; 1382 fname->dup.ea_size = fname->dup.reparse = 0; 1383 1384 dsize = le16_to_cpu(new_de->key_size); 1385 asize = ALIGN(SIZEOF_RESIDENT + dsize, 8); 1386 1387 attr->type = ATTR_NAME; 1388 attr->size = cpu_to_le32(asize); 1389 attr->res.data_off = SIZEOF_RESIDENT_LE; 1390 attr->res.flags = RESIDENT_FLAG_INDEXED; 1391 attr->id = cpu_to_le16(aid++); 1392 attr->res.data_size = cpu_to_le32(dsize); 1393 memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), fname, dsize); 1394 1395 attr = Add2Ptr(attr, asize); 1396 1397 if (security_id == SECURITY_ID_INVALID) { 1398 /* Insert security attribute. */ 1399 asize = SIZEOF_RESIDENT + ALIGN(sd_size, 8); 1400 1401 attr->type = ATTR_SECURE; 1402 attr->size = cpu_to_le32(asize); 1403 attr->id = cpu_to_le16(aid++); 1404 attr->res.data_off = SIZEOF_RESIDENT_LE; 1405 attr->res.data_size = cpu_to_le32(sd_size); 1406 memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), sd, sd_size); 1407 1408 attr = Add2Ptr(attr, asize); 1409 } 1410 1411 attr->id = cpu_to_le16(aid++); 1412 if (fa & FILE_ATTRIBUTE_DIRECTORY) { 1413 /* 1414 * Regular directory or symlink to directory. 1415 * Create root attribute. 1416 */ 1417 dsize = sizeof(struct INDEX_ROOT) + sizeof(struct NTFS_DE); 1418 asize = sizeof(I30_NAME) + SIZEOF_RESIDENT + dsize; 1419 1420 attr->type = ATTR_ROOT; 1421 attr->size = cpu_to_le32(asize); 1422 1423 attr->name_len = ARRAY_SIZE(I30_NAME); 1424 attr->name_off = SIZEOF_RESIDENT_LE; 1425 attr->res.data_off = 1426 cpu_to_le16(sizeof(I30_NAME) + SIZEOF_RESIDENT); 1427 attr->res.data_size = cpu_to_le32(dsize); 1428 memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), I30_NAME, 1429 sizeof(I30_NAME)); 1430 1431 root = Add2Ptr(attr, sizeof(I30_NAME) + SIZEOF_RESIDENT); 1432 memcpy(root, dir_root, offsetof(struct INDEX_ROOT, ihdr)); 1433 root->ihdr.de_off = 1434 cpu_to_le32(sizeof(struct INDEX_HDR)); // 0x10 1435 root->ihdr.used = cpu_to_le32(sizeof(struct INDEX_HDR) + 1436 sizeof(struct NTFS_DE)); 1437 root->ihdr.total = root->ihdr.used; 1438 1439 e = Add2Ptr(root, sizeof(struct INDEX_ROOT)); 1440 e->size = cpu_to_le16(sizeof(struct NTFS_DE)); 1441 e->flags = NTFS_IE_LAST; 1442 } else if (S_ISLNK(mode)) { 1443 /* 1444 * Symlink to file. 1445 * Create empty resident data attribute. 1446 */ 1447 asize = SIZEOF_RESIDENT; 1448 1449 /* Insert empty ATTR_DATA */ 1450 attr->type = ATTR_DATA; 1451 attr->size = cpu_to_le32(SIZEOF_RESIDENT); 1452 attr->name_off = SIZEOF_RESIDENT_LE; 1453 attr->res.data_off = SIZEOF_RESIDENT_LE; 1454 } else if (S_ISREG(mode)) { 1455 /* 1456 * Regular file. Create empty non resident data attribute. 1457 */ 1458 attr->type = ATTR_DATA; 1459 attr->non_res = 1; 1460 attr->nres.evcn = cpu_to_le64(-1ll); 1461 if (fa & FILE_ATTRIBUTE_SPARSE_FILE) { 1462 attr->size = cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8); 1463 attr->name_off = SIZEOF_NONRESIDENT_EX_LE; 1464 attr->flags = ATTR_FLAG_SPARSED; 1465 asize = SIZEOF_NONRESIDENT_EX + 8; 1466 } else if (fa & FILE_ATTRIBUTE_COMPRESSED) { 1467 attr->size = cpu_to_le32(SIZEOF_NONRESIDENT_EX + 8); 1468 attr->name_off = SIZEOF_NONRESIDENT_EX_LE; 1469 attr->flags = ATTR_FLAG_COMPRESSED; 1470 attr->nres.c_unit = COMPRESSION_UNIT; 1471 asize = SIZEOF_NONRESIDENT_EX + 8; 1472 } else { 1473 attr->size = cpu_to_le32(SIZEOF_NONRESIDENT + 8); 1474 attr->name_off = SIZEOF_NONRESIDENT_LE; 1475 asize = SIZEOF_NONRESIDENT + 8; 1476 } 1477 attr->nres.run_off = attr->name_off; 1478 } else { 1479 /* 1480 * Node. Create empty resident data attribute. 1481 */ 1482 attr->type = ATTR_DATA; 1483 attr->size = cpu_to_le32(SIZEOF_RESIDENT); 1484 attr->name_off = SIZEOF_RESIDENT_LE; 1485 if (fa & FILE_ATTRIBUTE_SPARSE_FILE) 1486 attr->flags = ATTR_FLAG_SPARSED; 1487 else if (fa & FILE_ATTRIBUTE_COMPRESSED) 1488 attr->flags = ATTR_FLAG_COMPRESSED; 1489 attr->res.data_off = SIZEOF_RESIDENT_LE; 1490 asize = SIZEOF_RESIDENT; 1491 ni->ni_flags |= NI_FLAG_RESIDENT; 1492 } 1493 1494 if (S_ISDIR(mode)) { 1495 ni->ni_flags |= NI_FLAG_DIR; 1496 err = indx_init(&ni->dir, sbi, attr, INDEX_MUTEX_I30); 1497 if (err) 1498 goto out4; 1499 } else if (S_ISLNK(mode)) { 1500 rp = ntfs_create_reparse_buffer(sbi, symname, size, &nsize); 1501 1502 if (IS_ERR(rp)) { 1503 err = PTR_ERR(rp); 1504 rp = NULL; 1505 goto out4; 1506 } 1507 1508 /* 1509 * Insert ATTR_REPARSE. 1510 */ 1511 attr = Add2Ptr(attr, asize); 1512 attr->type = ATTR_REPARSE; 1513 attr->id = cpu_to_le16(aid++); 1514 1515 /* Resident or non resident? */ 1516 asize = ALIGN(SIZEOF_RESIDENT + nsize, 8); 1517 t16 = PtrOffset(rec, attr); 1518 1519 /* 1520 * Below function 'ntfs_save_wsl_perm' requires 0x78 bytes. 1521 * It is good idea to keep extened attributes resident. 1522 */ 1523 if (asize + t16 + 0x78 + 8 > sbi->record_size) { 1524 CLST alen; 1525 CLST clst = bytes_to_cluster(sbi, nsize); 1526 1527 /* Bytes per runs. */ 1528 t16 = sbi->record_size - t16 - SIZEOF_NONRESIDENT; 1529 1530 attr->non_res = 1; 1531 attr->nres.evcn = cpu_to_le64(clst - 1); 1532 attr->name_off = SIZEOF_NONRESIDENT_LE; 1533 attr->nres.run_off = attr->name_off; 1534 attr->nres.data_size = cpu_to_le64(nsize); 1535 attr->nres.valid_size = attr->nres.data_size; 1536 attr->nres.alloc_size = 1537 cpu_to_le64(ntfs_up_cluster(sbi, nsize)); 1538 1539 err = attr_allocate_clusters(sbi, &ni->file.run, 0, 0, 1540 clst, NULL, ALLOCATE_DEF, 1541 &alen, 0, NULL, NULL); 1542 if (err) 1543 goto out5; 1544 1545 err = run_pack(&ni->file.run, 0, clst, 1546 Add2Ptr(attr, SIZEOF_NONRESIDENT), t16, 1547 &vcn); 1548 if (err < 0) 1549 goto out5; 1550 1551 if (vcn != clst) { 1552 err = -EINVAL; 1553 goto out5; 1554 } 1555 1556 asize = SIZEOF_NONRESIDENT + ALIGN(err, 8); 1557 } else { 1558 attr->res.data_off = SIZEOF_RESIDENT_LE; 1559 attr->res.data_size = cpu_to_le32(nsize); 1560 memcpy(Add2Ptr(attr, SIZEOF_RESIDENT), rp, nsize); 1561 nsize = 0; 1562 } 1563 /* Size of symlink equals the length of input string. */ 1564 inode->i_size = size; 1565 1566 attr->size = cpu_to_le32(asize); 1567 1568 err = ntfs_insert_reparse(sbi, IO_REPARSE_TAG_SYMLINK, 1569 &new_de->ref); 1570 if (err) 1571 goto out5; 1572 1573 rp_inserted = true; 1574 } 1575 1576 attr = Add2Ptr(attr, asize); 1577 attr->type = ATTR_END; 1578 1579 rec->used = cpu_to_le32(PtrOffset(rec, attr) + 8); 1580 rec->next_attr_id = cpu_to_le16(aid); 1581 1582 /* Step 2: Add new name in index. */ 1583 err = indx_insert_entry(&dir_ni->dir, dir_ni, new_de, sbi, fnd, 0); 1584 if (err) 1585 goto out6; 1586 1587 /* Unlock parent directory before ntfs_init_acl. */ 1588 if (!fnd) 1589 ni_unlock(dir_ni); 1590 1591 inode->i_generation = le16_to_cpu(rec->seq); 1592 1593 dir->i_mtime = dir->i_ctime = inode->i_atime; 1594 1595 if (S_ISDIR(mode)) { 1596 inode->i_op = &ntfs_dir_inode_operations; 1597 inode->i_fop = &ntfs_dir_operations; 1598 } else if (S_ISLNK(mode)) { 1599 inode->i_op = &ntfs_link_inode_operations; 1600 inode->i_fop = NULL; 1601 inode->i_mapping->a_ops = &ntfs_aops; 1602 inode->i_size = size; 1603 inode_nohighmem(inode); 1604 } else if (S_ISREG(mode)) { 1605 inode->i_op = &ntfs_file_inode_operations; 1606 inode->i_fop = &ntfs_file_operations; 1607 inode->i_mapping->a_ops = 1608 is_compressed(ni) ? &ntfs_aops_cmpr : &ntfs_aops; 1609 init_rwsem(&ni->file.run_lock); 1610 } else { 1611 inode->i_op = &ntfs_special_inode_operations; 1612 init_special_inode(inode, mode, dev); 1613 } 1614 1615 #ifdef CONFIG_NTFS3_FS_POSIX_ACL 1616 if (!S_ISLNK(mode) && (sb->s_flags & SB_POSIXACL)) { 1617 err = ntfs_init_acl(idmap, inode, dir); 1618 if (err) 1619 goto out7; 1620 } else 1621 #endif 1622 { 1623 inode->i_flags |= S_NOSEC; 1624 } 1625 1626 /* Write non resident data. */ 1627 if (nsize) { 1628 err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rp, nsize, 0); 1629 if (err) 1630 goto out7; 1631 } 1632 1633 /* 1634 * Call 'd_instantiate' after inode->i_op is set 1635 * but before finish_open. 1636 */ 1637 d_instantiate(dentry, inode); 1638 1639 ntfs_save_wsl_perm(inode); 1640 mark_inode_dirty(dir); 1641 mark_inode_dirty(inode); 1642 1643 /* Normal exit. */ 1644 goto out2; 1645 1646 out7: 1647 1648 /* Undo 'indx_insert_entry'. */ 1649 if (!fnd) 1650 ni_lock_dir(dir_ni); 1651 indx_delete_entry(&dir_ni->dir, dir_ni, new_de + 1, 1652 le16_to_cpu(new_de->key_size), sbi); 1653 /* ni_unlock(dir_ni); will be called later. */ 1654 out6: 1655 if (rp_inserted) 1656 ntfs_remove_reparse(sbi, IO_REPARSE_TAG_SYMLINK, &new_de->ref); 1657 1658 out5: 1659 if (!S_ISDIR(mode)) 1660 run_deallocate(sbi, &ni->file.run, false); 1661 1662 out4: 1663 clear_rec_inuse(rec); 1664 clear_nlink(inode); 1665 ni->mi.dirty = false; 1666 discard_new_inode(inode); 1667 out3: 1668 ntfs_mark_rec_free(sbi, ino, false); 1669 1670 out2: 1671 __putname(new_de); 1672 kfree(rp); 1673 1674 out1: 1675 if (err) { 1676 if (!fnd) 1677 ni_unlock(dir_ni); 1678 return ERR_PTR(err); 1679 } 1680 1681 unlock_new_inode(inode); 1682 1683 return inode; 1684 } 1685 1686 int ntfs_link_inode(struct inode *inode, struct dentry *dentry) 1687 { 1688 int err; 1689 struct ntfs_inode *ni = ntfs_i(inode); 1690 struct ntfs_sb_info *sbi = inode->i_sb->s_fs_info; 1691 struct NTFS_DE *de; 1692 1693 /* Allocate PATH_MAX bytes. */ 1694 de = __getname(); 1695 if (!de) 1696 return -ENOMEM; 1697 1698 /* Mark rw ntfs as dirty. It will be cleared at umount. */ 1699 ntfs_set_state(sbi, NTFS_DIRTY_DIRTY); 1700 1701 /* Construct 'de'. */ 1702 err = fill_name_de(sbi, de, &dentry->d_name, NULL); 1703 if (err) 1704 goto out; 1705 1706 err = ni_add_name(ntfs_i(d_inode(dentry->d_parent)), ni, de); 1707 out: 1708 __putname(de); 1709 return err; 1710 } 1711 1712 /* 1713 * ntfs_unlink_inode 1714 * 1715 * inode_operations::unlink 1716 * inode_operations::rmdir 1717 */ 1718 int ntfs_unlink_inode(struct inode *dir, const struct dentry *dentry) 1719 { 1720 int err; 1721 struct ntfs_sb_info *sbi = dir->i_sb->s_fs_info; 1722 struct inode *inode = d_inode(dentry); 1723 struct ntfs_inode *ni = ntfs_i(inode); 1724 struct ntfs_inode *dir_ni = ntfs_i(dir); 1725 struct NTFS_DE *de, *de2 = NULL; 1726 int undo_remove; 1727 1728 if (ntfs_is_meta_file(sbi, ni->mi.rno)) 1729 return -EINVAL; 1730 1731 /* Allocate PATH_MAX bytes. */ 1732 de = __getname(); 1733 if (!de) 1734 return -ENOMEM; 1735 1736 ni_lock(ni); 1737 1738 if (S_ISDIR(inode->i_mode) && !dir_is_empty(inode)) { 1739 err = -ENOTEMPTY; 1740 goto out; 1741 } 1742 1743 err = fill_name_de(sbi, de, &dentry->d_name, NULL); 1744 if (err < 0) 1745 goto out; 1746 1747 undo_remove = 0; 1748 err = ni_remove_name(dir_ni, ni, de, &de2, &undo_remove); 1749 1750 if (!err) { 1751 drop_nlink(inode); 1752 dir->i_mtime = dir->i_ctime = current_time(dir); 1753 mark_inode_dirty(dir); 1754 inode->i_ctime = dir->i_ctime; 1755 if (inode->i_nlink) 1756 mark_inode_dirty(inode); 1757 } else if (!ni_remove_name_undo(dir_ni, ni, de, de2, undo_remove)) { 1758 _ntfs_bad_inode(inode); 1759 } else { 1760 if (ni_is_dirty(dir)) 1761 mark_inode_dirty(dir); 1762 if (ni_is_dirty(inode)) 1763 mark_inode_dirty(inode); 1764 } 1765 1766 out: 1767 ni_unlock(ni); 1768 __putname(de); 1769 return err; 1770 } 1771 1772 void ntfs_evict_inode(struct inode *inode) 1773 { 1774 truncate_inode_pages_final(&inode->i_data); 1775 1776 if (inode->i_nlink) 1777 _ni_write_inode(inode, inode_needs_sync(inode)); 1778 1779 invalidate_inode_buffers(inode); 1780 clear_inode(inode); 1781 1782 ni_clear(ntfs_i(inode)); 1783 } 1784 1785 /* 1786 * ntfs_translate_junction 1787 * 1788 * Translate a Windows junction target to the Linux equivalent. 1789 * On junctions, targets are always absolute (they include the drive 1790 * letter). We have no way of knowing if the target is for the current 1791 * mounted device or not so we just assume it is. 1792 */ 1793 static int ntfs_translate_junction(const struct super_block *sb, 1794 const struct dentry *link_de, char *target, 1795 int target_len, int target_max) 1796 { 1797 int tl_len, err = target_len; 1798 char *link_path_buffer = NULL, *link_path; 1799 char *translated = NULL; 1800 char *target_start; 1801 int copy_len; 1802 1803 link_path_buffer = kmalloc(PATH_MAX, GFP_NOFS); 1804 if (!link_path_buffer) { 1805 err = -ENOMEM; 1806 goto out; 1807 } 1808 /* Get link path, relative to mount point */ 1809 link_path = dentry_path_raw(link_de, link_path_buffer, PATH_MAX); 1810 if (IS_ERR(link_path)) { 1811 ntfs_err(sb, "Error getting link path"); 1812 err = -EINVAL; 1813 goto out; 1814 } 1815 1816 translated = kmalloc(PATH_MAX, GFP_NOFS); 1817 if (!translated) { 1818 err = -ENOMEM; 1819 goto out; 1820 } 1821 1822 /* Make translated path a relative path to mount point */ 1823 strcpy(translated, "./"); 1824 ++link_path; /* Skip leading / */ 1825 for (tl_len = sizeof("./") - 1; *link_path; ++link_path) { 1826 if (*link_path == '/') { 1827 if (PATH_MAX - tl_len < sizeof("../")) { 1828 ntfs_err(sb, 1829 "Link path %s has too many components", 1830 link_path); 1831 err = -EINVAL; 1832 goto out; 1833 } 1834 strcpy(translated + tl_len, "../"); 1835 tl_len += sizeof("../") - 1; 1836 } 1837 } 1838 1839 /* Skip drive letter */ 1840 target_start = target; 1841 while (*target_start && *target_start != ':') 1842 ++target_start; 1843 1844 if (!*target_start) { 1845 ntfs_err(sb, "Link target (%s) missing drive separator", 1846 target); 1847 err = -EINVAL; 1848 goto out; 1849 } 1850 1851 /* Skip drive separator and leading /, if exists */ 1852 target_start += 1 + (target_start[1] == '/'); 1853 copy_len = target_len - (target_start - target); 1854 1855 if (PATH_MAX - tl_len <= copy_len) { 1856 ntfs_err(sb, "Link target %s too large for buffer (%d <= %d)", 1857 target_start, PATH_MAX - tl_len, copy_len); 1858 err = -EINVAL; 1859 goto out; 1860 } 1861 1862 /* translated path has a trailing / and target_start does not */ 1863 strcpy(translated + tl_len, target_start); 1864 tl_len += copy_len; 1865 if (target_max <= tl_len) { 1866 ntfs_err(sb, "Target path %s too large for buffer (%d <= %d)", 1867 translated, target_max, tl_len); 1868 err = -EINVAL; 1869 goto out; 1870 } 1871 strcpy(target, translated); 1872 err = tl_len; 1873 1874 out: 1875 kfree(link_path_buffer); 1876 kfree(translated); 1877 return err; 1878 } 1879 1880 static noinline int ntfs_readlink_hlp(const struct dentry *link_de, 1881 struct inode *inode, char *buffer, 1882 int buflen) 1883 { 1884 int i, err = -EINVAL; 1885 struct ntfs_inode *ni = ntfs_i(inode); 1886 struct super_block *sb = inode->i_sb; 1887 struct ntfs_sb_info *sbi = sb->s_fs_info; 1888 u64 size; 1889 u16 ulen = 0; 1890 void *to_free = NULL; 1891 struct REPARSE_DATA_BUFFER *rp; 1892 const __le16 *uname; 1893 struct ATTRIB *attr; 1894 1895 /* Reparse data present. Try to parse it. */ 1896 static_assert(!offsetof(struct REPARSE_DATA_BUFFER, ReparseTag)); 1897 static_assert(sizeof(u32) == sizeof(rp->ReparseTag)); 1898 1899 *buffer = 0; 1900 1901 attr = ni_find_attr(ni, NULL, NULL, ATTR_REPARSE, NULL, 0, NULL, NULL); 1902 if (!attr) 1903 goto out; 1904 1905 if (!attr->non_res) { 1906 rp = resident_data_ex(attr, sizeof(struct REPARSE_DATA_BUFFER)); 1907 if (!rp) 1908 goto out; 1909 size = le32_to_cpu(attr->res.data_size); 1910 } else { 1911 size = le64_to_cpu(attr->nres.data_size); 1912 rp = NULL; 1913 } 1914 1915 if (size > sbi->reparse.max_size || size <= sizeof(u32)) 1916 goto out; 1917 1918 if (!rp) { 1919 rp = kmalloc(size, GFP_NOFS); 1920 if (!rp) { 1921 err = -ENOMEM; 1922 goto out; 1923 } 1924 to_free = rp; 1925 /* Read into temporal buffer. */ 1926 err = ntfs_read_run_nb(sbi, &ni->file.run, 0, rp, size, NULL); 1927 if (err) 1928 goto out; 1929 } 1930 1931 /* Microsoft Tag. */ 1932 switch (rp->ReparseTag) { 1933 case IO_REPARSE_TAG_MOUNT_POINT: 1934 /* Mount points and junctions. */ 1935 /* Can we use 'Rp->MountPointReparseBuffer.PrintNameLength'? */ 1936 if (size <= offsetof(struct REPARSE_DATA_BUFFER, 1937 MountPointReparseBuffer.PathBuffer)) 1938 goto out; 1939 uname = Add2Ptr(rp, 1940 offsetof(struct REPARSE_DATA_BUFFER, 1941 MountPointReparseBuffer.PathBuffer) + 1942 le16_to_cpu(rp->MountPointReparseBuffer 1943 .PrintNameOffset)); 1944 ulen = le16_to_cpu(rp->MountPointReparseBuffer.PrintNameLength); 1945 break; 1946 1947 case IO_REPARSE_TAG_SYMLINK: 1948 /* FolderSymbolicLink */ 1949 /* Can we use 'Rp->SymbolicLinkReparseBuffer.PrintNameLength'? */ 1950 if (size <= offsetof(struct REPARSE_DATA_BUFFER, 1951 SymbolicLinkReparseBuffer.PathBuffer)) 1952 goto out; 1953 uname = Add2Ptr( 1954 rp, offsetof(struct REPARSE_DATA_BUFFER, 1955 SymbolicLinkReparseBuffer.PathBuffer) + 1956 le16_to_cpu(rp->SymbolicLinkReparseBuffer 1957 .PrintNameOffset)); 1958 ulen = le16_to_cpu( 1959 rp->SymbolicLinkReparseBuffer.PrintNameLength); 1960 break; 1961 1962 case IO_REPARSE_TAG_CLOUD: 1963 case IO_REPARSE_TAG_CLOUD_1: 1964 case IO_REPARSE_TAG_CLOUD_2: 1965 case IO_REPARSE_TAG_CLOUD_3: 1966 case IO_REPARSE_TAG_CLOUD_4: 1967 case IO_REPARSE_TAG_CLOUD_5: 1968 case IO_REPARSE_TAG_CLOUD_6: 1969 case IO_REPARSE_TAG_CLOUD_7: 1970 case IO_REPARSE_TAG_CLOUD_8: 1971 case IO_REPARSE_TAG_CLOUD_9: 1972 case IO_REPARSE_TAG_CLOUD_A: 1973 case IO_REPARSE_TAG_CLOUD_B: 1974 case IO_REPARSE_TAG_CLOUD_C: 1975 case IO_REPARSE_TAG_CLOUD_D: 1976 case IO_REPARSE_TAG_CLOUD_E: 1977 case IO_REPARSE_TAG_CLOUD_F: 1978 err = sizeof("OneDrive") - 1; 1979 if (err > buflen) 1980 err = buflen; 1981 memcpy(buffer, "OneDrive", err); 1982 goto out; 1983 1984 default: 1985 if (IsReparseTagMicrosoft(rp->ReparseTag)) { 1986 /* Unknown Microsoft Tag. */ 1987 goto out; 1988 } 1989 if (!IsReparseTagNameSurrogate(rp->ReparseTag) || 1990 size <= sizeof(struct REPARSE_POINT)) { 1991 goto out; 1992 } 1993 1994 /* Users tag. */ 1995 uname = Add2Ptr(rp, sizeof(struct REPARSE_POINT)); 1996 ulen = le16_to_cpu(rp->ReparseDataLength) - 1997 sizeof(struct REPARSE_POINT); 1998 } 1999 2000 /* Convert nlen from bytes to UNICODE chars. */ 2001 ulen >>= 1; 2002 2003 /* Check that name is available. */ 2004 if (!ulen || uname + ulen > (__le16 *)Add2Ptr(rp, size)) 2005 goto out; 2006 2007 /* If name is already zero terminated then truncate it now. */ 2008 if (!uname[ulen - 1]) 2009 ulen -= 1; 2010 2011 err = ntfs_utf16_to_nls(sbi, uname, ulen, buffer, buflen); 2012 2013 if (err < 0) 2014 goto out; 2015 2016 /* Translate Windows '\' into Linux '/'. */ 2017 for (i = 0; i < err; i++) { 2018 if (buffer[i] == '\\') 2019 buffer[i] = '/'; 2020 } 2021 2022 /* Always set last zero. */ 2023 buffer[err] = 0; 2024 2025 /* If this is a junction, translate the link target. */ 2026 if (rp->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) 2027 err = ntfs_translate_junction(sb, link_de, buffer, err, buflen); 2028 2029 out: 2030 kfree(to_free); 2031 return err; 2032 } 2033 2034 static const char *ntfs_get_link(struct dentry *de, struct inode *inode, 2035 struct delayed_call *done) 2036 { 2037 int err; 2038 char *ret; 2039 2040 if (!de) 2041 return ERR_PTR(-ECHILD); 2042 2043 ret = kmalloc(PAGE_SIZE, GFP_NOFS); 2044 if (!ret) 2045 return ERR_PTR(-ENOMEM); 2046 2047 err = ntfs_readlink_hlp(de, inode, ret, PAGE_SIZE); 2048 if (err < 0) { 2049 kfree(ret); 2050 return ERR_PTR(err); 2051 } 2052 2053 set_delayed_call(done, kfree_link, ret); 2054 2055 return ret; 2056 } 2057 2058 // clang-format off 2059 const struct inode_operations ntfs_link_inode_operations = { 2060 .get_link = ntfs_get_link, 2061 .setattr = ntfs3_setattr, 2062 .listxattr = ntfs_listxattr, 2063 .permission = ntfs_permission, 2064 }; 2065 2066 const struct address_space_operations ntfs_aops = { 2067 .read_folio = ntfs_read_folio, 2068 .readahead = ntfs_readahead, 2069 .writepage = ntfs_writepage, 2070 .writepages = ntfs_writepages, 2071 .write_begin = ntfs_write_begin, 2072 .write_end = ntfs_write_end, 2073 .direct_IO = ntfs_direct_IO, 2074 .bmap = ntfs_bmap, 2075 .dirty_folio = block_dirty_folio, 2076 .invalidate_folio = block_invalidate_folio, 2077 }; 2078 2079 const struct address_space_operations ntfs_aops_cmpr = { 2080 .read_folio = ntfs_read_folio, 2081 .readahead = ntfs_readahead, 2082 }; 2083 // clang-format on 2084