1 /** 2 * inode.c - NTFS kernel inode handling. 3 * 4 * Copyright (c) 2001-2014 Anton Altaparmakov and Tuxera Inc. 5 * 6 * This program/include file is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as published 8 * by the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program/include file is distributed in the hope that it will be 12 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program (in the main directory of the Linux-NTFS 18 * distribution in the file COPYING); if not, write to the Free Software 19 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #include <linux/buffer_head.h> 23 #include <linux/fs.h> 24 #include <linux/mm.h> 25 #include <linux/mount.h> 26 #include <linux/mutex.h> 27 #include <linux/pagemap.h> 28 #include <linux/quotaops.h> 29 #include <linux/slab.h> 30 #include <linux/log2.h> 31 #include <linux/aio.h> 32 33 #include "aops.h" 34 #include "attrib.h" 35 #include "bitmap.h" 36 #include "dir.h" 37 #include "debug.h" 38 #include "inode.h" 39 #include "lcnalloc.h" 40 #include "malloc.h" 41 #include "mft.h" 42 #include "time.h" 43 #include "ntfs.h" 44 45 /** 46 * ntfs_test_inode - compare two (possibly fake) inodes for equality 47 * @vi: vfs inode which to test 48 * @na: ntfs attribute which is being tested with 49 * 50 * Compare the ntfs attribute embedded in the ntfs specific part of the vfs 51 * inode @vi for equality with the ntfs attribute @na. 52 * 53 * If searching for the normal file/directory inode, set @na->type to AT_UNUSED. 54 * @na->name and @na->name_len are then ignored. 55 * 56 * Return 1 if the attributes match and 0 if not. 57 * 58 * NOTE: This function runs with the inode_hash_lock spin lock held so it is not 59 * allowed to sleep. 60 */ 61 int ntfs_test_inode(struct inode *vi, ntfs_attr *na) 62 { 63 ntfs_inode *ni; 64 65 if (vi->i_ino != na->mft_no) 66 return 0; 67 ni = NTFS_I(vi); 68 /* If !NInoAttr(ni), @vi is a normal file or directory inode. */ 69 if (likely(!NInoAttr(ni))) { 70 /* If not looking for a normal inode this is a mismatch. */ 71 if (unlikely(na->type != AT_UNUSED)) 72 return 0; 73 } else { 74 /* A fake inode describing an attribute. */ 75 if (ni->type != na->type) 76 return 0; 77 if (ni->name_len != na->name_len) 78 return 0; 79 if (na->name_len && memcmp(ni->name, na->name, 80 na->name_len * sizeof(ntfschar))) 81 return 0; 82 } 83 /* Match! */ 84 return 1; 85 } 86 87 /** 88 * ntfs_init_locked_inode - initialize an inode 89 * @vi: vfs inode to initialize 90 * @na: ntfs attribute which to initialize @vi to 91 * 92 * Initialize the vfs inode @vi with the values from the ntfs attribute @na in 93 * order to enable ntfs_test_inode() to do its work. 94 * 95 * If initializing the normal file/directory inode, set @na->type to AT_UNUSED. 96 * In that case, @na->name and @na->name_len should be set to NULL and 0, 97 * respectively. Although that is not strictly necessary as 98 * ntfs_read_locked_inode() will fill them in later. 99 * 100 * Return 0 on success and -errno on error. 101 * 102 * NOTE: This function runs with the inode->i_lock spin lock held so it is not 103 * allowed to sleep. (Hence the GFP_ATOMIC allocation.) 104 */ 105 static int ntfs_init_locked_inode(struct inode *vi, ntfs_attr *na) 106 { 107 ntfs_inode *ni = NTFS_I(vi); 108 109 vi->i_ino = na->mft_no; 110 111 ni->type = na->type; 112 if (na->type == AT_INDEX_ALLOCATION) 113 NInoSetMstProtected(ni); 114 115 ni->name = na->name; 116 ni->name_len = na->name_len; 117 118 /* If initializing a normal inode, we are done. */ 119 if (likely(na->type == AT_UNUSED)) { 120 BUG_ON(na->name); 121 BUG_ON(na->name_len); 122 return 0; 123 } 124 125 /* It is a fake inode. */ 126 NInoSetAttr(ni); 127 128 /* 129 * We have I30 global constant as an optimization as it is the name 130 * in >99.9% of named attributes! The other <0.1% incur a GFP_ATOMIC 131 * allocation but that is ok. And most attributes are unnamed anyway, 132 * thus the fraction of named attributes with name != I30 is actually 133 * absolutely tiny. 134 */ 135 if (na->name_len && na->name != I30) { 136 unsigned int i; 137 138 BUG_ON(!na->name); 139 i = na->name_len * sizeof(ntfschar); 140 ni->name = kmalloc(i + sizeof(ntfschar), GFP_ATOMIC); 141 if (!ni->name) 142 return -ENOMEM; 143 memcpy(ni->name, na->name, i); 144 ni->name[na->name_len] = 0; 145 } 146 return 0; 147 } 148 149 typedef int (*set_t)(struct inode *, void *); 150 static int ntfs_read_locked_inode(struct inode *vi); 151 static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi); 152 static int ntfs_read_locked_index_inode(struct inode *base_vi, 153 struct inode *vi); 154 155 /** 156 * ntfs_iget - obtain a struct inode corresponding to a specific normal inode 157 * @sb: super block of mounted volume 158 * @mft_no: mft record number / inode number to obtain 159 * 160 * Obtain the struct inode corresponding to a specific normal inode (i.e. a 161 * file or directory). 162 * 163 * If the inode is in the cache, it is just returned with an increased 164 * reference count. Otherwise, a new struct inode is allocated and initialized, 165 * and finally ntfs_read_locked_inode() is called to read in the inode and 166 * fill in the remainder of the inode structure. 167 * 168 * Return the struct inode on success. Check the return value with IS_ERR() and 169 * if true, the function failed and the error code is obtained from PTR_ERR(). 170 */ 171 struct inode *ntfs_iget(struct super_block *sb, unsigned long mft_no) 172 { 173 struct inode *vi; 174 int err; 175 ntfs_attr na; 176 177 na.mft_no = mft_no; 178 na.type = AT_UNUSED; 179 na.name = NULL; 180 na.name_len = 0; 181 182 vi = iget5_locked(sb, mft_no, (test_t)ntfs_test_inode, 183 (set_t)ntfs_init_locked_inode, &na); 184 if (unlikely(!vi)) 185 return ERR_PTR(-ENOMEM); 186 187 err = 0; 188 189 /* If this is a freshly allocated inode, need to read it now. */ 190 if (vi->i_state & I_NEW) { 191 err = ntfs_read_locked_inode(vi); 192 unlock_new_inode(vi); 193 } 194 /* 195 * There is no point in keeping bad inodes around if the failure was 196 * due to ENOMEM. We want to be able to retry again later. 197 */ 198 if (unlikely(err == -ENOMEM)) { 199 iput(vi); 200 vi = ERR_PTR(err); 201 } 202 return vi; 203 } 204 205 /** 206 * ntfs_attr_iget - obtain a struct inode corresponding to an attribute 207 * @base_vi: vfs base inode containing the attribute 208 * @type: attribute type 209 * @name: Unicode name of the attribute (NULL if unnamed) 210 * @name_len: length of @name in Unicode characters (0 if unnamed) 211 * 212 * Obtain the (fake) struct inode corresponding to the attribute specified by 213 * @type, @name, and @name_len, which is present in the base mft record 214 * specified by the vfs inode @base_vi. 215 * 216 * If the attribute inode is in the cache, it is just returned with an 217 * increased reference count. Otherwise, a new struct inode is allocated and 218 * initialized, and finally ntfs_read_locked_attr_inode() is called to read the 219 * attribute and fill in the inode structure. 220 * 221 * Note, for index allocation attributes, you need to use ntfs_index_iget() 222 * instead of ntfs_attr_iget() as working with indices is a lot more complex. 223 * 224 * Return the struct inode of the attribute inode on success. Check the return 225 * value with IS_ERR() and if true, the function failed and the error code is 226 * obtained from PTR_ERR(). 227 */ 228 struct inode *ntfs_attr_iget(struct inode *base_vi, ATTR_TYPE type, 229 ntfschar *name, u32 name_len) 230 { 231 struct inode *vi; 232 int err; 233 ntfs_attr na; 234 235 /* Make sure no one calls ntfs_attr_iget() for indices. */ 236 BUG_ON(type == AT_INDEX_ALLOCATION); 237 238 na.mft_no = base_vi->i_ino; 239 na.type = type; 240 na.name = name; 241 na.name_len = name_len; 242 243 vi = iget5_locked(base_vi->i_sb, na.mft_no, (test_t)ntfs_test_inode, 244 (set_t)ntfs_init_locked_inode, &na); 245 if (unlikely(!vi)) 246 return ERR_PTR(-ENOMEM); 247 248 err = 0; 249 250 /* If this is a freshly allocated inode, need to read it now. */ 251 if (vi->i_state & I_NEW) { 252 err = ntfs_read_locked_attr_inode(base_vi, vi); 253 unlock_new_inode(vi); 254 } 255 /* 256 * There is no point in keeping bad attribute inodes around. This also 257 * simplifies things in that we never need to check for bad attribute 258 * inodes elsewhere. 259 */ 260 if (unlikely(err)) { 261 iput(vi); 262 vi = ERR_PTR(err); 263 } 264 return vi; 265 } 266 267 /** 268 * ntfs_index_iget - obtain a struct inode corresponding to an index 269 * @base_vi: vfs base inode containing the index related attributes 270 * @name: Unicode name of the index 271 * @name_len: length of @name in Unicode characters 272 * 273 * Obtain the (fake) struct inode corresponding to the index specified by @name 274 * and @name_len, which is present in the base mft record specified by the vfs 275 * inode @base_vi. 276 * 277 * If the index inode is in the cache, it is just returned with an increased 278 * reference count. Otherwise, a new struct inode is allocated and 279 * initialized, and finally ntfs_read_locked_index_inode() is called to read 280 * the index related attributes and fill in the inode structure. 281 * 282 * Return the struct inode of the index inode on success. Check the return 283 * value with IS_ERR() and if true, the function failed and the error code is 284 * obtained from PTR_ERR(). 285 */ 286 struct inode *ntfs_index_iget(struct inode *base_vi, ntfschar *name, 287 u32 name_len) 288 { 289 struct inode *vi; 290 int err; 291 ntfs_attr na; 292 293 na.mft_no = base_vi->i_ino; 294 na.type = AT_INDEX_ALLOCATION; 295 na.name = name; 296 na.name_len = name_len; 297 298 vi = iget5_locked(base_vi->i_sb, na.mft_no, (test_t)ntfs_test_inode, 299 (set_t)ntfs_init_locked_inode, &na); 300 if (unlikely(!vi)) 301 return ERR_PTR(-ENOMEM); 302 303 err = 0; 304 305 /* If this is a freshly allocated inode, need to read it now. */ 306 if (vi->i_state & I_NEW) { 307 err = ntfs_read_locked_index_inode(base_vi, vi); 308 unlock_new_inode(vi); 309 } 310 /* 311 * There is no point in keeping bad index inodes around. This also 312 * simplifies things in that we never need to check for bad index 313 * inodes elsewhere. 314 */ 315 if (unlikely(err)) { 316 iput(vi); 317 vi = ERR_PTR(err); 318 } 319 return vi; 320 } 321 322 struct inode *ntfs_alloc_big_inode(struct super_block *sb) 323 { 324 ntfs_inode *ni; 325 326 ntfs_debug("Entering."); 327 ni = kmem_cache_alloc(ntfs_big_inode_cache, GFP_NOFS); 328 if (likely(ni != NULL)) { 329 ni->state = 0; 330 return VFS_I(ni); 331 } 332 ntfs_error(sb, "Allocation of NTFS big inode structure failed."); 333 return NULL; 334 } 335 336 static void ntfs_i_callback(struct rcu_head *head) 337 { 338 struct inode *inode = container_of(head, struct inode, i_rcu); 339 kmem_cache_free(ntfs_big_inode_cache, NTFS_I(inode)); 340 } 341 342 void ntfs_destroy_big_inode(struct inode *inode) 343 { 344 ntfs_inode *ni = NTFS_I(inode); 345 346 ntfs_debug("Entering."); 347 BUG_ON(ni->page); 348 if (!atomic_dec_and_test(&ni->count)) 349 BUG(); 350 call_rcu(&inode->i_rcu, ntfs_i_callback); 351 } 352 353 static inline ntfs_inode *ntfs_alloc_extent_inode(void) 354 { 355 ntfs_inode *ni; 356 357 ntfs_debug("Entering."); 358 ni = kmem_cache_alloc(ntfs_inode_cache, GFP_NOFS); 359 if (likely(ni != NULL)) { 360 ni->state = 0; 361 return ni; 362 } 363 ntfs_error(NULL, "Allocation of NTFS inode structure failed."); 364 return NULL; 365 } 366 367 static void ntfs_destroy_extent_inode(ntfs_inode *ni) 368 { 369 ntfs_debug("Entering."); 370 BUG_ON(ni->page); 371 if (!atomic_dec_and_test(&ni->count)) 372 BUG(); 373 kmem_cache_free(ntfs_inode_cache, ni); 374 } 375 376 /* 377 * The attribute runlist lock has separate locking rules from the 378 * normal runlist lock, so split the two lock-classes: 379 */ 380 static struct lock_class_key attr_list_rl_lock_class; 381 382 /** 383 * __ntfs_init_inode - initialize ntfs specific part of an inode 384 * @sb: super block of mounted volume 385 * @ni: freshly allocated ntfs inode which to initialize 386 * 387 * Initialize an ntfs inode to defaults. 388 * 389 * NOTE: ni->mft_no, ni->state, ni->type, ni->name, and ni->name_len are left 390 * untouched. Make sure to initialize them elsewhere. 391 * 392 * Return zero on success and -ENOMEM on error. 393 */ 394 void __ntfs_init_inode(struct super_block *sb, ntfs_inode *ni) 395 { 396 ntfs_debug("Entering."); 397 rwlock_init(&ni->size_lock); 398 ni->initialized_size = ni->allocated_size = 0; 399 ni->seq_no = 0; 400 atomic_set(&ni->count, 1); 401 ni->vol = NTFS_SB(sb); 402 ntfs_init_runlist(&ni->runlist); 403 mutex_init(&ni->mrec_lock); 404 ni->page = NULL; 405 ni->page_ofs = 0; 406 ni->attr_list_size = 0; 407 ni->attr_list = NULL; 408 ntfs_init_runlist(&ni->attr_list_rl); 409 lockdep_set_class(&ni->attr_list_rl.lock, 410 &attr_list_rl_lock_class); 411 ni->itype.index.block_size = 0; 412 ni->itype.index.vcn_size = 0; 413 ni->itype.index.collation_rule = 0; 414 ni->itype.index.block_size_bits = 0; 415 ni->itype.index.vcn_size_bits = 0; 416 mutex_init(&ni->extent_lock); 417 ni->nr_extents = 0; 418 ni->ext.base_ntfs_ino = NULL; 419 } 420 421 /* 422 * Extent inodes get MFT-mapped in a nested way, while the base inode 423 * is still mapped. Teach this nesting to the lock validator by creating 424 * a separate class for nested inode's mrec_lock's: 425 */ 426 static struct lock_class_key extent_inode_mrec_lock_key; 427 428 inline ntfs_inode *ntfs_new_extent_inode(struct super_block *sb, 429 unsigned long mft_no) 430 { 431 ntfs_inode *ni = ntfs_alloc_extent_inode(); 432 433 ntfs_debug("Entering."); 434 if (likely(ni != NULL)) { 435 __ntfs_init_inode(sb, ni); 436 lockdep_set_class(&ni->mrec_lock, &extent_inode_mrec_lock_key); 437 ni->mft_no = mft_no; 438 ni->type = AT_UNUSED; 439 ni->name = NULL; 440 ni->name_len = 0; 441 } 442 return ni; 443 } 444 445 /** 446 * ntfs_is_extended_system_file - check if a file is in the $Extend directory 447 * @ctx: initialized attribute search context 448 * 449 * Search all file name attributes in the inode described by the attribute 450 * search context @ctx and check if any of the names are in the $Extend system 451 * directory. 452 * 453 * Return values: 454 * 1: file is in $Extend directory 455 * 0: file is not in $Extend directory 456 * -errno: failed to determine if the file is in the $Extend directory 457 */ 458 static int ntfs_is_extended_system_file(ntfs_attr_search_ctx *ctx) 459 { 460 int nr_links, err; 461 462 /* Restart search. */ 463 ntfs_attr_reinit_search_ctx(ctx); 464 465 /* Get number of hard links. */ 466 nr_links = le16_to_cpu(ctx->mrec->link_count); 467 468 /* Loop through all hard links. */ 469 while (!(err = ntfs_attr_lookup(AT_FILE_NAME, NULL, 0, 0, 0, NULL, 0, 470 ctx))) { 471 FILE_NAME_ATTR *file_name_attr; 472 ATTR_RECORD *attr = ctx->attr; 473 u8 *p, *p2; 474 475 nr_links--; 476 /* 477 * Maximum sanity checking as we are called on an inode that 478 * we suspect might be corrupt. 479 */ 480 p = (u8*)attr + le32_to_cpu(attr->length); 481 if (p < (u8*)ctx->mrec || (u8*)p > (u8*)ctx->mrec + 482 le32_to_cpu(ctx->mrec->bytes_in_use)) { 483 err_corrupt_attr: 484 ntfs_error(ctx->ntfs_ino->vol->sb, "Corrupt file name " 485 "attribute. You should run chkdsk."); 486 return -EIO; 487 } 488 if (attr->non_resident) { 489 ntfs_error(ctx->ntfs_ino->vol->sb, "Non-resident file " 490 "name. You should run chkdsk."); 491 return -EIO; 492 } 493 if (attr->flags) { 494 ntfs_error(ctx->ntfs_ino->vol->sb, "File name with " 495 "invalid flags. You should run " 496 "chkdsk."); 497 return -EIO; 498 } 499 if (!(attr->data.resident.flags & RESIDENT_ATTR_IS_INDEXED)) { 500 ntfs_error(ctx->ntfs_ino->vol->sb, "Unindexed file " 501 "name. You should run chkdsk."); 502 return -EIO; 503 } 504 file_name_attr = (FILE_NAME_ATTR*)((u8*)attr + 505 le16_to_cpu(attr->data.resident.value_offset)); 506 p2 = (u8*)attr + le32_to_cpu(attr->data.resident.value_length); 507 if (p2 < (u8*)attr || p2 > p) 508 goto err_corrupt_attr; 509 /* This attribute is ok, but is it in the $Extend directory? */ 510 if (MREF_LE(file_name_attr->parent_directory) == FILE_Extend) 511 return 1; /* YES, it's an extended system file. */ 512 } 513 if (unlikely(err != -ENOENT)) 514 return err; 515 if (unlikely(nr_links)) { 516 ntfs_error(ctx->ntfs_ino->vol->sb, "Inode hard link count " 517 "doesn't match number of name attributes. You " 518 "should run chkdsk."); 519 return -EIO; 520 } 521 return 0; /* NO, it is not an extended system file. */ 522 } 523 524 /** 525 * ntfs_read_locked_inode - read an inode from its device 526 * @vi: inode to read 527 * 528 * ntfs_read_locked_inode() is called from ntfs_iget() to read the inode 529 * described by @vi into memory from the device. 530 * 531 * The only fields in @vi that we need to/can look at when the function is 532 * called are i_sb, pointing to the mounted device's super block, and i_ino, 533 * the number of the inode to load. 534 * 535 * ntfs_read_locked_inode() maps, pins and locks the mft record number i_ino 536 * for reading and sets up the necessary @vi fields as well as initializing 537 * the ntfs inode. 538 * 539 * Q: What locks are held when the function is called? 540 * A: i_state has I_NEW set, hence the inode is locked, also 541 * i_count is set to 1, so it is not going to go away 542 * i_flags is set to 0 and we have no business touching it. Only an ioctl() 543 * is allowed to write to them. We should of course be honouring them but 544 * we need to do that using the IS_* macros defined in include/linux/fs.h. 545 * In any case ntfs_read_locked_inode() has nothing to do with i_flags. 546 * 547 * Return 0 on success and -errno on error. In the error case, the inode will 548 * have had make_bad_inode() executed on it. 549 */ 550 static int ntfs_read_locked_inode(struct inode *vi) 551 { 552 ntfs_volume *vol = NTFS_SB(vi->i_sb); 553 ntfs_inode *ni; 554 struct inode *bvi; 555 MFT_RECORD *m; 556 ATTR_RECORD *a; 557 STANDARD_INFORMATION *si; 558 ntfs_attr_search_ctx *ctx; 559 int err = 0; 560 561 ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino); 562 563 /* Setup the generic vfs inode parts now. */ 564 565 /* 566 * This is for checking whether an inode has changed w.r.t. a file so 567 * that the file can be updated if necessary (compare with f_version). 568 */ 569 vi->i_version = 1; 570 571 vi->i_uid = vol->uid; 572 vi->i_gid = vol->gid; 573 vi->i_mode = 0; 574 575 /* 576 * Initialize the ntfs specific part of @vi special casing 577 * FILE_MFT which we need to do at mount time. 578 */ 579 if (vi->i_ino != FILE_MFT) 580 ntfs_init_big_inode(vi); 581 ni = NTFS_I(vi); 582 583 m = map_mft_record(ni); 584 if (IS_ERR(m)) { 585 err = PTR_ERR(m); 586 goto err_out; 587 } 588 ctx = ntfs_attr_get_search_ctx(ni, m); 589 if (!ctx) { 590 err = -ENOMEM; 591 goto unm_err_out; 592 } 593 594 if (!(m->flags & MFT_RECORD_IN_USE)) { 595 ntfs_error(vi->i_sb, "Inode is not in use!"); 596 goto unm_err_out; 597 } 598 if (m->base_mft_record) { 599 ntfs_error(vi->i_sb, "Inode is an extent inode!"); 600 goto unm_err_out; 601 } 602 603 /* Transfer information from mft record into vfs and ntfs inodes. */ 604 vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number); 605 606 /* 607 * FIXME: Keep in mind that link_count is two for files which have both 608 * a long file name and a short file name as separate entries, so if 609 * we are hiding short file names this will be too high. Either we need 610 * to account for the short file names by subtracting them or we need 611 * to make sure we delete files even though i_nlink is not zero which 612 * might be tricky due to vfs interactions. Need to think about this 613 * some more when implementing the unlink command. 614 */ 615 set_nlink(vi, le16_to_cpu(m->link_count)); 616 /* 617 * FIXME: Reparse points can have the directory bit set even though 618 * they would be S_IFLNK. Need to deal with this further below when we 619 * implement reparse points / symbolic links but it will do for now. 620 * Also if not a directory, it could be something else, rather than 621 * a regular file. But again, will do for now. 622 */ 623 /* Everyone gets all permissions. */ 624 vi->i_mode |= S_IRWXUGO; 625 /* If read-only, no one gets write permissions. */ 626 if (IS_RDONLY(vi)) 627 vi->i_mode &= ~S_IWUGO; 628 if (m->flags & MFT_RECORD_IS_DIRECTORY) { 629 vi->i_mode |= S_IFDIR; 630 /* 631 * Apply the directory permissions mask set in the mount 632 * options. 633 */ 634 vi->i_mode &= ~vol->dmask; 635 /* Things break without this kludge! */ 636 if (vi->i_nlink > 1) 637 set_nlink(vi, 1); 638 } else { 639 vi->i_mode |= S_IFREG; 640 /* Apply the file permissions mask set in the mount options. */ 641 vi->i_mode &= ~vol->fmask; 642 } 643 /* 644 * Find the standard information attribute in the mft record. At this 645 * stage we haven't setup the attribute list stuff yet, so this could 646 * in fact fail if the standard information is in an extent record, but 647 * I don't think this actually ever happens. 648 */ 649 err = ntfs_attr_lookup(AT_STANDARD_INFORMATION, NULL, 0, 0, 0, NULL, 0, 650 ctx); 651 if (unlikely(err)) { 652 if (err == -ENOENT) { 653 /* 654 * TODO: We should be performing a hot fix here (if the 655 * recover mount option is set) by creating a new 656 * attribute. 657 */ 658 ntfs_error(vi->i_sb, "$STANDARD_INFORMATION attribute " 659 "is missing."); 660 } 661 goto unm_err_out; 662 } 663 a = ctx->attr; 664 /* Get the standard information attribute value. */ 665 si = (STANDARD_INFORMATION*)((u8*)a + 666 le16_to_cpu(a->data.resident.value_offset)); 667 668 /* Transfer information from the standard information into vi. */ 669 /* 670 * Note: The i_?times do not quite map perfectly onto the NTFS times, 671 * but they are close enough, and in the end it doesn't really matter 672 * that much... 673 */ 674 /* 675 * mtime is the last change of the data within the file. Not changed 676 * when only metadata is changed, e.g. a rename doesn't affect mtime. 677 */ 678 vi->i_mtime = ntfs2utc(si->last_data_change_time); 679 /* 680 * ctime is the last change of the metadata of the file. This obviously 681 * always changes, when mtime is changed. ctime can be changed on its 682 * own, mtime is then not changed, e.g. when a file is renamed. 683 */ 684 vi->i_ctime = ntfs2utc(si->last_mft_change_time); 685 /* 686 * Last access to the data within the file. Not changed during a rename 687 * for example but changed whenever the file is written to. 688 */ 689 vi->i_atime = ntfs2utc(si->last_access_time); 690 691 /* Find the attribute list attribute if present. */ 692 ntfs_attr_reinit_search_ctx(ctx); 693 err = ntfs_attr_lookup(AT_ATTRIBUTE_LIST, NULL, 0, 0, 0, NULL, 0, ctx); 694 if (err) { 695 if (unlikely(err != -ENOENT)) { 696 ntfs_error(vi->i_sb, "Failed to lookup attribute list " 697 "attribute."); 698 goto unm_err_out; 699 } 700 } else /* if (!err) */ { 701 if (vi->i_ino == FILE_MFT) 702 goto skip_attr_list_load; 703 ntfs_debug("Attribute list found in inode 0x%lx.", vi->i_ino); 704 NInoSetAttrList(ni); 705 a = ctx->attr; 706 if (a->flags & ATTR_COMPRESSION_MASK) { 707 ntfs_error(vi->i_sb, "Attribute list attribute is " 708 "compressed."); 709 goto unm_err_out; 710 } 711 if (a->flags & ATTR_IS_ENCRYPTED || 712 a->flags & ATTR_IS_SPARSE) { 713 if (a->non_resident) { 714 ntfs_error(vi->i_sb, "Non-resident attribute " 715 "list attribute is encrypted/" 716 "sparse."); 717 goto unm_err_out; 718 } 719 ntfs_warning(vi->i_sb, "Resident attribute list " 720 "attribute in inode 0x%lx is marked " 721 "encrypted/sparse which is not true. " 722 "However, Windows allows this and " 723 "chkdsk does not detect or correct it " 724 "so we will just ignore the invalid " 725 "flags and pretend they are not set.", 726 vi->i_ino); 727 } 728 /* Now allocate memory for the attribute list. */ 729 ni->attr_list_size = (u32)ntfs_attr_size(a); 730 ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size); 731 if (!ni->attr_list) { 732 ntfs_error(vi->i_sb, "Not enough memory to allocate " 733 "buffer for attribute list."); 734 err = -ENOMEM; 735 goto unm_err_out; 736 } 737 if (a->non_resident) { 738 NInoSetAttrListNonResident(ni); 739 if (a->data.non_resident.lowest_vcn) { 740 ntfs_error(vi->i_sb, "Attribute list has non " 741 "zero lowest_vcn."); 742 goto unm_err_out; 743 } 744 /* 745 * Setup the runlist. No need for locking as we have 746 * exclusive access to the inode at this time. 747 */ 748 ni->attr_list_rl.rl = ntfs_mapping_pairs_decompress(vol, 749 a, NULL); 750 if (IS_ERR(ni->attr_list_rl.rl)) { 751 err = PTR_ERR(ni->attr_list_rl.rl); 752 ni->attr_list_rl.rl = NULL; 753 ntfs_error(vi->i_sb, "Mapping pairs " 754 "decompression failed."); 755 goto unm_err_out; 756 } 757 /* Now load the attribute list. */ 758 if ((err = load_attribute_list(vol, &ni->attr_list_rl, 759 ni->attr_list, ni->attr_list_size, 760 sle64_to_cpu(a->data.non_resident. 761 initialized_size)))) { 762 ntfs_error(vi->i_sb, "Failed to load " 763 "attribute list attribute."); 764 goto unm_err_out; 765 } 766 } else /* if (!a->non_resident) */ { 767 if ((u8*)a + le16_to_cpu(a->data.resident.value_offset) 768 + le32_to_cpu( 769 a->data.resident.value_length) > 770 (u8*)ctx->mrec + vol->mft_record_size) { 771 ntfs_error(vi->i_sb, "Corrupt attribute list " 772 "in inode."); 773 goto unm_err_out; 774 } 775 /* Now copy the attribute list. */ 776 memcpy(ni->attr_list, (u8*)a + le16_to_cpu( 777 a->data.resident.value_offset), 778 le32_to_cpu( 779 a->data.resident.value_length)); 780 } 781 } 782 skip_attr_list_load: 783 /* 784 * If an attribute list is present we now have the attribute list value 785 * in ntfs_ino->attr_list and it is ntfs_ino->attr_list_size bytes. 786 */ 787 if (S_ISDIR(vi->i_mode)) { 788 loff_t bvi_size; 789 ntfs_inode *bni; 790 INDEX_ROOT *ir; 791 u8 *ir_end, *index_end; 792 793 /* It is a directory, find index root attribute. */ 794 ntfs_attr_reinit_search_ctx(ctx); 795 err = ntfs_attr_lookup(AT_INDEX_ROOT, I30, 4, CASE_SENSITIVE, 796 0, NULL, 0, ctx); 797 if (unlikely(err)) { 798 if (err == -ENOENT) { 799 // FIXME: File is corrupt! Hot-fix with empty 800 // index root attribute if recovery option is 801 // set. 802 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute " 803 "is missing."); 804 } 805 goto unm_err_out; 806 } 807 a = ctx->attr; 808 /* Set up the state. */ 809 if (unlikely(a->non_resident)) { 810 ntfs_error(vol->sb, "$INDEX_ROOT attribute is not " 811 "resident."); 812 goto unm_err_out; 813 } 814 /* Ensure the attribute name is placed before the value. */ 815 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >= 816 le16_to_cpu(a->data.resident.value_offset)))) { 817 ntfs_error(vol->sb, "$INDEX_ROOT attribute name is " 818 "placed after the attribute value."); 819 goto unm_err_out; 820 } 821 /* 822 * Compressed/encrypted index root just means that the newly 823 * created files in that directory should be created compressed/ 824 * encrypted. However index root cannot be both compressed and 825 * encrypted. 826 */ 827 if (a->flags & ATTR_COMPRESSION_MASK) 828 NInoSetCompressed(ni); 829 if (a->flags & ATTR_IS_ENCRYPTED) { 830 if (a->flags & ATTR_COMPRESSION_MASK) { 831 ntfs_error(vi->i_sb, "Found encrypted and " 832 "compressed attribute."); 833 goto unm_err_out; 834 } 835 NInoSetEncrypted(ni); 836 } 837 if (a->flags & ATTR_IS_SPARSE) 838 NInoSetSparse(ni); 839 ir = (INDEX_ROOT*)((u8*)a + 840 le16_to_cpu(a->data.resident.value_offset)); 841 ir_end = (u8*)ir + le32_to_cpu(a->data.resident.value_length); 842 if (ir_end > (u8*)ctx->mrec + vol->mft_record_size) { 843 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is " 844 "corrupt."); 845 goto unm_err_out; 846 } 847 index_end = (u8*)&ir->index + 848 le32_to_cpu(ir->index.index_length); 849 if (index_end > ir_end) { 850 ntfs_error(vi->i_sb, "Directory index is corrupt."); 851 goto unm_err_out; 852 } 853 if (ir->type != AT_FILE_NAME) { 854 ntfs_error(vi->i_sb, "Indexed attribute is not " 855 "$FILE_NAME."); 856 goto unm_err_out; 857 } 858 if (ir->collation_rule != COLLATION_FILE_NAME) { 859 ntfs_error(vi->i_sb, "Index collation rule is not " 860 "COLLATION_FILE_NAME."); 861 goto unm_err_out; 862 } 863 ni->itype.index.collation_rule = ir->collation_rule; 864 ni->itype.index.block_size = le32_to_cpu(ir->index_block_size); 865 if (ni->itype.index.block_size & 866 (ni->itype.index.block_size - 1)) { 867 ntfs_error(vi->i_sb, "Index block size (%u) is not a " 868 "power of two.", 869 ni->itype.index.block_size); 870 goto unm_err_out; 871 } 872 if (ni->itype.index.block_size > PAGE_CACHE_SIZE) { 873 ntfs_error(vi->i_sb, "Index block size (%u) > " 874 "PAGE_CACHE_SIZE (%ld) is not " 875 "supported. Sorry.", 876 ni->itype.index.block_size, 877 PAGE_CACHE_SIZE); 878 err = -EOPNOTSUPP; 879 goto unm_err_out; 880 } 881 if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) { 882 ntfs_error(vi->i_sb, "Index block size (%u) < " 883 "NTFS_BLOCK_SIZE (%i) is not " 884 "supported. Sorry.", 885 ni->itype.index.block_size, 886 NTFS_BLOCK_SIZE); 887 err = -EOPNOTSUPP; 888 goto unm_err_out; 889 } 890 ni->itype.index.block_size_bits = 891 ffs(ni->itype.index.block_size) - 1; 892 /* Determine the size of a vcn in the directory index. */ 893 if (vol->cluster_size <= ni->itype.index.block_size) { 894 ni->itype.index.vcn_size = vol->cluster_size; 895 ni->itype.index.vcn_size_bits = vol->cluster_size_bits; 896 } else { 897 ni->itype.index.vcn_size = vol->sector_size; 898 ni->itype.index.vcn_size_bits = vol->sector_size_bits; 899 } 900 901 /* Setup the index allocation attribute, even if not present. */ 902 NInoSetMstProtected(ni); 903 ni->type = AT_INDEX_ALLOCATION; 904 ni->name = I30; 905 ni->name_len = 4; 906 907 if (!(ir->index.flags & LARGE_INDEX)) { 908 /* No index allocation. */ 909 vi->i_size = ni->initialized_size = 910 ni->allocated_size = 0; 911 /* We are done with the mft record, so we release it. */ 912 ntfs_attr_put_search_ctx(ctx); 913 unmap_mft_record(ni); 914 m = NULL; 915 ctx = NULL; 916 goto skip_large_dir_stuff; 917 } /* LARGE_INDEX: Index allocation present. Setup state. */ 918 NInoSetIndexAllocPresent(ni); 919 /* Find index allocation attribute. */ 920 ntfs_attr_reinit_search_ctx(ctx); 921 err = ntfs_attr_lookup(AT_INDEX_ALLOCATION, I30, 4, 922 CASE_SENSITIVE, 0, NULL, 0, ctx); 923 if (unlikely(err)) { 924 if (err == -ENOENT) 925 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION " 926 "attribute is not present but " 927 "$INDEX_ROOT indicated it is."); 928 else 929 ntfs_error(vi->i_sb, "Failed to lookup " 930 "$INDEX_ALLOCATION " 931 "attribute."); 932 goto unm_err_out; 933 } 934 a = ctx->attr; 935 if (!a->non_resident) { 936 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute " 937 "is resident."); 938 goto unm_err_out; 939 } 940 /* 941 * Ensure the attribute name is placed before the mapping pairs 942 * array. 943 */ 944 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >= 945 le16_to_cpu( 946 a->data.non_resident.mapping_pairs_offset)))) { 947 ntfs_error(vol->sb, "$INDEX_ALLOCATION attribute name " 948 "is placed after the mapping pairs " 949 "array."); 950 goto unm_err_out; 951 } 952 if (a->flags & ATTR_IS_ENCRYPTED) { 953 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute " 954 "is encrypted."); 955 goto unm_err_out; 956 } 957 if (a->flags & ATTR_IS_SPARSE) { 958 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute " 959 "is sparse."); 960 goto unm_err_out; 961 } 962 if (a->flags & ATTR_COMPRESSION_MASK) { 963 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute " 964 "is compressed."); 965 goto unm_err_out; 966 } 967 if (a->data.non_resident.lowest_vcn) { 968 ntfs_error(vi->i_sb, "First extent of " 969 "$INDEX_ALLOCATION attribute has non " 970 "zero lowest_vcn."); 971 goto unm_err_out; 972 } 973 vi->i_size = sle64_to_cpu(a->data.non_resident.data_size); 974 ni->initialized_size = sle64_to_cpu( 975 a->data.non_resident.initialized_size); 976 ni->allocated_size = sle64_to_cpu( 977 a->data.non_resident.allocated_size); 978 /* 979 * We are done with the mft record, so we release it. Otherwise 980 * we would deadlock in ntfs_attr_iget(). 981 */ 982 ntfs_attr_put_search_ctx(ctx); 983 unmap_mft_record(ni); 984 m = NULL; 985 ctx = NULL; 986 /* Get the index bitmap attribute inode. */ 987 bvi = ntfs_attr_iget(vi, AT_BITMAP, I30, 4); 988 if (IS_ERR(bvi)) { 989 ntfs_error(vi->i_sb, "Failed to get bitmap attribute."); 990 err = PTR_ERR(bvi); 991 goto unm_err_out; 992 } 993 bni = NTFS_I(bvi); 994 if (NInoCompressed(bni) || NInoEncrypted(bni) || 995 NInoSparse(bni)) { 996 ntfs_error(vi->i_sb, "$BITMAP attribute is compressed " 997 "and/or encrypted and/or sparse."); 998 goto iput_unm_err_out; 999 } 1000 /* Consistency check bitmap size vs. index allocation size. */ 1001 bvi_size = i_size_read(bvi); 1002 if ((bvi_size << 3) < (vi->i_size >> 1003 ni->itype.index.block_size_bits)) { 1004 ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) " 1005 "for index allocation (0x%llx).", 1006 bvi_size << 3, vi->i_size); 1007 goto iput_unm_err_out; 1008 } 1009 /* No longer need the bitmap attribute inode. */ 1010 iput(bvi); 1011 skip_large_dir_stuff: 1012 /* Setup the operations for this inode. */ 1013 vi->i_op = &ntfs_dir_inode_ops; 1014 vi->i_fop = &ntfs_dir_ops; 1015 vi->i_mapping->a_ops = &ntfs_mst_aops; 1016 } else { 1017 /* It is a file. */ 1018 ntfs_attr_reinit_search_ctx(ctx); 1019 1020 /* Setup the data attribute, even if not present. */ 1021 ni->type = AT_DATA; 1022 ni->name = NULL; 1023 ni->name_len = 0; 1024 1025 /* Find first extent of the unnamed data attribute. */ 1026 err = ntfs_attr_lookup(AT_DATA, NULL, 0, 0, 0, NULL, 0, ctx); 1027 if (unlikely(err)) { 1028 vi->i_size = ni->initialized_size = 1029 ni->allocated_size = 0; 1030 if (err != -ENOENT) { 1031 ntfs_error(vi->i_sb, "Failed to lookup $DATA " 1032 "attribute."); 1033 goto unm_err_out; 1034 } 1035 /* 1036 * FILE_Secure does not have an unnamed $DATA 1037 * attribute, so we special case it here. 1038 */ 1039 if (vi->i_ino == FILE_Secure) 1040 goto no_data_attr_special_case; 1041 /* 1042 * Most if not all the system files in the $Extend 1043 * system directory do not have unnamed data 1044 * attributes so we need to check if the parent 1045 * directory of the file is FILE_Extend and if it is 1046 * ignore this error. To do this we need to get the 1047 * name of this inode from the mft record as the name 1048 * contains the back reference to the parent directory. 1049 */ 1050 if (ntfs_is_extended_system_file(ctx) > 0) 1051 goto no_data_attr_special_case; 1052 // FIXME: File is corrupt! Hot-fix with empty data 1053 // attribute if recovery option is set. 1054 ntfs_error(vi->i_sb, "$DATA attribute is missing."); 1055 goto unm_err_out; 1056 } 1057 a = ctx->attr; 1058 /* Setup the state. */ 1059 if (a->flags & (ATTR_COMPRESSION_MASK | ATTR_IS_SPARSE)) { 1060 if (a->flags & ATTR_COMPRESSION_MASK) { 1061 NInoSetCompressed(ni); 1062 if (vol->cluster_size > 4096) { 1063 ntfs_error(vi->i_sb, "Found " 1064 "compressed data but " 1065 "compression is " 1066 "disabled due to " 1067 "cluster size (%i) > " 1068 "4kiB.", 1069 vol->cluster_size); 1070 goto unm_err_out; 1071 } 1072 if ((a->flags & ATTR_COMPRESSION_MASK) 1073 != ATTR_IS_COMPRESSED) { 1074 ntfs_error(vi->i_sb, "Found unknown " 1075 "compression method " 1076 "or corrupt file."); 1077 goto unm_err_out; 1078 } 1079 } 1080 if (a->flags & ATTR_IS_SPARSE) 1081 NInoSetSparse(ni); 1082 } 1083 if (a->flags & ATTR_IS_ENCRYPTED) { 1084 if (NInoCompressed(ni)) { 1085 ntfs_error(vi->i_sb, "Found encrypted and " 1086 "compressed data."); 1087 goto unm_err_out; 1088 } 1089 NInoSetEncrypted(ni); 1090 } 1091 if (a->non_resident) { 1092 NInoSetNonResident(ni); 1093 if (NInoCompressed(ni) || NInoSparse(ni)) { 1094 if (NInoCompressed(ni) && a->data.non_resident. 1095 compression_unit != 4) { 1096 ntfs_error(vi->i_sb, "Found " 1097 "non-standard " 1098 "compression unit (%u " 1099 "instead of 4). " 1100 "Cannot handle this.", 1101 a->data.non_resident. 1102 compression_unit); 1103 err = -EOPNOTSUPP; 1104 goto unm_err_out; 1105 } 1106 if (a->data.non_resident.compression_unit) { 1107 ni->itype.compressed.block_size = 1U << 1108 (a->data.non_resident. 1109 compression_unit + 1110 vol->cluster_size_bits); 1111 ni->itype.compressed.block_size_bits = 1112 ffs(ni->itype. 1113 compressed. 1114 block_size) - 1; 1115 ni->itype.compressed.block_clusters = 1116 1U << a->data. 1117 non_resident. 1118 compression_unit; 1119 } else { 1120 ni->itype.compressed.block_size = 0; 1121 ni->itype.compressed.block_size_bits = 1122 0; 1123 ni->itype.compressed.block_clusters = 1124 0; 1125 } 1126 ni->itype.compressed.size = sle64_to_cpu( 1127 a->data.non_resident. 1128 compressed_size); 1129 } 1130 if (a->data.non_resident.lowest_vcn) { 1131 ntfs_error(vi->i_sb, "First extent of $DATA " 1132 "attribute has non zero " 1133 "lowest_vcn."); 1134 goto unm_err_out; 1135 } 1136 vi->i_size = sle64_to_cpu( 1137 a->data.non_resident.data_size); 1138 ni->initialized_size = sle64_to_cpu( 1139 a->data.non_resident.initialized_size); 1140 ni->allocated_size = sle64_to_cpu( 1141 a->data.non_resident.allocated_size); 1142 } else { /* Resident attribute. */ 1143 vi->i_size = ni->initialized_size = le32_to_cpu( 1144 a->data.resident.value_length); 1145 ni->allocated_size = le32_to_cpu(a->length) - 1146 le16_to_cpu( 1147 a->data.resident.value_offset); 1148 if (vi->i_size > ni->allocated_size) { 1149 ntfs_error(vi->i_sb, "Resident data attribute " 1150 "is corrupt (size exceeds " 1151 "allocation)."); 1152 goto unm_err_out; 1153 } 1154 } 1155 no_data_attr_special_case: 1156 /* We are done with the mft record, so we release it. */ 1157 ntfs_attr_put_search_ctx(ctx); 1158 unmap_mft_record(ni); 1159 m = NULL; 1160 ctx = NULL; 1161 /* Setup the operations for this inode. */ 1162 vi->i_op = &ntfs_file_inode_ops; 1163 vi->i_fop = &ntfs_file_ops; 1164 vi->i_mapping->a_ops = &ntfs_normal_aops; 1165 if (NInoMstProtected(ni)) 1166 vi->i_mapping->a_ops = &ntfs_mst_aops; 1167 else if (NInoCompressed(ni)) 1168 vi->i_mapping->a_ops = &ntfs_compressed_aops; 1169 } 1170 /* 1171 * The number of 512-byte blocks used on disk (for stat). This is in so 1172 * far inaccurate as it doesn't account for any named streams or other 1173 * special non-resident attributes, but that is how Windows works, too, 1174 * so we are at least consistent with Windows, if not entirely 1175 * consistent with the Linux Way. Doing it the Linux Way would cause a 1176 * significant slowdown as it would involve iterating over all 1177 * attributes in the mft record and adding the allocated/compressed 1178 * sizes of all non-resident attributes present to give us the Linux 1179 * correct size that should go into i_blocks (after division by 512). 1180 */ 1181 if (S_ISREG(vi->i_mode) && (NInoCompressed(ni) || NInoSparse(ni))) 1182 vi->i_blocks = ni->itype.compressed.size >> 9; 1183 else 1184 vi->i_blocks = ni->allocated_size >> 9; 1185 ntfs_debug("Done."); 1186 return 0; 1187 iput_unm_err_out: 1188 iput(bvi); 1189 unm_err_out: 1190 if (!err) 1191 err = -EIO; 1192 if (ctx) 1193 ntfs_attr_put_search_ctx(ctx); 1194 if (m) 1195 unmap_mft_record(ni); 1196 err_out: 1197 ntfs_error(vol->sb, "Failed with error code %i. Marking corrupt " 1198 "inode 0x%lx as bad. Run chkdsk.", err, vi->i_ino); 1199 make_bad_inode(vi); 1200 if (err != -EOPNOTSUPP && err != -ENOMEM) 1201 NVolSetErrors(vol); 1202 return err; 1203 } 1204 1205 /** 1206 * ntfs_read_locked_attr_inode - read an attribute inode from its base inode 1207 * @base_vi: base inode 1208 * @vi: attribute inode to read 1209 * 1210 * ntfs_read_locked_attr_inode() is called from ntfs_attr_iget() to read the 1211 * attribute inode described by @vi into memory from the base mft record 1212 * described by @base_ni. 1213 * 1214 * ntfs_read_locked_attr_inode() maps, pins and locks the base inode for 1215 * reading and looks up the attribute described by @vi before setting up the 1216 * necessary fields in @vi as well as initializing the ntfs inode. 1217 * 1218 * Q: What locks are held when the function is called? 1219 * A: i_state has I_NEW set, hence the inode is locked, also 1220 * i_count is set to 1, so it is not going to go away 1221 * 1222 * Return 0 on success and -errno on error. In the error case, the inode will 1223 * have had make_bad_inode() executed on it. 1224 * 1225 * Note this cannot be called for AT_INDEX_ALLOCATION. 1226 */ 1227 static int ntfs_read_locked_attr_inode(struct inode *base_vi, struct inode *vi) 1228 { 1229 ntfs_volume *vol = NTFS_SB(vi->i_sb); 1230 ntfs_inode *ni, *base_ni; 1231 MFT_RECORD *m; 1232 ATTR_RECORD *a; 1233 ntfs_attr_search_ctx *ctx; 1234 int err = 0; 1235 1236 ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino); 1237 1238 ntfs_init_big_inode(vi); 1239 1240 ni = NTFS_I(vi); 1241 base_ni = NTFS_I(base_vi); 1242 1243 /* Just mirror the values from the base inode. */ 1244 vi->i_version = base_vi->i_version; 1245 vi->i_uid = base_vi->i_uid; 1246 vi->i_gid = base_vi->i_gid; 1247 set_nlink(vi, base_vi->i_nlink); 1248 vi->i_mtime = base_vi->i_mtime; 1249 vi->i_ctime = base_vi->i_ctime; 1250 vi->i_atime = base_vi->i_atime; 1251 vi->i_generation = ni->seq_no = base_ni->seq_no; 1252 1253 /* Set inode type to zero but preserve permissions. */ 1254 vi->i_mode = base_vi->i_mode & ~S_IFMT; 1255 1256 m = map_mft_record(base_ni); 1257 if (IS_ERR(m)) { 1258 err = PTR_ERR(m); 1259 goto err_out; 1260 } 1261 ctx = ntfs_attr_get_search_ctx(base_ni, m); 1262 if (!ctx) { 1263 err = -ENOMEM; 1264 goto unm_err_out; 1265 } 1266 /* Find the attribute. */ 1267 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, 1268 CASE_SENSITIVE, 0, NULL, 0, ctx); 1269 if (unlikely(err)) 1270 goto unm_err_out; 1271 a = ctx->attr; 1272 if (a->flags & (ATTR_COMPRESSION_MASK | ATTR_IS_SPARSE)) { 1273 if (a->flags & ATTR_COMPRESSION_MASK) { 1274 NInoSetCompressed(ni); 1275 if ((ni->type != AT_DATA) || (ni->type == AT_DATA && 1276 ni->name_len)) { 1277 ntfs_error(vi->i_sb, "Found compressed " 1278 "non-data or named data " 1279 "attribute. Please report " 1280 "you saw this message to " 1281 "linux-ntfs-dev@lists." 1282 "sourceforge.net"); 1283 goto unm_err_out; 1284 } 1285 if (vol->cluster_size > 4096) { 1286 ntfs_error(vi->i_sb, "Found compressed " 1287 "attribute but compression is " 1288 "disabled due to cluster size " 1289 "(%i) > 4kiB.", 1290 vol->cluster_size); 1291 goto unm_err_out; 1292 } 1293 if ((a->flags & ATTR_COMPRESSION_MASK) != 1294 ATTR_IS_COMPRESSED) { 1295 ntfs_error(vi->i_sb, "Found unknown " 1296 "compression method."); 1297 goto unm_err_out; 1298 } 1299 } 1300 /* 1301 * The compressed/sparse flag set in an index root just means 1302 * to compress all files. 1303 */ 1304 if (NInoMstProtected(ni) && ni->type != AT_INDEX_ROOT) { 1305 ntfs_error(vi->i_sb, "Found mst protected attribute " 1306 "but the attribute is %s. Please " 1307 "report you saw this message to " 1308 "linux-ntfs-dev@lists.sourceforge.net", 1309 NInoCompressed(ni) ? "compressed" : 1310 "sparse"); 1311 goto unm_err_out; 1312 } 1313 if (a->flags & ATTR_IS_SPARSE) 1314 NInoSetSparse(ni); 1315 } 1316 if (a->flags & ATTR_IS_ENCRYPTED) { 1317 if (NInoCompressed(ni)) { 1318 ntfs_error(vi->i_sb, "Found encrypted and compressed " 1319 "data."); 1320 goto unm_err_out; 1321 } 1322 /* 1323 * The encryption flag set in an index root just means to 1324 * encrypt all files. 1325 */ 1326 if (NInoMstProtected(ni) && ni->type != AT_INDEX_ROOT) { 1327 ntfs_error(vi->i_sb, "Found mst protected attribute " 1328 "but the attribute is encrypted. " 1329 "Please report you saw this message " 1330 "to linux-ntfs-dev@lists.sourceforge." 1331 "net"); 1332 goto unm_err_out; 1333 } 1334 if (ni->type != AT_DATA) { 1335 ntfs_error(vi->i_sb, "Found encrypted non-data " 1336 "attribute."); 1337 goto unm_err_out; 1338 } 1339 NInoSetEncrypted(ni); 1340 } 1341 if (!a->non_resident) { 1342 /* Ensure the attribute name is placed before the value. */ 1343 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >= 1344 le16_to_cpu(a->data.resident.value_offset)))) { 1345 ntfs_error(vol->sb, "Attribute name is placed after " 1346 "the attribute value."); 1347 goto unm_err_out; 1348 } 1349 if (NInoMstProtected(ni)) { 1350 ntfs_error(vi->i_sb, "Found mst protected attribute " 1351 "but the attribute is resident. " 1352 "Please report you saw this message to " 1353 "linux-ntfs-dev@lists.sourceforge.net"); 1354 goto unm_err_out; 1355 } 1356 vi->i_size = ni->initialized_size = le32_to_cpu( 1357 a->data.resident.value_length); 1358 ni->allocated_size = le32_to_cpu(a->length) - 1359 le16_to_cpu(a->data.resident.value_offset); 1360 if (vi->i_size > ni->allocated_size) { 1361 ntfs_error(vi->i_sb, "Resident attribute is corrupt " 1362 "(size exceeds allocation)."); 1363 goto unm_err_out; 1364 } 1365 } else { 1366 NInoSetNonResident(ni); 1367 /* 1368 * Ensure the attribute name is placed before the mapping pairs 1369 * array. 1370 */ 1371 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >= 1372 le16_to_cpu( 1373 a->data.non_resident.mapping_pairs_offset)))) { 1374 ntfs_error(vol->sb, "Attribute name is placed after " 1375 "the mapping pairs array."); 1376 goto unm_err_out; 1377 } 1378 if (NInoCompressed(ni) || NInoSparse(ni)) { 1379 if (NInoCompressed(ni) && a->data.non_resident. 1380 compression_unit != 4) { 1381 ntfs_error(vi->i_sb, "Found non-standard " 1382 "compression unit (%u instead " 1383 "of 4). Cannot handle this.", 1384 a->data.non_resident. 1385 compression_unit); 1386 err = -EOPNOTSUPP; 1387 goto unm_err_out; 1388 } 1389 if (a->data.non_resident.compression_unit) { 1390 ni->itype.compressed.block_size = 1U << 1391 (a->data.non_resident. 1392 compression_unit + 1393 vol->cluster_size_bits); 1394 ni->itype.compressed.block_size_bits = 1395 ffs(ni->itype.compressed. 1396 block_size) - 1; 1397 ni->itype.compressed.block_clusters = 1U << 1398 a->data.non_resident. 1399 compression_unit; 1400 } else { 1401 ni->itype.compressed.block_size = 0; 1402 ni->itype.compressed.block_size_bits = 0; 1403 ni->itype.compressed.block_clusters = 0; 1404 } 1405 ni->itype.compressed.size = sle64_to_cpu( 1406 a->data.non_resident.compressed_size); 1407 } 1408 if (a->data.non_resident.lowest_vcn) { 1409 ntfs_error(vi->i_sb, "First extent of attribute has " 1410 "non-zero lowest_vcn."); 1411 goto unm_err_out; 1412 } 1413 vi->i_size = sle64_to_cpu(a->data.non_resident.data_size); 1414 ni->initialized_size = sle64_to_cpu( 1415 a->data.non_resident.initialized_size); 1416 ni->allocated_size = sle64_to_cpu( 1417 a->data.non_resident.allocated_size); 1418 } 1419 vi->i_mapping->a_ops = &ntfs_normal_aops; 1420 if (NInoMstProtected(ni)) 1421 vi->i_mapping->a_ops = &ntfs_mst_aops; 1422 else if (NInoCompressed(ni)) 1423 vi->i_mapping->a_ops = &ntfs_compressed_aops; 1424 if ((NInoCompressed(ni) || NInoSparse(ni)) && ni->type != AT_INDEX_ROOT) 1425 vi->i_blocks = ni->itype.compressed.size >> 9; 1426 else 1427 vi->i_blocks = ni->allocated_size >> 9; 1428 /* 1429 * Make sure the base inode does not go away and attach it to the 1430 * attribute inode. 1431 */ 1432 igrab(base_vi); 1433 ni->ext.base_ntfs_ino = base_ni; 1434 ni->nr_extents = -1; 1435 1436 ntfs_attr_put_search_ctx(ctx); 1437 unmap_mft_record(base_ni); 1438 1439 ntfs_debug("Done."); 1440 return 0; 1441 1442 unm_err_out: 1443 if (!err) 1444 err = -EIO; 1445 if (ctx) 1446 ntfs_attr_put_search_ctx(ctx); 1447 unmap_mft_record(base_ni); 1448 err_out: 1449 ntfs_error(vol->sb, "Failed with error code %i while reading attribute " 1450 "inode (mft_no 0x%lx, type 0x%x, name_len %i). " 1451 "Marking corrupt inode and base inode 0x%lx as bad. " 1452 "Run chkdsk.", err, vi->i_ino, ni->type, ni->name_len, 1453 base_vi->i_ino); 1454 make_bad_inode(vi); 1455 if (err != -ENOMEM) 1456 NVolSetErrors(vol); 1457 return err; 1458 } 1459 1460 /** 1461 * ntfs_read_locked_index_inode - read an index inode from its base inode 1462 * @base_vi: base inode 1463 * @vi: index inode to read 1464 * 1465 * ntfs_read_locked_index_inode() is called from ntfs_index_iget() to read the 1466 * index inode described by @vi into memory from the base mft record described 1467 * by @base_ni. 1468 * 1469 * ntfs_read_locked_index_inode() maps, pins and locks the base inode for 1470 * reading and looks up the attributes relating to the index described by @vi 1471 * before setting up the necessary fields in @vi as well as initializing the 1472 * ntfs inode. 1473 * 1474 * Note, index inodes are essentially attribute inodes (NInoAttr() is true) 1475 * with the attribute type set to AT_INDEX_ALLOCATION. Apart from that, they 1476 * are setup like directory inodes since directories are a special case of 1477 * indices ao they need to be treated in much the same way. Most importantly, 1478 * for small indices the index allocation attribute might not actually exist. 1479 * However, the index root attribute always exists but this does not need to 1480 * have an inode associated with it and this is why we define a new inode type 1481 * index. Also, like for directories, we need to have an attribute inode for 1482 * the bitmap attribute corresponding to the index allocation attribute and we 1483 * can store this in the appropriate field of the inode, just like we do for 1484 * normal directory inodes. 1485 * 1486 * Q: What locks are held when the function is called? 1487 * A: i_state has I_NEW set, hence the inode is locked, also 1488 * i_count is set to 1, so it is not going to go away 1489 * 1490 * Return 0 on success and -errno on error. In the error case, the inode will 1491 * have had make_bad_inode() executed on it. 1492 */ 1493 static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi) 1494 { 1495 loff_t bvi_size; 1496 ntfs_volume *vol = NTFS_SB(vi->i_sb); 1497 ntfs_inode *ni, *base_ni, *bni; 1498 struct inode *bvi; 1499 MFT_RECORD *m; 1500 ATTR_RECORD *a; 1501 ntfs_attr_search_ctx *ctx; 1502 INDEX_ROOT *ir; 1503 u8 *ir_end, *index_end; 1504 int err = 0; 1505 1506 ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino); 1507 ntfs_init_big_inode(vi); 1508 ni = NTFS_I(vi); 1509 base_ni = NTFS_I(base_vi); 1510 /* Just mirror the values from the base inode. */ 1511 vi->i_version = base_vi->i_version; 1512 vi->i_uid = base_vi->i_uid; 1513 vi->i_gid = base_vi->i_gid; 1514 set_nlink(vi, base_vi->i_nlink); 1515 vi->i_mtime = base_vi->i_mtime; 1516 vi->i_ctime = base_vi->i_ctime; 1517 vi->i_atime = base_vi->i_atime; 1518 vi->i_generation = ni->seq_no = base_ni->seq_no; 1519 /* Set inode type to zero but preserve permissions. */ 1520 vi->i_mode = base_vi->i_mode & ~S_IFMT; 1521 /* Map the mft record for the base inode. */ 1522 m = map_mft_record(base_ni); 1523 if (IS_ERR(m)) { 1524 err = PTR_ERR(m); 1525 goto err_out; 1526 } 1527 ctx = ntfs_attr_get_search_ctx(base_ni, m); 1528 if (!ctx) { 1529 err = -ENOMEM; 1530 goto unm_err_out; 1531 } 1532 /* Find the index root attribute. */ 1533 err = ntfs_attr_lookup(AT_INDEX_ROOT, ni->name, ni->name_len, 1534 CASE_SENSITIVE, 0, NULL, 0, ctx); 1535 if (unlikely(err)) { 1536 if (err == -ENOENT) 1537 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is " 1538 "missing."); 1539 goto unm_err_out; 1540 } 1541 a = ctx->attr; 1542 /* Set up the state. */ 1543 if (unlikely(a->non_resident)) { 1544 ntfs_error(vol->sb, "$INDEX_ROOT attribute is not resident."); 1545 goto unm_err_out; 1546 } 1547 /* Ensure the attribute name is placed before the value. */ 1548 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >= 1549 le16_to_cpu(a->data.resident.value_offset)))) { 1550 ntfs_error(vol->sb, "$INDEX_ROOT attribute name is placed " 1551 "after the attribute value."); 1552 goto unm_err_out; 1553 } 1554 /* 1555 * Compressed/encrypted/sparse index root is not allowed, except for 1556 * directories of course but those are not dealt with here. 1557 */ 1558 if (a->flags & (ATTR_COMPRESSION_MASK | ATTR_IS_ENCRYPTED | 1559 ATTR_IS_SPARSE)) { 1560 ntfs_error(vi->i_sb, "Found compressed/encrypted/sparse index " 1561 "root attribute."); 1562 goto unm_err_out; 1563 } 1564 ir = (INDEX_ROOT*)((u8*)a + le16_to_cpu(a->data.resident.value_offset)); 1565 ir_end = (u8*)ir + le32_to_cpu(a->data.resident.value_length); 1566 if (ir_end > (u8*)ctx->mrec + vol->mft_record_size) { 1567 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is corrupt."); 1568 goto unm_err_out; 1569 } 1570 index_end = (u8*)&ir->index + le32_to_cpu(ir->index.index_length); 1571 if (index_end > ir_end) { 1572 ntfs_error(vi->i_sb, "Index is corrupt."); 1573 goto unm_err_out; 1574 } 1575 if (ir->type) { 1576 ntfs_error(vi->i_sb, "Index type is not 0 (type is 0x%x).", 1577 le32_to_cpu(ir->type)); 1578 goto unm_err_out; 1579 } 1580 ni->itype.index.collation_rule = ir->collation_rule; 1581 ntfs_debug("Index collation rule is 0x%x.", 1582 le32_to_cpu(ir->collation_rule)); 1583 ni->itype.index.block_size = le32_to_cpu(ir->index_block_size); 1584 if (!is_power_of_2(ni->itype.index.block_size)) { 1585 ntfs_error(vi->i_sb, "Index block size (%u) is not a power of " 1586 "two.", ni->itype.index.block_size); 1587 goto unm_err_out; 1588 } 1589 if (ni->itype.index.block_size > PAGE_CACHE_SIZE) { 1590 ntfs_error(vi->i_sb, "Index block size (%u) > PAGE_CACHE_SIZE " 1591 "(%ld) is not supported. Sorry.", 1592 ni->itype.index.block_size, PAGE_CACHE_SIZE); 1593 err = -EOPNOTSUPP; 1594 goto unm_err_out; 1595 } 1596 if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) { 1597 ntfs_error(vi->i_sb, "Index block size (%u) < NTFS_BLOCK_SIZE " 1598 "(%i) is not supported. Sorry.", 1599 ni->itype.index.block_size, NTFS_BLOCK_SIZE); 1600 err = -EOPNOTSUPP; 1601 goto unm_err_out; 1602 } 1603 ni->itype.index.block_size_bits = ffs(ni->itype.index.block_size) - 1; 1604 /* Determine the size of a vcn in the index. */ 1605 if (vol->cluster_size <= ni->itype.index.block_size) { 1606 ni->itype.index.vcn_size = vol->cluster_size; 1607 ni->itype.index.vcn_size_bits = vol->cluster_size_bits; 1608 } else { 1609 ni->itype.index.vcn_size = vol->sector_size; 1610 ni->itype.index.vcn_size_bits = vol->sector_size_bits; 1611 } 1612 /* Check for presence of index allocation attribute. */ 1613 if (!(ir->index.flags & LARGE_INDEX)) { 1614 /* No index allocation. */ 1615 vi->i_size = ni->initialized_size = ni->allocated_size = 0; 1616 /* We are done with the mft record, so we release it. */ 1617 ntfs_attr_put_search_ctx(ctx); 1618 unmap_mft_record(base_ni); 1619 m = NULL; 1620 ctx = NULL; 1621 goto skip_large_index_stuff; 1622 } /* LARGE_INDEX: Index allocation present. Setup state. */ 1623 NInoSetIndexAllocPresent(ni); 1624 /* Find index allocation attribute. */ 1625 ntfs_attr_reinit_search_ctx(ctx); 1626 err = ntfs_attr_lookup(AT_INDEX_ALLOCATION, ni->name, ni->name_len, 1627 CASE_SENSITIVE, 0, NULL, 0, ctx); 1628 if (unlikely(err)) { 1629 if (err == -ENOENT) 1630 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is " 1631 "not present but $INDEX_ROOT " 1632 "indicated it is."); 1633 else 1634 ntfs_error(vi->i_sb, "Failed to lookup " 1635 "$INDEX_ALLOCATION attribute."); 1636 goto unm_err_out; 1637 } 1638 a = ctx->attr; 1639 if (!a->non_resident) { 1640 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is " 1641 "resident."); 1642 goto unm_err_out; 1643 } 1644 /* 1645 * Ensure the attribute name is placed before the mapping pairs array. 1646 */ 1647 if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >= 1648 le16_to_cpu( 1649 a->data.non_resident.mapping_pairs_offset)))) { 1650 ntfs_error(vol->sb, "$INDEX_ALLOCATION attribute name is " 1651 "placed after the mapping pairs array."); 1652 goto unm_err_out; 1653 } 1654 if (a->flags & ATTR_IS_ENCRYPTED) { 1655 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is " 1656 "encrypted."); 1657 goto unm_err_out; 1658 } 1659 if (a->flags & ATTR_IS_SPARSE) { 1660 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is sparse."); 1661 goto unm_err_out; 1662 } 1663 if (a->flags & ATTR_COMPRESSION_MASK) { 1664 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is " 1665 "compressed."); 1666 goto unm_err_out; 1667 } 1668 if (a->data.non_resident.lowest_vcn) { 1669 ntfs_error(vi->i_sb, "First extent of $INDEX_ALLOCATION " 1670 "attribute has non zero lowest_vcn."); 1671 goto unm_err_out; 1672 } 1673 vi->i_size = sle64_to_cpu(a->data.non_resident.data_size); 1674 ni->initialized_size = sle64_to_cpu( 1675 a->data.non_resident.initialized_size); 1676 ni->allocated_size = sle64_to_cpu(a->data.non_resident.allocated_size); 1677 /* 1678 * We are done with the mft record, so we release it. Otherwise 1679 * we would deadlock in ntfs_attr_iget(). 1680 */ 1681 ntfs_attr_put_search_ctx(ctx); 1682 unmap_mft_record(base_ni); 1683 m = NULL; 1684 ctx = NULL; 1685 /* Get the index bitmap attribute inode. */ 1686 bvi = ntfs_attr_iget(base_vi, AT_BITMAP, ni->name, ni->name_len); 1687 if (IS_ERR(bvi)) { 1688 ntfs_error(vi->i_sb, "Failed to get bitmap attribute."); 1689 err = PTR_ERR(bvi); 1690 goto unm_err_out; 1691 } 1692 bni = NTFS_I(bvi); 1693 if (NInoCompressed(bni) || NInoEncrypted(bni) || 1694 NInoSparse(bni)) { 1695 ntfs_error(vi->i_sb, "$BITMAP attribute is compressed and/or " 1696 "encrypted and/or sparse."); 1697 goto iput_unm_err_out; 1698 } 1699 /* Consistency check bitmap size vs. index allocation size. */ 1700 bvi_size = i_size_read(bvi); 1701 if ((bvi_size << 3) < (vi->i_size >> ni->itype.index.block_size_bits)) { 1702 ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) for " 1703 "index allocation (0x%llx).", bvi_size << 3, 1704 vi->i_size); 1705 goto iput_unm_err_out; 1706 } 1707 iput(bvi); 1708 skip_large_index_stuff: 1709 /* Setup the operations for this index inode. */ 1710 vi->i_mapping->a_ops = &ntfs_mst_aops; 1711 vi->i_blocks = ni->allocated_size >> 9; 1712 /* 1713 * Make sure the base inode doesn't go away and attach it to the 1714 * index inode. 1715 */ 1716 igrab(base_vi); 1717 ni->ext.base_ntfs_ino = base_ni; 1718 ni->nr_extents = -1; 1719 1720 ntfs_debug("Done."); 1721 return 0; 1722 iput_unm_err_out: 1723 iput(bvi); 1724 unm_err_out: 1725 if (!err) 1726 err = -EIO; 1727 if (ctx) 1728 ntfs_attr_put_search_ctx(ctx); 1729 if (m) 1730 unmap_mft_record(base_ni); 1731 err_out: 1732 ntfs_error(vi->i_sb, "Failed with error code %i while reading index " 1733 "inode (mft_no 0x%lx, name_len %i.", err, vi->i_ino, 1734 ni->name_len); 1735 make_bad_inode(vi); 1736 if (err != -EOPNOTSUPP && err != -ENOMEM) 1737 NVolSetErrors(vol); 1738 return err; 1739 } 1740 1741 /* 1742 * The MFT inode has special locking, so teach the lock validator 1743 * about this by splitting off the locking rules of the MFT from 1744 * the locking rules of other inodes. The MFT inode can never be 1745 * accessed from the VFS side (or even internally), only by the 1746 * map_mft functions. 1747 */ 1748 static struct lock_class_key mft_ni_runlist_lock_key, mft_ni_mrec_lock_key; 1749 1750 /** 1751 * ntfs_read_inode_mount - special read_inode for mount time use only 1752 * @vi: inode to read 1753 * 1754 * Read inode FILE_MFT at mount time, only called with super_block lock 1755 * held from within the read_super() code path. 1756 * 1757 * This function exists because when it is called the page cache for $MFT/$DATA 1758 * is not initialized and hence we cannot get at the contents of mft records 1759 * by calling map_mft_record*(). 1760 * 1761 * Further it needs to cope with the circular references problem, i.e. cannot 1762 * load any attributes other than $ATTRIBUTE_LIST until $DATA is loaded, because 1763 * we do not know where the other extent mft records are yet and again, because 1764 * we cannot call map_mft_record*() yet. Obviously this applies only when an 1765 * attribute list is actually present in $MFT inode. 1766 * 1767 * We solve these problems by starting with the $DATA attribute before anything 1768 * else and iterating using ntfs_attr_lookup($DATA) over all extents. As each 1769 * extent is found, we ntfs_mapping_pairs_decompress() including the implied 1770 * ntfs_runlists_merge(). Each step of the iteration necessarily provides 1771 * sufficient information for the next step to complete. 1772 * 1773 * This should work but there are two possible pit falls (see inline comments 1774 * below), but only time will tell if they are real pits or just smoke... 1775 */ 1776 int ntfs_read_inode_mount(struct inode *vi) 1777 { 1778 VCN next_vcn, last_vcn, highest_vcn; 1779 s64 block; 1780 struct super_block *sb = vi->i_sb; 1781 ntfs_volume *vol = NTFS_SB(sb); 1782 struct buffer_head *bh; 1783 ntfs_inode *ni; 1784 MFT_RECORD *m = NULL; 1785 ATTR_RECORD *a; 1786 ntfs_attr_search_ctx *ctx; 1787 unsigned int i, nr_blocks; 1788 int err; 1789 1790 ntfs_debug("Entering."); 1791 1792 /* Initialize the ntfs specific part of @vi. */ 1793 ntfs_init_big_inode(vi); 1794 1795 ni = NTFS_I(vi); 1796 1797 /* Setup the data attribute. It is special as it is mst protected. */ 1798 NInoSetNonResident(ni); 1799 NInoSetMstProtected(ni); 1800 NInoSetSparseDisabled(ni); 1801 ni->type = AT_DATA; 1802 ni->name = NULL; 1803 ni->name_len = 0; 1804 /* 1805 * This sets up our little cheat allowing us to reuse the async read io 1806 * completion handler for directories. 1807 */ 1808 ni->itype.index.block_size = vol->mft_record_size; 1809 ni->itype.index.block_size_bits = vol->mft_record_size_bits; 1810 1811 /* Very important! Needed to be able to call map_mft_record*(). */ 1812 vol->mft_ino = vi; 1813 1814 /* Allocate enough memory to read the first mft record. */ 1815 if (vol->mft_record_size > 64 * 1024) { 1816 ntfs_error(sb, "Unsupported mft record size %i (max 64kiB).", 1817 vol->mft_record_size); 1818 goto err_out; 1819 } 1820 i = vol->mft_record_size; 1821 if (i < sb->s_blocksize) 1822 i = sb->s_blocksize; 1823 m = (MFT_RECORD*)ntfs_malloc_nofs(i); 1824 if (!m) { 1825 ntfs_error(sb, "Failed to allocate buffer for $MFT record 0."); 1826 goto err_out; 1827 } 1828 1829 /* Determine the first block of the $MFT/$DATA attribute. */ 1830 block = vol->mft_lcn << vol->cluster_size_bits >> 1831 sb->s_blocksize_bits; 1832 nr_blocks = vol->mft_record_size >> sb->s_blocksize_bits; 1833 if (!nr_blocks) 1834 nr_blocks = 1; 1835 1836 /* Load $MFT/$DATA's first mft record. */ 1837 for (i = 0; i < nr_blocks; i++) { 1838 bh = sb_bread(sb, block++); 1839 if (!bh) { 1840 ntfs_error(sb, "Device read failed."); 1841 goto err_out; 1842 } 1843 memcpy((char*)m + (i << sb->s_blocksize_bits), bh->b_data, 1844 sb->s_blocksize); 1845 brelse(bh); 1846 } 1847 1848 /* Apply the mst fixups. */ 1849 if (post_read_mst_fixup((NTFS_RECORD*)m, vol->mft_record_size)) { 1850 /* FIXME: Try to use the $MFTMirr now. */ 1851 ntfs_error(sb, "MST fixup failed. $MFT is corrupt."); 1852 goto err_out; 1853 } 1854 1855 /* Need this to sanity check attribute list references to $MFT. */ 1856 vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number); 1857 1858 /* Provides readpage() and sync_page() for map_mft_record(). */ 1859 vi->i_mapping->a_ops = &ntfs_mst_aops; 1860 1861 ctx = ntfs_attr_get_search_ctx(ni, m); 1862 if (!ctx) { 1863 err = -ENOMEM; 1864 goto err_out; 1865 } 1866 1867 /* Find the attribute list attribute if present. */ 1868 err = ntfs_attr_lookup(AT_ATTRIBUTE_LIST, NULL, 0, 0, 0, NULL, 0, ctx); 1869 if (err) { 1870 if (unlikely(err != -ENOENT)) { 1871 ntfs_error(sb, "Failed to lookup attribute list " 1872 "attribute. You should run chkdsk."); 1873 goto put_err_out; 1874 } 1875 } else /* if (!err) */ { 1876 ATTR_LIST_ENTRY *al_entry, *next_al_entry; 1877 u8 *al_end; 1878 static const char *es = " Not allowed. $MFT is corrupt. " 1879 "You should run chkdsk."; 1880 1881 ntfs_debug("Attribute list attribute found in $MFT."); 1882 NInoSetAttrList(ni); 1883 a = ctx->attr; 1884 if (a->flags & ATTR_COMPRESSION_MASK) { 1885 ntfs_error(sb, "Attribute list attribute is " 1886 "compressed.%s", es); 1887 goto put_err_out; 1888 } 1889 if (a->flags & ATTR_IS_ENCRYPTED || 1890 a->flags & ATTR_IS_SPARSE) { 1891 if (a->non_resident) { 1892 ntfs_error(sb, "Non-resident attribute list " 1893 "attribute is encrypted/" 1894 "sparse.%s", es); 1895 goto put_err_out; 1896 } 1897 ntfs_warning(sb, "Resident attribute list attribute " 1898 "in $MFT system file is marked " 1899 "encrypted/sparse which is not true. " 1900 "However, Windows allows this and " 1901 "chkdsk does not detect or correct it " 1902 "so we will just ignore the invalid " 1903 "flags and pretend they are not set."); 1904 } 1905 /* Now allocate memory for the attribute list. */ 1906 ni->attr_list_size = (u32)ntfs_attr_size(a); 1907 ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size); 1908 if (!ni->attr_list) { 1909 ntfs_error(sb, "Not enough memory to allocate buffer " 1910 "for attribute list."); 1911 goto put_err_out; 1912 } 1913 if (a->non_resident) { 1914 NInoSetAttrListNonResident(ni); 1915 if (a->data.non_resident.lowest_vcn) { 1916 ntfs_error(sb, "Attribute list has non zero " 1917 "lowest_vcn. $MFT is corrupt. " 1918 "You should run chkdsk."); 1919 goto put_err_out; 1920 } 1921 /* Setup the runlist. */ 1922 ni->attr_list_rl.rl = ntfs_mapping_pairs_decompress(vol, 1923 a, NULL); 1924 if (IS_ERR(ni->attr_list_rl.rl)) { 1925 err = PTR_ERR(ni->attr_list_rl.rl); 1926 ni->attr_list_rl.rl = NULL; 1927 ntfs_error(sb, "Mapping pairs decompression " 1928 "failed with error code %i.", 1929 -err); 1930 goto put_err_out; 1931 } 1932 /* Now load the attribute list. */ 1933 if ((err = load_attribute_list(vol, &ni->attr_list_rl, 1934 ni->attr_list, ni->attr_list_size, 1935 sle64_to_cpu(a->data. 1936 non_resident.initialized_size)))) { 1937 ntfs_error(sb, "Failed to load attribute list " 1938 "attribute with error code %i.", 1939 -err); 1940 goto put_err_out; 1941 } 1942 } else /* if (!ctx.attr->non_resident) */ { 1943 if ((u8*)a + le16_to_cpu( 1944 a->data.resident.value_offset) + 1945 le32_to_cpu( 1946 a->data.resident.value_length) > 1947 (u8*)ctx->mrec + vol->mft_record_size) { 1948 ntfs_error(sb, "Corrupt attribute list " 1949 "attribute."); 1950 goto put_err_out; 1951 } 1952 /* Now copy the attribute list. */ 1953 memcpy(ni->attr_list, (u8*)a + le16_to_cpu( 1954 a->data.resident.value_offset), 1955 le32_to_cpu( 1956 a->data.resident.value_length)); 1957 } 1958 /* The attribute list is now setup in memory. */ 1959 /* 1960 * FIXME: I don't know if this case is actually possible. 1961 * According to logic it is not possible but I have seen too 1962 * many weird things in MS software to rely on logic... Thus we 1963 * perform a manual search and make sure the first $MFT/$DATA 1964 * extent is in the base inode. If it is not we abort with an 1965 * error and if we ever see a report of this error we will need 1966 * to do some magic in order to have the necessary mft record 1967 * loaded and in the right place in the page cache. But 1968 * hopefully logic will prevail and this never happens... 1969 */ 1970 al_entry = (ATTR_LIST_ENTRY*)ni->attr_list; 1971 al_end = (u8*)al_entry + ni->attr_list_size; 1972 for (;; al_entry = next_al_entry) { 1973 /* Out of bounds check. */ 1974 if ((u8*)al_entry < ni->attr_list || 1975 (u8*)al_entry > al_end) 1976 goto em_put_err_out; 1977 /* Catch the end of the attribute list. */ 1978 if ((u8*)al_entry == al_end) 1979 goto em_put_err_out; 1980 if (!al_entry->length) 1981 goto em_put_err_out; 1982 if ((u8*)al_entry + 6 > al_end || (u8*)al_entry + 1983 le16_to_cpu(al_entry->length) > al_end) 1984 goto em_put_err_out; 1985 next_al_entry = (ATTR_LIST_ENTRY*)((u8*)al_entry + 1986 le16_to_cpu(al_entry->length)); 1987 if (le32_to_cpu(al_entry->type) > le32_to_cpu(AT_DATA)) 1988 goto em_put_err_out; 1989 if (AT_DATA != al_entry->type) 1990 continue; 1991 /* We want an unnamed attribute. */ 1992 if (al_entry->name_length) 1993 goto em_put_err_out; 1994 /* Want the first entry, i.e. lowest_vcn == 0. */ 1995 if (al_entry->lowest_vcn) 1996 goto em_put_err_out; 1997 /* First entry has to be in the base mft record. */ 1998 if (MREF_LE(al_entry->mft_reference) != vi->i_ino) { 1999 /* MFT references do not match, logic fails. */ 2000 ntfs_error(sb, "BUG: The first $DATA extent " 2001 "of $MFT is not in the base " 2002 "mft record. Please report " 2003 "you saw this message to " 2004 "linux-ntfs-dev@lists." 2005 "sourceforge.net"); 2006 goto put_err_out; 2007 } else { 2008 /* Sequence numbers must match. */ 2009 if (MSEQNO_LE(al_entry->mft_reference) != 2010 ni->seq_no) 2011 goto em_put_err_out; 2012 /* Got it. All is ok. We can stop now. */ 2013 break; 2014 } 2015 } 2016 } 2017 2018 ntfs_attr_reinit_search_ctx(ctx); 2019 2020 /* Now load all attribute extents. */ 2021 a = NULL; 2022 next_vcn = last_vcn = highest_vcn = 0; 2023 while (!(err = ntfs_attr_lookup(AT_DATA, NULL, 0, 0, next_vcn, NULL, 0, 2024 ctx))) { 2025 runlist_element *nrl; 2026 2027 /* Cache the current attribute. */ 2028 a = ctx->attr; 2029 /* $MFT must be non-resident. */ 2030 if (!a->non_resident) { 2031 ntfs_error(sb, "$MFT must be non-resident but a " 2032 "resident extent was found. $MFT is " 2033 "corrupt. Run chkdsk."); 2034 goto put_err_out; 2035 } 2036 /* $MFT must be uncompressed and unencrypted. */ 2037 if (a->flags & ATTR_COMPRESSION_MASK || 2038 a->flags & ATTR_IS_ENCRYPTED || 2039 a->flags & ATTR_IS_SPARSE) { 2040 ntfs_error(sb, "$MFT must be uncompressed, " 2041 "non-sparse, and unencrypted but a " 2042 "compressed/sparse/encrypted extent " 2043 "was found. $MFT is corrupt. Run " 2044 "chkdsk."); 2045 goto put_err_out; 2046 } 2047 /* 2048 * Decompress the mapping pairs array of this extent and merge 2049 * the result into the existing runlist. No need for locking 2050 * as we have exclusive access to the inode at this time and we 2051 * are a mount in progress task, too. 2052 */ 2053 nrl = ntfs_mapping_pairs_decompress(vol, a, ni->runlist.rl); 2054 if (IS_ERR(nrl)) { 2055 ntfs_error(sb, "ntfs_mapping_pairs_decompress() " 2056 "failed with error code %ld. $MFT is " 2057 "corrupt.", PTR_ERR(nrl)); 2058 goto put_err_out; 2059 } 2060 ni->runlist.rl = nrl; 2061 2062 /* Are we in the first extent? */ 2063 if (!next_vcn) { 2064 if (a->data.non_resident.lowest_vcn) { 2065 ntfs_error(sb, "First extent of $DATA " 2066 "attribute has non zero " 2067 "lowest_vcn. $MFT is corrupt. " 2068 "You should run chkdsk."); 2069 goto put_err_out; 2070 } 2071 /* Get the last vcn in the $DATA attribute. */ 2072 last_vcn = sle64_to_cpu( 2073 a->data.non_resident.allocated_size) 2074 >> vol->cluster_size_bits; 2075 /* Fill in the inode size. */ 2076 vi->i_size = sle64_to_cpu( 2077 a->data.non_resident.data_size); 2078 ni->initialized_size = sle64_to_cpu( 2079 a->data.non_resident.initialized_size); 2080 ni->allocated_size = sle64_to_cpu( 2081 a->data.non_resident.allocated_size); 2082 /* 2083 * Verify the number of mft records does not exceed 2084 * 2^32 - 1. 2085 */ 2086 if ((vi->i_size >> vol->mft_record_size_bits) >= 2087 (1ULL << 32)) { 2088 ntfs_error(sb, "$MFT is too big! Aborting."); 2089 goto put_err_out; 2090 } 2091 /* 2092 * We have got the first extent of the runlist for 2093 * $MFT which means it is now relatively safe to call 2094 * the normal ntfs_read_inode() function. 2095 * Complete reading the inode, this will actually 2096 * re-read the mft record for $MFT, this time entering 2097 * it into the page cache with which we complete the 2098 * kick start of the volume. It should be safe to do 2099 * this now as the first extent of $MFT/$DATA is 2100 * already known and we would hope that we don't need 2101 * further extents in order to find the other 2102 * attributes belonging to $MFT. Only time will tell if 2103 * this is really the case. If not we will have to play 2104 * magic at this point, possibly duplicating a lot of 2105 * ntfs_read_inode() at this point. We will need to 2106 * ensure we do enough of its work to be able to call 2107 * ntfs_read_inode() on extents of $MFT/$DATA. But lets 2108 * hope this never happens... 2109 */ 2110 ntfs_read_locked_inode(vi); 2111 if (is_bad_inode(vi)) { 2112 ntfs_error(sb, "ntfs_read_inode() of $MFT " 2113 "failed. BUG or corrupt $MFT. " 2114 "Run chkdsk and if no errors " 2115 "are found, please report you " 2116 "saw this message to " 2117 "linux-ntfs-dev@lists." 2118 "sourceforge.net"); 2119 ntfs_attr_put_search_ctx(ctx); 2120 /* Revert to the safe super operations. */ 2121 ntfs_free(m); 2122 return -1; 2123 } 2124 /* 2125 * Re-initialize some specifics about $MFT's inode as 2126 * ntfs_read_inode() will have set up the default ones. 2127 */ 2128 /* Set uid and gid to root. */ 2129 vi->i_uid = GLOBAL_ROOT_UID; 2130 vi->i_gid = GLOBAL_ROOT_GID; 2131 /* Regular file. No access for anyone. */ 2132 vi->i_mode = S_IFREG; 2133 /* No VFS initiated operations allowed for $MFT. */ 2134 vi->i_op = &ntfs_empty_inode_ops; 2135 vi->i_fop = &ntfs_empty_file_ops; 2136 } 2137 2138 /* Get the lowest vcn for the next extent. */ 2139 highest_vcn = sle64_to_cpu(a->data.non_resident.highest_vcn); 2140 next_vcn = highest_vcn + 1; 2141 2142 /* Only one extent or error, which we catch below. */ 2143 if (next_vcn <= 0) 2144 break; 2145 2146 /* Avoid endless loops due to corruption. */ 2147 if (next_vcn < sle64_to_cpu( 2148 a->data.non_resident.lowest_vcn)) { 2149 ntfs_error(sb, "$MFT has corrupt attribute list " 2150 "attribute. Run chkdsk."); 2151 goto put_err_out; 2152 } 2153 } 2154 if (err != -ENOENT) { 2155 ntfs_error(sb, "Failed to lookup $MFT/$DATA attribute extent. " 2156 "$MFT is corrupt. Run chkdsk."); 2157 goto put_err_out; 2158 } 2159 if (!a) { 2160 ntfs_error(sb, "$MFT/$DATA attribute not found. $MFT is " 2161 "corrupt. Run chkdsk."); 2162 goto put_err_out; 2163 } 2164 if (highest_vcn && highest_vcn != last_vcn - 1) { 2165 ntfs_error(sb, "Failed to load the complete runlist for " 2166 "$MFT/$DATA. Driver bug or corrupt $MFT. " 2167 "Run chkdsk."); 2168 ntfs_debug("highest_vcn = 0x%llx, last_vcn - 1 = 0x%llx", 2169 (unsigned long long)highest_vcn, 2170 (unsigned long long)last_vcn - 1); 2171 goto put_err_out; 2172 } 2173 ntfs_attr_put_search_ctx(ctx); 2174 ntfs_debug("Done."); 2175 ntfs_free(m); 2176 2177 /* 2178 * Split the locking rules of the MFT inode from the 2179 * locking rules of other inodes: 2180 */ 2181 lockdep_set_class(&ni->runlist.lock, &mft_ni_runlist_lock_key); 2182 lockdep_set_class(&ni->mrec_lock, &mft_ni_mrec_lock_key); 2183 2184 return 0; 2185 2186 em_put_err_out: 2187 ntfs_error(sb, "Couldn't find first extent of $DATA attribute in " 2188 "attribute list. $MFT is corrupt. Run chkdsk."); 2189 put_err_out: 2190 ntfs_attr_put_search_ctx(ctx); 2191 err_out: 2192 ntfs_error(sb, "Failed. Marking inode as bad."); 2193 make_bad_inode(vi); 2194 ntfs_free(m); 2195 return -1; 2196 } 2197 2198 static void __ntfs_clear_inode(ntfs_inode *ni) 2199 { 2200 /* Free all alocated memory. */ 2201 down_write(&ni->runlist.lock); 2202 if (ni->runlist.rl) { 2203 ntfs_free(ni->runlist.rl); 2204 ni->runlist.rl = NULL; 2205 } 2206 up_write(&ni->runlist.lock); 2207 2208 if (ni->attr_list) { 2209 ntfs_free(ni->attr_list); 2210 ni->attr_list = NULL; 2211 } 2212 2213 down_write(&ni->attr_list_rl.lock); 2214 if (ni->attr_list_rl.rl) { 2215 ntfs_free(ni->attr_list_rl.rl); 2216 ni->attr_list_rl.rl = NULL; 2217 } 2218 up_write(&ni->attr_list_rl.lock); 2219 2220 if (ni->name_len && ni->name != I30) { 2221 /* Catch bugs... */ 2222 BUG_ON(!ni->name); 2223 kfree(ni->name); 2224 } 2225 } 2226 2227 void ntfs_clear_extent_inode(ntfs_inode *ni) 2228 { 2229 ntfs_debug("Entering for inode 0x%lx.", ni->mft_no); 2230 2231 BUG_ON(NInoAttr(ni)); 2232 BUG_ON(ni->nr_extents != -1); 2233 2234 #ifdef NTFS_RW 2235 if (NInoDirty(ni)) { 2236 if (!is_bad_inode(VFS_I(ni->ext.base_ntfs_ino))) 2237 ntfs_error(ni->vol->sb, "Clearing dirty extent inode! " 2238 "Losing data! This is a BUG!!!"); 2239 // FIXME: Do something!!! 2240 } 2241 #endif /* NTFS_RW */ 2242 2243 __ntfs_clear_inode(ni); 2244 2245 /* Bye, bye... */ 2246 ntfs_destroy_extent_inode(ni); 2247 } 2248 2249 /** 2250 * ntfs_evict_big_inode - clean up the ntfs specific part of an inode 2251 * @vi: vfs inode pending annihilation 2252 * 2253 * When the VFS is going to remove an inode from memory, ntfs_clear_big_inode() 2254 * is called, which deallocates all memory belonging to the NTFS specific part 2255 * of the inode and returns. 2256 * 2257 * If the MFT record is dirty, we commit it before doing anything else. 2258 */ 2259 void ntfs_evict_big_inode(struct inode *vi) 2260 { 2261 ntfs_inode *ni = NTFS_I(vi); 2262 2263 truncate_inode_pages_final(&vi->i_data); 2264 clear_inode(vi); 2265 2266 #ifdef NTFS_RW 2267 if (NInoDirty(ni)) { 2268 bool was_bad = (is_bad_inode(vi)); 2269 2270 /* Committing the inode also commits all extent inodes. */ 2271 ntfs_commit_inode(vi); 2272 2273 if (!was_bad && (is_bad_inode(vi) || NInoDirty(ni))) { 2274 ntfs_error(vi->i_sb, "Failed to commit dirty inode " 2275 "0x%lx. Losing data!", vi->i_ino); 2276 // FIXME: Do something!!! 2277 } 2278 } 2279 #endif /* NTFS_RW */ 2280 2281 /* No need to lock at this stage as no one else has a reference. */ 2282 if (ni->nr_extents > 0) { 2283 int i; 2284 2285 for (i = 0; i < ni->nr_extents; i++) 2286 ntfs_clear_extent_inode(ni->ext.extent_ntfs_inos[i]); 2287 kfree(ni->ext.extent_ntfs_inos); 2288 } 2289 2290 __ntfs_clear_inode(ni); 2291 2292 if (NInoAttr(ni)) { 2293 /* Release the base inode if we are holding it. */ 2294 if (ni->nr_extents == -1) { 2295 iput(VFS_I(ni->ext.base_ntfs_ino)); 2296 ni->nr_extents = 0; 2297 ni->ext.base_ntfs_ino = NULL; 2298 } 2299 } 2300 return; 2301 } 2302 2303 /** 2304 * ntfs_show_options - show mount options in /proc/mounts 2305 * @sf: seq_file in which to write our mount options 2306 * @root: root of the mounted tree whose mount options to display 2307 * 2308 * Called by the VFS once for each mounted ntfs volume when someone reads 2309 * /proc/mounts in order to display the NTFS specific mount options of each 2310 * mount. The mount options of fs specified by @root are written to the seq file 2311 * @sf and success is returned. 2312 */ 2313 int ntfs_show_options(struct seq_file *sf, struct dentry *root) 2314 { 2315 ntfs_volume *vol = NTFS_SB(root->d_sb); 2316 int i; 2317 2318 seq_printf(sf, ",uid=%i", from_kuid_munged(&init_user_ns, vol->uid)); 2319 seq_printf(sf, ",gid=%i", from_kgid_munged(&init_user_ns, vol->gid)); 2320 if (vol->fmask == vol->dmask) 2321 seq_printf(sf, ",umask=0%o", vol->fmask); 2322 else { 2323 seq_printf(sf, ",fmask=0%o", vol->fmask); 2324 seq_printf(sf, ",dmask=0%o", vol->dmask); 2325 } 2326 seq_printf(sf, ",nls=%s", vol->nls_map->charset); 2327 if (NVolCaseSensitive(vol)) 2328 seq_printf(sf, ",case_sensitive"); 2329 if (NVolShowSystemFiles(vol)) 2330 seq_printf(sf, ",show_sys_files"); 2331 if (!NVolSparseEnabled(vol)) 2332 seq_printf(sf, ",disable_sparse"); 2333 for (i = 0; on_errors_arr[i].val; i++) { 2334 if (on_errors_arr[i].val & vol->on_errors) 2335 seq_printf(sf, ",errors=%s", on_errors_arr[i].str); 2336 } 2337 seq_printf(sf, ",mft_zone_multiplier=%i", vol->mft_zone_multiplier); 2338 return 0; 2339 } 2340 2341 #ifdef NTFS_RW 2342 2343 static const char *es = " Leaving inconsistent metadata. Unmount and run " 2344 "chkdsk."; 2345 2346 /** 2347 * ntfs_truncate - called when the i_size of an ntfs inode is changed 2348 * @vi: inode for which the i_size was changed 2349 * 2350 * We only support i_size changes for normal files at present, i.e. not 2351 * compressed and not encrypted. This is enforced in ntfs_setattr(), see 2352 * below. 2353 * 2354 * The kernel guarantees that @vi is a regular file (S_ISREG() is true) and 2355 * that the change is allowed. 2356 * 2357 * This implies for us that @vi is a file inode rather than a directory, index, 2358 * or attribute inode as well as that @vi is a base inode. 2359 * 2360 * Returns 0 on success or -errno on error. 2361 * 2362 * Called with ->i_mutex held. 2363 */ 2364 int ntfs_truncate(struct inode *vi) 2365 { 2366 s64 new_size, old_size, nr_freed, new_alloc_size, old_alloc_size; 2367 VCN highest_vcn; 2368 unsigned long flags; 2369 ntfs_inode *base_ni, *ni = NTFS_I(vi); 2370 ntfs_volume *vol = ni->vol; 2371 ntfs_attr_search_ctx *ctx; 2372 MFT_RECORD *m; 2373 ATTR_RECORD *a; 2374 const char *te = " Leaving file length out of sync with i_size."; 2375 int err, mp_size, size_change, alloc_change; 2376 u32 attr_len; 2377 2378 ntfs_debug("Entering for inode 0x%lx.", vi->i_ino); 2379 BUG_ON(NInoAttr(ni)); 2380 BUG_ON(S_ISDIR(vi->i_mode)); 2381 BUG_ON(NInoMstProtected(ni)); 2382 BUG_ON(ni->nr_extents < 0); 2383 retry_truncate: 2384 /* 2385 * Lock the runlist for writing and map the mft record to ensure it is 2386 * safe to mess with the attribute runlist and sizes. 2387 */ 2388 down_write(&ni->runlist.lock); 2389 if (!NInoAttr(ni)) 2390 base_ni = ni; 2391 else 2392 base_ni = ni->ext.base_ntfs_ino; 2393 m = map_mft_record(base_ni); 2394 if (IS_ERR(m)) { 2395 err = PTR_ERR(m); 2396 ntfs_error(vi->i_sb, "Failed to map mft record for inode 0x%lx " 2397 "(error code %d).%s", vi->i_ino, err, te); 2398 ctx = NULL; 2399 m = NULL; 2400 goto old_bad_out; 2401 } 2402 ctx = ntfs_attr_get_search_ctx(base_ni, m); 2403 if (unlikely(!ctx)) { 2404 ntfs_error(vi->i_sb, "Failed to allocate a search context for " 2405 "inode 0x%lx (not enough memory).%s", 2406 vi->i_ino, te); 2407 err = -ENOMEM; 2408 goto old_bad_out; 2409 } 2410 err = ntfs_attr_lookup(ni->type, ni->name, ni->name_len, 2411 CASE_SENSITIVE, 0, NULL, 0, ctx); 2412 if (unlikely(err)) { 2413 if (err == -ENOENT) { 2414 ntfs_error(vi->i_sb, "Open attribute is missing from " 2415 "mft record. Inode 0x%lx is corrupt. " 2416 "Run chkdsk.%s", vi->i_ino, te); 2417 err = -EIO; 2418 } else 2419 ntfs_error(vi->i_sb, "Failed to lookup attribute in " 2420 "inode 0x%lx (error code %d).%s", 2421 vi->i_ino, err, te); 2422 goto old_bad_out; 2423 } 2424 m = ctx->mrec; 2425 a = ctx->attr; 2426 /* 2427 * The i_size of the vfs inode is the new size for the attribute value. 2428 */ 2429 new_size = i_size_read(vi); 2430 /* The current size of the attribute value is the old size. */ 2431 old_size = ntfs_attr_size(a); 2432 /* Calculate the new allocated size. */ 2433 if (NInoNonResident(ni)) 2434 new_alloc_size = (new_size + vol->cluster_size - 1) & 2435 ~(s64)vol->cluster_size_mask; 2436 else 2437 new_alloc_size = (new_size + 7) & ~7; 2438 /* The current allocated size is the old allocated size. */ 2439 read_lock_irqsave(&ni->size_lock, flags); 2440 old_alloc_size = ni->allocated_size; 2441 read_unlock_irqrestore(&ni->size_lock, flags); 2442 /* 2443 * The change in the file size. This will be 0 if no change, >0 if the 2444 * size is growing, and <0 if the size is shrinking. 2445 */ 2446 size_change = -1; 2447 if (new_size - old_size >= 0) { 2448 size_change = 1; 2449 if (new_size == old_size) 2450 size_change = 0; 2451 } 2452 /* As above for the allocated size. */ 2453 alloc_change = -1; 2454 if (new_alloc_size - old_alloc_size >= 0) { 2455 alloc_change = 1; 2456 if (new_alloc_size == old_alloc_size) 2457 alloc_change = 0; 2458 } 2459 /* 2460 * If neither the size nor the allocation are being changed there is 2461 * nothing to do. 2462 */ 2463 if (!size_change && !alloc_change) 2464 goto unm_done; 2465 /* If the size is changing, check if new size is allowed in $AttrDef. */ 2466 if (size_change) { 2467 err = ntfs_attr_size_bounds_check(vol, ni->type, new_size); 2468 if (unlikely(err)) { 2469 if (err == -ERANGE) { 2470 ntfs_error(vol->sb, "Truncate would cause the " 2471 "inode 0x%lx to %simum size " 2472 "for its attribute type " 2473 "(0x%x). Aborting truncate.", 2474 vi->i_ino, 2475 new_size > old_size ? "exceed " 2476 "the max" : "go under the min", 2477 le32_to_cpu(ni->type)); 2478 err = -EFBIG; 2479 } else { 2480 ntfs_error(vol->sb, "Inode 0x%lx has unknown " 2481 "attribute type 0x%x. " 2482 "Aborting truncate.", 2483 vi->i_ino, 2484 le32_to_cpu(ni->type)); 2485 err = -EIO; 2486 } 2487 /* Reset the vfs inode size to the old size. */ 2488 i_size_write(vi, old_size); 2489 goto err_out; 2490 } 2491 } 2492 if (NInoCompressed(ni) || NInoEncrypted(ni)) { 2493 ntfs_warning(vi->i_sb, "Changes in inode size are not " 2494 "supported yet for %s files, ignoring.", 2495 NInoCompressed(ni) ? "compressed" : 2496 "encrypted"); 2497 err = -EOPNOTSUPP; 2498 goto bad_out; 2499 } 2500 if (a->non_resident) 2501 goto do_non_resident_truncate; 2502 BUG_ON(NInoNonResident(ni)); 2503 /* Resize the attribute record to best fit the new attribute size. */ 2504 if (new_size < vol->mft_record_size && 2505 !ntfs_resident_attr_value_resize(m, a, new_size)) { 2506 /* The resize succeeded! */ 2507 flush_dcache_mft_record_page(ctx->ntfs_ino); 2508 mark_mft_record_dirty(ctx->ntfs_ino); 2509 write_lock_irqsave(&ni->size_lock, flags); 2510 /* Update the sizes in the ntfs inode and all is done. */ 2511 ni->allocated_size = le32_to_cpu(a->length) - 2512 le16_to_cpu(a->data.resident.value_offset); 2513 /* 2514 * Note ntfs_resident_attr_value_resize() has already done any 2515 * necessary data clearing in the attribute record. When the 2516 * file is being shrunk vmtruncate() will already have cleared 2517 * the top part of the last partial page, i.e. since this is 2518 * the resident case this is the page with index 0. However, 2519 * when the file is being expanded, the page cache page data 2520 * between the old data_size, i.e. old_size, and the new_size 2521 * has not been zeroed. Fortunately, we do not need to zero it 2522 * either since on one hand it will either already be zero due 2523 * to both readpage and writepage clearing partial page data 2524 * beyond i_size in which case there is nothing to do or in the 2525 * case of the file being mmap()ped at the same time, POSIX 2526 * specifies that the behaviour is unspecified thus we do not 2527 * have to do anything. This means that in our implementation 2528 * in the rare case that the file is mmap()ped and a write 2529 * occurred into the mmap()ped region just beyond the file size 2530 * and writepage has not yet been called to write out the page 2531 * (which would clear the area beyond the file size) and we now 2532 * extend the file size to incorporate this dirty region 2533 * outside the file size, a write of the page would result in 2534 * this data being written to disk instead of being cleared. 2535 * Given both POSIX and the Linux mmap(2) man page specify that 2536 * this corner case is undefined, we choose to leave it like 2537 * that as this is much simpler for us as we cannot lock the 2538 * relevant page now since we are holding too many ntfs locks 2539 * which would result in a lock reversal deadlock. 2540 */ 2541 ni->initialized_size = new_size; 2542 write_unlock_irqrestore(&ni->size_lock, flags); 2543 goto unm_done; 2544 } 2545 /* If the above resize failed, this must be an attribute extension. */ 2546 BUG_ON(size_change < 0); 2547 /* 2548 * We have to drop all the locks so we can call 2549 * ntfs_attr_make_non_resident(). This could be optimised by try- 2550 * locking the first page cache page and only if that fails dropping 2551 * the locks, locking the page, and redoing all the locking and 2552 * lookups. While this would be a huge optimisation, it is not worth 2553 * it as this is definitely a slow code path as it only ever can happen 2554 * once for any given file. 2555 */ 2556 ntfs_attr_put_search_ctx(ctx); 2557 unmap_mft_record(base_ni); 2558 up_write(&ni->runlist.lock); 2559 /* 2560 * Not enough space in the mft record, try to make the attribute 2561 * non-resident and if successful restart the truncation process. 2562 */ 2563 err = ntfs_attr_make_non_resident(ni, old_size); 2564 if (likely(!err)) 2565 goto retry_truncate; 2566 /* 2567 * Could not make non-resident. If this is due to this not being 2568 * permitted for this attribute type or there not being enough space, 2569 * try to make other attributes non-resident. Otherwise fail. 2570 */ 2571 if (unlikely(err != -EPERM && err != -ENOSPC)) { 2572 ntfs_error(vol->sb, "Cannot truncate inode 0x%lx, attribute " 2573 "type 0x%x, because the conversion from " 2574 "resident to non-resident attribute failed " 2575 "with error code %i.", vi->i_ino, 2576 (unsigned)le32_to_cpu(ni->type), err); 2577 if (err != -ENOMEM) 2578 err = -EIO; 2579 goto conv_err_out; 2580 } 2581 /* TODO: Not implemented from here, abort. */ 2582 if (err == -ENOSPC) 2583 ntfs_error(vol->sb, "Not enough space in the mft record/on " 2584 "disk for the non-resident attribute value. " 2585 "This case is not implemented yet."); 2586 else /* if (err == -EPERM) */ 2587 ntfs_error(vol->sb, "This attribute type may not be " 2588 "non-resident. This case is not implemented " 2589 "yet."); 2590 err = -EOPNOTSUPP; 2591 goto conv_err_out; 2592 #if 0 2593 // TODO: Attempt to make other attributes non-resident. 2594 if (!err) 2595 goto do_resident_extend; 2596 /* 2597 * Both the attribute list attribute and the standard information 2598 * attribute must remain in the base inode. Thus, if this is one of 2599 * these attributes, we have to try to move other attributes out into 2600 * extent mft records instead. 2601 */ 2602 if (ni->type == AT_ATTRIBUTE_LIST || 2603 ni->type == AT_STANDARD_INFORMATION) { 2604 // TODO: Attempt to move other attributes into extent mft 2605 // records. 2606 err = -EOPNOTSUPP; 2607 if (!err) 2608 goto do_resident_extend; 2609 goto err_out; 2610 } 2611 // TODO: Attempt to move this attribute to an extent mft record, but 2612 // only if it is not already the only attribute in an mft record in 2613 // which case there would be nothing to gain. 2614 err = -EOPNOTSUPP; 2615 if (!err) 2616 goto do_resident_extend; 2617 /* There is nothing we can do to make enough space. )-: */ 2618 goto err_out; 2619 #endif 2620 do_non_resident_truncate: 2621 BUG_ON(!NInoNonResident(ni)); 2622 if (alloc_change < 0) { 2623 highest_vcn = sle64_to_cpu(a->data.non_resident.highest_vcn); 2624 if (highest_vcn > 0 && 2625 old_alloc_size >> vol->cluster_size_bits > 2626 highest_vcn + 1) { 2627 /* 2628 * This attribute has multiple extents. Not yet 2629 * supported. 2630 */ 2631 ntfs_error(vol->sb, "Cannot truncate inode 0x%lx, " 2632 "attribute type 0x%x, because the " 2633 "attribute is highly fragmented (it " 2634 "consists of multiple extents) and " 2635 "this case is not implemented yet.", 2636 vi->i_ino, 2637 (unsigned)le32_to_cpu(ni->type)); 2638 err = -EOPNOTSUPP; 2639 goto bad_out; 2640 } 2641 } 2642 /* 2643 * If the size is shrinking, need to reduce the initialized_size and 2644 * the data_size before reducing the allocation. 2645 */ 2646 if (size_change < 0) { 2647 /* 2648 * Make the valid size smaller (i_size is already up-to-date). 2649 */ 2650 write_lock_irqsave(&ni->size_lock, flags); 2651 if (new_size < ni->initialized_size) { 2652 ni->initialized_size = new_size; 2653 a->data.non_resident.initialized_size = 2654 cpu_to_sle64(new_size); 2655 } 2656 a->data.non_resident.data_size = cpu_to_sle64(new_size); 2657 write_unlock_irqrestore(&ni->size_lock, flags); 2658 flush_dcache_mft_record_page(ctx->ntfs_ino); 2659 mark_mft_record_dirty(ctx->ntfs_ino); 2660 /* If the allocated size is not changing, we are done. */ 2661 if (!alloc_change) 2662 goto unm_done; 2663 /* 2664 * If the size is shrinking it makes no sense for the 2665 * allocation to be growing. 2666 */ 2667 BUG_ON(alloc_change > 0); 2668 } else /* if (size_change >= 0) */ { 2669 /* 2670 * The file size is growing or staying the same but the 2671 * allocation can be shrinking, growing or staying the same. 2672 */ 2673 if (alloc_change > 0) { 2674 /* 2675 * We need to extend the allocation and possibly update 2676 * the data size. If we are updating the data size, 2677 * since we are not touching the initialized_size we do 2678 * not need to worry about the actual data on disk. 2679 * And as far as the page cache is concerned, there 2680 * will be no pages beyond the old data size and any 2681 * partial region in the last page between the old and 2682 * new data size (or the end of the page if the new 2683 * data size is outside the page) does not need to be 2684 * modified as explained above for the resident 2685 * attribute truncate case. To do this, we simply drop 2686 * the locks we hold and leave all the work to our 2687 * friendly helper ntfs_attr_extend_allocation(). 2688 */ 2689 ntfs_attr_put_search_ctx(ctx); 2690 unmap_mft_record(base_ni); 2691 up_write(&ni->runlist.lock); 2692 err = ntfs_attr_extend_allocation(ni, new_size, 2693 size_change > 0 ? new_size : -1, -1); 2694 /* 2695 * ntfs_attr_extend_allocation() will have done error 2696 * output already. 2697 */ 2698 goto done; 2699 } 2700 if (!alloc_change) 2701 goto alloc_done; 2702 } 2703 /* alloc_change < 0 */ 2704 /* Free the clusters. */ 2705 nr_freed = ntfs_cluster_free(ni, new_alloc_size >> 2706 vol->cluster_size_bits, -1, ctx); 2707 m = ctx->mrec; 2708 a = ctx->attr; 2709 if (unlikely(nr_freed < 0)) { 2710 ntfs_error(vol->sb, "Failed to release cluster(s) (error code " 2711 "%lli). Unmount and run chkdsk to recover " 2712 "the lost cluster(s).", (long long)nr_freed); 2713 NVolSetErrors(vol); 2714 nr_freed = 0; 2715 } 2716 /* Truncate the runlist. */ 2717 err = ntfs_rl_truncate_nolock(vol, &ni->runlist, 2718 new_alloc_size >> vol->cluster_size_bits); 2719 /* 2720 * If the runlist truncation failed and/or the search context is no 2721 * longer valid, we cannot resize the attribute record or build the 2722 * mapping pairs array thus we mark the inode bad so that no access to 2723 * the freed clusters can happen. 2724 */ 2725 if (unlikely(err || IS_ERR(m))) { 2726 ntfs_error(vol->sb, "Failed to %s (error code %li).%s", 2727 IS_ERR(m) ? 2728 "restore attribute search context" : 2729 "truncate attribute runlist", 2730 IS_ERR(m) ? PTR_ERR(m) : err, es); 2731 err = -EIO; 2732 goto bad_out; 2733 } 2734 /* Get the size for the shrunk mapping pairs array for the runlist. */ 2735 mp_size = ntfs_get_size_for_mapping_pairs(vol, ni->runlist.rl, 0, -1); 2736 if (unlikely(mp_size <= 0)) { 2737 ntfs_error(vol->sb, "Cannot shrink allocation of inode 0x%lx, " 2738 "attribute type 0x%x, because determining the " 2739 "size for the mapping pairs failed with error " 2740 "code %i.%s", vi->i_ino, 2741 (unsigned)le32_to_cpu(ni->type), mp_size, es); 2742 err = -EIO; 2743 goto bad_out; 2744 } 2745 /* 2746 * Shrink the attribute record for the new mapping pairs array. Note, 2747 * this cannot fail since we are making the attribute smaller thus by 2748 * definition there is enough space to do so. 2749 */ 2750 attr_len = le32_to_cpu(a->length); 2751 err = ntfs_attr_record_resize(m, a, mp_size + 2752 le16_to_cpu(a->data.non_resident.mapping_pairs_offset)); 2753 BUG_ON(err); 2754 /* 2755 * Generate the mapping pairs array directly into the attribute record. 2756 */ 2757 err = ntfs_mapping_pairs_build(vol, (u8*)a + 2758 le16_to_cpu(a->data.non_resident.mapping_pairs_offset), 2759 mp_size, ni->runlist.rl, 0, -1, NULL); 2760 if (unlikely(err)) { 2761 ntfs_error(vol->sb, "Cannot shrink allocation of inode 0x%lx, " 2762 "attribute type 0x%x, because building the " 2763 "mapping pairs failed with error code %i.%s", 2764 vi->i_ino, (unsigned)le32_to_cpu(ni->type), 2765 err, es); 2766 err = -EIO; 2767 goto bad_out; 2768 } 2769 /* Update the allocated/compressed size as well as the highest vcn. */ 2770 a->data.non_resident.highest_vcn = cpu_to_sle64((new_alloc_size >> 2771 vol->cluster_size_bits) - 1); 2772 write_lock_irqsave(&ni->size_lock, flags); 2773 ni->allocated_size = new_alloc_size; 2774 a->data.non_resident.allocated_size = cpu_to_sle64(new_alloc_size); 2775 if (NInoSparse(ni) || NInoCompressed(ni)) { 2776 if (nr_freed) { 2777 ni->itype.compressed.size -= nr_freed << 2778 vol->cluster_size_bits; 2779 BUG_ON(ni->itype.compressed.size < 0); 2780 a->data.non_resident.compressed_size = cpu_to_sle64( 2781 ni->itype.compressed.size); 2782 vi->i_blocks = ni->itype.compressed.size >> 9; 2783 } 2784 } else 2785 vi->i_blocks = new_alloc_size >> 9; 2786 write_unlock_irqrestore(&ni->size_lock, flags); 2787 /* 2788 * We have shrunk the allocation. If this is a shrinking truncate we 2789 * have already dealt with the initialized_size and the data_size above 2790 * and we are done. If the truncate is only changing the allocation 2791 * and not the data_size, we are also done. If this is an extending 2792 * truncate, need to extend the data_size now which is ensured by the 2793 * fact that @size_change is positive. 2794 */ 2795 alloc_done: 2796 /* 2797 * If the size is growing, need to update it now. If it is shrinking, 2798 * we have already updated it above (before the allocation change). 2799 */ 2800 if (size_change > 0) 2801 a->data.non_resident.data_size = cpu_to_sle64(new_size); 2802 /* Ensure the modified mft record is written out. */ 2803 flush_dcache_mft_record_page(ctx->ntfs_ino); 2804 mark_mft_record_dirty(ctx->ntfs_ino); 2805 unm_done: 2806 ntfs_attr_put_search_ctx(ctx); 2807 unmap_mft_record(base_ni); 2808 up_write(&ni->runlist.lock); 2809 done: 2810 /* Update the mtime and ctime on the base inode. */ 2811 /* normally ->truncate shouldn't update ctime or mtime, 2812 * but ntfs did before so it got a copy & paste version 2813 * of file_update_time. one day someone should fix this 2814 * for real. 2815 */ 2816 if (!IS_NOCMTIME(VFS_I(base_ni)) && !IS_RDONLY(VFS_I(base_ni))) { 2817 struct timespec now = current_fs_time(VFS_I(base_ni)->i_sb); 2818 int sync_it = 0; 2819 2820 if (!timespec_equal(&VFS_I(base_ni)->i_mtime, &now) || 2821 !timespec_equal(&VFS_I(base_ni)->i_ctime, &now)) 2822 sync_it = 1; 2823 VFS_I(base_ni)->i_mtime = now; 2824 VFS_I(base_ni)->i_ctime = now; 2825 2826 if (sync_it) 2827 mark_inode_dirty_sync(VFS_I(base_ni)); 2828 } 2829 2830 if (likely(!err)) { 2831 NInoClearTruncateFailed(ni); 2832 ntfs_debug("Done."); 2833 } 2834 return err; 2835 old_bad_out: 2836 old_size = -1; 2837 bad_out: 2838 if (err != -ENOMEM && err != -EOPNOTSUPP) 2839 NVolSetErrors(vol); 2840 if (err != -EOPNOTSUPP) 2841 NInoSetTruncateFailed(ni); 2842 else if (old_size >= 0) 2843 i_size_write(vi, old_size); 2844 err_out: 2845 if (ctx) 2846 ntfs_attr_put_search_ctx(ctx); 2847 if (m) 2848 unmap_mft_record(base_ni); 2849 up_write(&ni->runlist.lock); 2850 out: 2851 ntfs_debug("Failed. Returning error code %i.", err); 2852 return err; 2853 conv_err_out: 2854 if (err != -ENOMEM && err != -EOPNOTSUPP) 2855 NVolSetErrors(vol); 2856 if (err != -EOPNOTSUPP) 2857 NInoSetTruncateFailed(ni); 2858 else 2859 i_size_write(vi, old_size); 2860 goto out; 2861 } 2862 2863 /** 2864 * ntfs_truncate_vfs - wrapper for ntfs_truncate() that has no return value 2865 * @vi: inode for which the i_size was changed 2866 * 2867 * Wrapper for ntfs_truncate() that has no return value. 2868 * 2869 * See ntfs_truncate() description above for details. 2870 */ 2871 #ifdef NTFS_RW 2872 void ntfs_truncate_vfs(struct inode *vi) { 2873 ntfs_truncate(vi); 2874 } 2875 #endif 2876 2877 /** 2878 * ntfs_setattr - called from notify_change() when an attribute is being changed 2879 * @dentry: dentry whose attributes to change 2880 * @attr: structure describing the attributes and the changes 2881 * 2882 * We have to trap VFS attempts to truncate the file described by @dentry as 2883 * soon as possible, because we do not implement changes in i_size yet. So we 2884 * abort all i_size changes here. 2885 * 2886 * We also abort all changes of user, group, and mode as we do not implement 2887 * the NTFS ACLs yet. 2888 * 2889 * Called with ->i_mutex held. 2890 */ 2891 int ntfs_setattr(struct dentry *dentry, struct iattr *attr) 2892 { 2893 struct inode *vi = dentry->d_inode; 2894 int err; 2895 unsigned int ia_valid = attr->ia_valid; 2896 2897 err = inode_change_ok(vi, attr); 2898 if (err) 2899 goto out; 2900 /* We do not support NTFS ACLs yet. */ 2901 if (ia_valid & (ATTR_UID | ATTR_GID | ATTR_MODE)) { 2902 ntfs_warning(vi->i_sb, "Changes in user/group/mode are not " 2903 "supported yet, ignoring."); 2904 err = -EOPNOTSUPP; 2905 goto out; 2906 } 2907 if (ia_valid & ATTR_SIZE) { 2908 if (attr->ia_size != i_size_read(vi)) { 2909 ntfs_inode *ni = NTFS_I(vi); 2910 /* 2911 * FIXME: For now we do not support resizing of 2912 * compressed or encrypted files yet. 2913 */ 2914 if (NInoCompressed(ni) || NInoEncrypted(ni)) { 2915 ntfs_warning(vi->i_sb, "Changes in inode size " 2916 "are not supported yet for " 2917 "%s files, ignoring.", 2918 NInoCompressed(ni) ? 2919 "compressed" : "encrypted"); 2920 err = -EOPNOTSUPP; 2921 } else { 2922 truncate_setsize(vi, attr->ia_size); 2923 ntfs_truncate_vfs(vi); 2924 } 2925 if (err || ia_valid == ATTR_SIZE) 2926 goto out; 2927 } else { 2928 /* 2929 * We skipped the truncate but must still update 2930 * timestamps. 2931 */ 2932 ia_valid |= ATTR_MTIME | ATTR_CTIME; 2933 } 2934 } 2935 if (ia_valid & ATTR_ATIME) 2936 vi->i_atime = timespec_trunc(attr->ia_atime, 2937 vi->i_sb->s_time_gran); 2938 if (ia_valid & ATTR_MTIME) 2939 vi->i_mtime = timespec_trunc(attr->ia_mtime, 2940 vi->i_sb->s_time_gran); 2941 if (ia_valid & ATTR_CTIME) 2942 vi->i_ctime = timespec_trunc(attr->ia_ctime, 2943 vi->i_sb->s_time_gran); 2944 mark_inode_dirty(vi); 2945 out: 2946 return err; 2947 } 2948 2949 /** 2950 * ntfs_write_inode - write out a dirty inode 2951 * @vi: inode to write out 2952 * @sync: if true, write out synchronously 2953 * 2954 * Write out a dirty inode to disk including any extent inodes if present. 2955 * 2956 * If @sync is true, commit the inode to disk and wait for io completion. This 2957 * is done using write_mft_record(). 2958 * 2959 * If @sync is false, just schedule the write to happen but do not wait for i/o 2960 * completion. In 2.6 kernels, scheduling usually happens just by virtue of 2961 * marking the page (and in this case mft record) dirty but we do not implement 2962 * this yet as write_mft_record() largely ignores the @sync parameter and 2963 * always performs synchronous writes. 2964 * 2965 * Return 0 on success and -errno on error. 2966 */ 2967 int __ntfs_write_inode(struct inode *vi, int sync) 2968 { 2969 sle64 nt; 2970 ntfs_inode *ni = NTFS_I(vi); 2971 ntfs_attr_search_ctx *ctx; 2972 MFT_RECORD *m; 2973 STANDARD_INFORMATION *si; 2974 int err = 0; 2975 bool modified = false; 2976 2977 ntfs_debug("Entering for %sinode 0x%lx.", NInoAttr(ni) ? "attr " : "", 2978 vi->i_ino); 2979 /* 2980 * Dirty attribute inodes are written via their real inodes so just 2981 * clean them here. Access time updates are taken care off when the 2982 * real inode is written. 2983 */ 2984 if (NInoAttr(ni)) { 2985 NInoClearDirty(ni); 2986 ntfs_debug("Done."); 2987 return 0; 2988 } 2989 /* Map, pin, and lock the mft record belonging to the inode. */ 2990 m = map_mft_record(ni); 2991 if (IS_ERR(m)) { 2992 err = PTR_ERR(m); 2993 goto err_out; 2994 } 2995 /* Update the access times in the standard information attribute. */ 2996 ctx = ntfs_attr_get_search_ctx(ni, m); 2997 if (unlikely(!ctx)) { 2998 err = -ENOMEM; 2999 goto unm_err_out; 3000 } 3001 err = ntfs_attr_lookup(AT_STANDARD_INFORMATION, NULL, 0, 3002 CASE_SENSITIVE, 0, NULL, 0, ctx); 3003 if (unlikely(err)) { 3004 ntfs_attr_put_search_ctx(ctx); 3005 goto unm_err_out; 3006 } 3007 si = (STANDARD_INFORMATION*)((u8*)ctx->attr + 3008 le16_to_cpu(ctx->attr->data.resident.value_offset)); 3009 /* Update the access times if they have changed. */ 3010 nt = utc2ntfs(vi->i_mtime); 3011 if (si->last_data_change_time != nt) { 3012 ntfs_debug("Updating mtime for inode 0x%lx: old = 0x%llx, " 3013 "new = 0x%llx", vi->i_ino, (long long) 3014 sle64_to_cpu(si->last_data_change_time), 3015 (long long)sle64_to_cpu(nt)); 3016 si->last_data_change_time = nt; 3017 modified = true; 3018 } 3019 nt = utc2ntfs(vi->i_ctime); 3020 if (si->last_mft_change_time != nt) { 3021 ntfs_debug("Updating ctime for inode 0x%lx: old = 0x%llx, " 3022 "new = 0x%llx", vi->i_ino, (long long) 3023 sle64_to_cpu(si->last_mft_change_time), 3024 (long long)sle64_to_cpu(nt)); 3025 si->last_mft_change_time = nt; 3026 modified = true; 3027 } 3028 nt = utc2ntfs(vi->i_atime); 3029 if (si->last_access_time != nt) { 3030 ntfs_debug("Updating atime for inode 0x%lx: old = 0x%llx, " 3031 "new = 0x%llx", vi->i_ino, 3032 (long long)sle64_to_cpu(si->last_access_time), 3033 (long long)sle64_to_cpu(nt)); 3034 si->last_access_time = nt; 3035 modified = true; 3036 } 3037 /* 3038 * If we just modified the standard information attribute we need to 3039 * mark the mft record it is in dirty. We do this manually so that 3040 * mark_inode_dirty() is not called which would redirty the inode and 3041 * hence result in an infinite loop of trying to write the inode. 3042 * There is no need to mark the base inode nor the base mft record 3043 * dirty, since we are going to write this mft record below in any case 3044 * and the base mft record may actually not have been modified so it 3045 * might not need to be written out. 3046 * NOTE: It is not a problem when the inode for $MFT itself is being 3047 * written out as mark_ntfs_record_dirty() will only set I_DIRTY_PAGES 3048 * on the $MFT inode and hence ntfs_write_inode() will not be 3049 * re-invoked because of it which in turn is ok since the dirtied mft 3050 * record will be cleaned and written out to disk below, i.e. before 3051 * this function returns. 3052 */ 3053 if (modified) { 3054 flush_dcache_mft_record_page(ctx->ntfs_ino); 3055 if (!NInoTestSetDirty(ctx->ntfs_ino)) 3056 mark_ntfs_record_dirty(ctx->ntfs_ino->page, 3057 ctx->ntfs_ino->page_ofs); 3058 } 3059 ntfs_attr_put_search_ctx(ctx); 3060 /* Now the access times are updated, write the base mft record. */ 3061 if (NInoDirty(ni)) 3062 err = write_mft_record(ni, m, sync); 3063 /* Write all attached extent mft records. */ 3064 mutex_lock(&ni->extent_lock); 3065 if (ni->nr_extents > 0) { 3066 ntfs_inode **extent_nis = ni->ext.extent_ntfs_inos; 3067 int i; 3068 3069 ntfs_debug("Writing %i extent inodes.", ni->nr_extents); 3070 for (i = 0; i < ni->nr_extents; i++) { 3071 ntfs_inode *tni = extent_nis[i]; 3072 3073 if (NInoDirty(tni)) { 3074 MFT_RECORD *tm = map_mft_record(tni); 3075 int ret; 3076 3077 if (IS_ERR(tm)) { 3078 if (!err || err == -ENOMEM) 3079 err = PTR_ERR(tm); 3080 continue; 3081 } 3082 ret = write_mft_record(tni, tm, sync); 3083 unmap_mft_record(tni); 3084 if (unlikely(ret)) { 3085 if (!err || err == -ENOMEM) 3086 err = ret; 3087 } 3088 } 3089 } 3090 } 3091 mutex_unlock(&ni->extent_lock); 3092 unmap_mft_record(ni); 3093 if (unlikely(err)) 3094 goto err_out; 3095 ntfs_debug("Done."); 3096 return 0; 3097 unm_err_out: 3098 unmap_mft_record(ni); 3099 err_out: 3100 if (err == -ENOMEM) { 3101 ntfs_warning(vi->i_sb, "Not enough memory to write inode. " 3102 "Marking the inode dirty again, so the VFS " 3103 "retries later."); 3104 mark_inode_dirty(vi); 3105 } else { 3106 ntfs_error(vi->i_sb, "Failed (error %i): Run chkdsk.", -err); 3107 NVolSetErrors(ni->vol); 3108 } 3109 return err; 3110 } 3111 3112 #endif /* NTFS_RW */ 3113