1 /* 2 * Copyright (C) 2008 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include <linux/sched.h> 20 #include <linux/slab.h> 21 #include "ctree.h" 22 #include "transaction.h" 23 #include "disk-io.h" 24 #include "locking.h" 25 #include "print-tree.h" 26 #include "compat.h" 27 #include "tree-log.h" 28 29 /* magic values for the inode_only field in btrfs_log_inode: 30 * 31 * LOG_INODE_ALL means to log everything 32 * LOG_INODE_EXISTS means to log just enough to recreate the inode 33 * during log replay 34 */ 35 #define LOG_INODE_ALL 0 36 #define LOG_INODE_EXISTS 1 37 38 /* 39 * directory trouble cases 40 * 41 * 1) on rename or unlink, if the inode being unlinked isn't in the fsync 42 * log, we must force a full commit before doing an fsync of the directory 43 * where the unlink was done. 44 * ---> record transid of last unlink/rename per directory 45 * 46 * mkdir foo/some_dir 47 * normal commit 48 * rename foo/some_dir foo2/some_dir 49 * mkdir foo/some_dir 50 * fsync foo/some_dir/some_file 51 * 52 * The fsync above will unlink the original some_dir without recording 53 * it in its new location (foo2). After a crash, some_dir will be gone 54 * unless the fsync of some_file forces a full commit 55 * 56 * 2) we must log any new names for any file or dir that is in the fsync 57 * log. ---> check inode while renaming/linking. 58 * 59 * 2a) we must log any new names for any file or dir during rename 60 * when the directory they are being removed from was logged. 61 * ---> check inode and old parent dir during rename 62 * 63 * 2a is actually the more important variant. With the extra logging 64 * a crash might unlink the old name without recreating the new one 65 * 66 * 3) after a crash, we must go through any directories with a link count 67 * of zero and redo the rm -rf 68 * 69 * mkdir f1/foo 70 * normal commit 71 * rm -rf f1/foo 72 * fsync(f1) 73 * 74 * The directory f1 was fully removed from the FS, but fsync was never 75 * called on f1, only its parent dir. After a crash the rm -rf must 76 * be replayed. This must be able to recurse down the entire 77 * directory tree. The inode link count fixup code takes care of the 78 * ugly details. 79 */ 80 81 /* 82 * stages for the tree walking. The first 83 * stage (0) is to only pin down the blocks we find 84 * the second stage (1) is to make sure that all the inodes 85 * we find in the log are created in the subvolume. 86 * 87 * The last stage is to deal with directories and links and extents 88 * and all the other fun semantics 89 */ 90 #define LOG_WALK_PIN_ONLY 0 91 #define LOG_WALK_REPLAY_INODES 1 92 #define LOG_WALK_REPLAY_ALL 2 93 94 static int btrfs_log_inode(struct btrfs_trans_handle *trans, 95 struct btrfs_root *root, struct inode *inode, 96 int inode_only); 97 static int link_to_fixup_dir(struct btrfs_trans_handle *trans, 98 struct btrfs_root *root, 99 struct btrfs_path *path, u64 objectid); 100 static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans, 101 struct btrfs_root *root, 102 struct btrfs_root *log, 103 struct btrfs_path *path, 104 u64 dirid, int del_all); 105 106 /* 107 * tree logging is a special write ahead log used to make sure that 108 * fsyncs and O_SYNCs can happen without doing full tree commits. 109 * 110 * Full tree commits are expensive because they require commonly 111 * modified blocks to be recowed, creating many dirty pages in the 112 * extent tree an 4x-6x higher write load than ext3. 113 * 114 * Instead of doing a tree commit on every fsync, we use the 115 * key ranges and transaction ids to find items for a given file or directory 116 * that have changed in this transaction. Those items are copied into 117 * a special tree (one per subvolume root), that tree is written to disk 118 * and then the fsync is considered complete. 119 * 120 * After a crash, items are copied out of the log-tree back into the 121 * subvolume tree. Any file data extents found are recorded in the extent 122 * allocation tree, and the log-tree freed. 123 * 124 * The log tree is read three times, once to pin down all the extents it is 125 * using in ram and once, once to create all the inodes logged in the tree 126 * and once to do all the other items. 127 */ 128 129 /* 130 * start a sub transaction and setup the log tree 131 * this increments the log tree writer count to make the people 132 * syncing the tree wait for us to finish 133 */ 134 static int start_log_trans(struct btrfs_trans_handle *trans, 135 struct btrfs_root *root) 136 { 137 int ret; 138 int err = 0; 139 140 mutex_lock(&root->log_mutex); 141 if (root->log_root) { 142 if (!root->log_start_pid) { 143 root->log_start_pid = current->pid; 144 root->log_multiple_pids = false; 145 } else if (root->log_start_pid != current->pid) { 146 root->log_multiple_pids = true; 147 } 148 149 root->log_batch++; 150 atomic_inc(&root->log_writers); 151 mutex_unlock(&root->log_mutex); 152 return 0; 153 } 154 root->log_multiple_pids = false; 155 root->log_start_pid = current->pid; 156 mutex_lock(&root->fs_info->tree_log_mutex); 157 if (!root->fs_info->log_root_tree) { 158 ret = btrfs_init_log_root_tree(trans, root->fs_info); 159 if (ret) 160 err = ret; 161 } 162 if (err == 0 && !root->log_root) { 163 ret = btrfs_add_log_tree(trans, root); 164 if (ret) 165 err = ret; 166 } 167 mutex_unlock(&root->fs_info->tree_log_mutex); 168 root->log_batch++; 169 atomic_inc(&root->log_writers); 170 mutex_unlock(&root->log_mutex); 171 return err; 172 } 173 174 /* 175 * returns 0 if there was a log transaction running and we were able 176 * to join, or returns -ENOENT if there were not transactions 177 * in progress 178 */ 179 static int join_running_log_trans(struct btrfs_root *root) 180 { 181 int ret = -ENOENT; 182 183 smp_mb(); 184 if (!root->log_root) 185 return -ENOENT; 186 187 mutex_lock(&root->log_mutex); 188 if (root->log_root) { 189 ret = 0; 190 atomic_inc(&root->log_writers); 191 } 192 mutex_unlock(&root->log_mutex); 193 return ret; 194 } 195 196 /* 197 * This either makes the current running log transaction wait 198 * until you call btrfs_end_log_trans() or it makes any future 199 * log transactions wait until you call btrfs_end_log_trans() 200 */ 201 int btrfs_pin_log_trans(struct btrfs_root *root) 202 { 203 int ret = -ENOENT; 204 205 mutex_lock(&root->log_mutex); 206 atomic_inc(&root->log_writers); 207 mutex_unlock(&root->log_mutex); 208 return ret; 209 } 210 211 /* 212 * indicate we're done making changes to the log tree 213 * and wake up anyone waiting to do a sync 214 */ 215 int btrfs_end_log_trans(struct btrfs_root *root) 216 { 217 if (atomic_dec_and_test(&root->log_writers)) { 218 smp_mb(); 219 if (waitqueue_active(&root->log_writer_wait)) 220 wake_up(&root->log_writer_wait); 221 } 222 return 0; 223 } 224 225 226 /* 227 * the walk control struct is used to pass state down the chain when 228 * processing the log tree. The stage field tells us which part 229 * of the log tree processing we are currently doing. The others 230 * are state fields used for that specific part 231 */ 232 struct walk_control { 233 /* should we free the extent on disk when done? This is used 234 * at transaction commit time while freeing a log tree 235 */ 236 int free; 237 238 /* should we write out the extent buffer? This is used 239 * while flushing the log tree to disk during a sync 240 */ 241 int write; 242 243 /* should we wait for the extent buffer io to finish? Also used 244 * while flushing the log tree to disk for a sync 245 */ 246 int wait; 247 248 /* pin only walk, we record which extents on disk belong to the 249 * log trees 250 */ 251 int pin; 252 253 /* what stage of the replay code we're currently in */ 254 int stage; 255 256 /* the root we are currently replaying */ 257 struct btrfs_root *replay_dest; 258 259 /* the trans handle for the current replay */ 260 struct btrfs_trans_handle *trans; 261 262 /* the function that gets used to process blocks we find in the 263 * tree. Note the extent_buffer might not be up to date when it is 264 * passed in, and it must be checked or read if you need the data 265 * inside it 266 */ 267 int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb, 268 struct walk_control *wc, u64 gen); 269 }; 270 271 /* 272 * process_func used to pin down extents, write them or wait on them 273 */ 274 static int process_one_buffer(struct btrfs_root *log, 275 struct extent_buffer *eb, 276 struct walk_control *wc, u64 gen) 277 { 278 if (wc->pin) 279 btrfs_pin_extent(log->fs_info->extent_root, 280 eb->start, eb->len, 0); 281 282 if (btrfs_buffer_uptodate(eb, gen)) { 283 if (wc->write) 284 btrfs_write_tree_block(eb); 285 if (wc->wait) 286 btrfs_wait_tree_block_writeback(eb); 287 } 288 return 0; 289 } 290 291 /* 292 * Item overwrite used by replay and tree logging. eb, slot and key all refer 293 * to the src data we are copying out. 294 * 295 * root is the tree we are copying into, and path is a scratch 296 * path for use in this function (it should be released on entry and 297 * will be released on exit). 298 * 299 * If the key is already in the destination tree the existing item is 300 * overwritten. If the existing item isn't big enough, it is extended. 301 * If it is too large, it is truncated. 302 * 303 * If the key isn't in the destination yet, a new item is inserted. 304 */ 305 static noinline int overwrite_item(struct btrfs_trans_handle *trans, 306 struct btrfs_root *root, 307 struct btrfs_path *path, 308 struct extent_buffer *eb, int slot, 309 struct btrfs_key *key) 310 { 311 int ret; 312 u32 item_size; 313 u64 saved_i_size = 0; 314 int save_old_i_size = 0; 315 unsigned long src_ptr; 316 unsigned long dst_ptr; 317 int overwrite_root = 0; 318 319 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) 320 overwrite_root = 1; 321 322 item_size = btrfs_item_size_nr(eb, slot); 323 src_ptr = btrfs_item_ptr_offset(eb, slot); 324 325 /* look for the key in the destination tree */ 326 ret = btrfs_search_slot(NULL, root, key, path, 0, 0); 327 if (ret == 0) { 328 char *src_copy; 329 char *dst_copy; 330 u32 dst_size = btrfs_item_size_nr(path->nodes[0], 331 path->slots[0]); 332 if (dst_size != item_size) 333 goto insert; 334 335 if (item_size == 0) { 336 btrfs_release_path(path); 337 return 0; 338 } 339 dst_copy = kmalloc(item_size, GFP_NOFS); 340 src_copy = kmalloc(item_size, GFP_NOFS); 341 if (!dst_copy || !src_copy) { 342 btrfs_release_path(path); 343 kfree(dst_copy); 344 kfree(src_copy); 345 return -ENOMEM; 346 } 347 348 read_extent_buffer(eb, src_copy, src_ptr, item_size); 349 350 dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]); 351 read_extent_buffer(path->nodes[0], dst_copy, dst_ptr, 352 item_size); 353 ret = memcmp(dst_copy, src_copy, item_size); 354 355 kfree(dst_copy); 356 kfree(src_copy); 357 /* 358 * they have the same contents, just return, this saves 359 * us from cowing blocks in the destination tree and doing 360 * extra writes that may not have been done by a previous 361 * sync 362 */ 363 if (ret == 0) { 364 btrfs_release_path(path); 365 return 0; 366 } 367 368 } 369 insert: 370 btrfs_release_path(path); 371 /* try to insert the key into the destination tree */ 372 ret = btrfs_insert_empty_item(trans, root, path, 373 key, item_size); 374 375 /* make sure any existing item is the correct size */ 376 if (ret == -EEXIST) { 377 u32 found_size; 378 found_size = btrfs_item_size_nr(path->nodes[0], 379 path->slots[0]); 380 if (found_size > item_size) { 381 btrfs_truncate_item(trans, root, path, item_size, 1); 382 } else if (found_size < item_size) { 383 ret = btrfs_extend_item(trans, root, path, 384 item_size - found_size); 385 } 386 } else if (ret) { 387 return ret; 388 } 389 dst_ptr = btrfs_item_ptr_offset(path->nodes[0], 390 path->slots[0]); 391 392 /* don't overwrite an existing inode if the generation number 393 * was logged as zero. This is done when the tree logging code 394 * is just logging an inode to make sure it exists after recovery. 395 * 396 * Also, don't overwrite i_size on directories during replay. 397 * log replay inserts and removes directory items based on the 398 * state of the tree found in the subvolume, and i_size is modified 399 * as it goes 400 */ 401 if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) { 402 struct btrfs_inode_item *src_item; 403 struct btrfs_inode_item *dst_item; 404 405 src_item = (struct btrfs_inode_item *)src_ptr; 406 dst_item = (struct btrfs_inode_item *)dst_ptr; 407 408 if (btrfs_inode_generation(eb, src_item) == 0) 409 goto no_copy; 410 411 if (overwrite_root && 412 S_ISDIR(btrfs_inode_mode(eb, src_item)) && 413 S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) { 414 save_old_i_size = 1; 415 saved_i_size = btrfs_inode_size(path->nodes[0], 416 dst_item); 417 } 418 } 419 420 copy_extent_buffer(path->nodes[0], eb, dst_ptr, 421 src_ptr, item_size); 422 423 if (save_old_i_size) { 424 struct btrfs_inode_item *dst_item; 425 dst_item = (struct btrfs_inode_item *)dst_ptr; 426 btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size); 427 } 428 429 /* make sure the generation is filled in */ 430 if (key->type == BTRFS_INODE_ITEM_KEY) { 431 struct btrfs_inode_item *dst_item; 432 dst_item = (struct btrfs_inode_item *)dst_ptr; 433 if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) { 434 btrfs_set_inode_generation(path->nodes[0], dst_item, 435 trans->transid); 436 } 437 } 438 no_copy: 439 btrfs_mark_buffer_dirty(path->nodes[0]); 440 btrfs_release_path(path); 441 return 0; 442 } 443 444 /* 445 * simple helper to read an inode off the disk from a given root 446 * This can only be called for subvolume roots and not for the log 447 */ 448 static noinline struct inode *read_one_inode(struct btrfs_root *root, 449 u64 objectid) 450 { 451 struct btrfs_key key; 452 struct inode *inode; 453 454 key.objectid = objectid; 455 key.type = BTRFS_INODE_ITEM_KEY; 456 key.offset = 0; 457 inode = btrfs_iget(root->fs_info->sb, &key, root, NULL); 458 if (IS_ERR(inode)) { 459 inode = NULL; 460 } else if (is_bad_inode(inode)) { 461 iput(inode); 462 inode = NULL; 463 } 464 return inode; 465 } 466 467 /* replays a single extent in 'eb' at 'slot' with 'key' into the 468 * subvolume 'root'. path is released on entry and should be released 469 * on exit. 470 * 471 * extents in the log tree have not been allocated out of the extent 472 * tree yet. So, this completes the allocation, taking a reference 473 * as required if the extent already exists or creating a new extent 474 * if it isn't in the extent allocation tree yet. 475 * 476 * The extent is inserted into the file, dropping any existing extents 477 * from the file that overlap the new one. 478 */ 479 static noinline int replay_one_extent(struct btrfs_trans_handle *trans, 480 struct btrfs_root *root, 481 struct btrfs_path *path, 482 struct extent_buffer *eb, int slot, 483 struct btrfs_key *key) 484 { 485 int found_type; 486 u64 mask = root->sectorsize - 1; 487 u64 extent_end; 488 u64 alloc_hint; 489 u64 start = key->offset; 490 u64 saved_nbytes; 491 struct btrfs_file_extent_item *item; 492 struct inode *inode = NULL; 493 unsigned long size; 494 int ret = 0; 495 496 item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item); 497 found_type = btrfs_file_extent_type(eb, item); 498 499 if (found_type == BTRFS_FILE_EXTENT_REG || 500 found_type == BTRFS_FILE_EXTENT_PREALLOC) 501 extent_end = start + btrfs_file_extent_num_bytes(eb, item); 502 else if (found_type == BTRFS_FILE_EXTENT_INLINE) { 503 size = btrfs_file_extent_inline_len(eb, item); 504 extent_end = (start + size + mask) & ~mask; 505 } else { 506 ret = 0; 507 goto out; 508 } 509 510 inode = read_one_inode(root, key->objectid); 511 if (!inode) { 512 ret = -EIO; 513 goto out; 514 } 515 516 /* 517 * first check to see if we already have this extent in the 518 * file. This must be done before the btrfs_drop_extents run 519 * so we don't try to drop this extent. 520 */ 521 ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode), 522 start, 0); 523 524 if (ret == 0 && 525 (found_type == BTRFS_FILE_EXTENT_REG || 526 found_type == BTRFS_FILE_EXTENT_PREALLOC)) { 527 struct btrfs_file_extent_item cmp1; 528 struct btrfs_file_extent_item cmp2; 529 struct btrfs_file_extent_item *existing; 530 struct extent_buffer *leaf; 531 532 leaf = path->nodes[0]; 533 existing = btrfs_item_ptr(leaf, path->slots[0], 534 struct btrfs_file_extent_item); 535 536 read_extent_buffer(eb, &cmp1, (unsigned long)item, 537 sizeof(cmp1)); 538 read_extent_buffer(leaf, &cmp2, (unsigned long)existing, 539 sizeof(cmp2)); 540 541 /* 542 * we already have a pointer to this exact extent, 543 * we don't have to do anything 544 */ 545 if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) { 546 btrfs_release_path(path); 547 goto out; 548 } 549 } 550 btrfs_release_path(path); 551 552 saved_nbytes = inode_get_bytes(inode); 553 /* drop any overlapping extents */ 554 ret = btrfs_drop_extents(trans, inode, start, extent_end, 555 &alloc_hint, 1); 556 BUG_ON(ret); 557 558 if (found_type == BTRFS_FILE_EXTENT_REG || 559 found_type == BTRFS_FILE_EXTENT_PREALLOC) { 560 u64 offset; 561 unsigned long dest_offset; 562 struct btrfs_key ins; 563 564 ret = btrfs_insert_empty_item(trans, root, path, key, 565 sizeof(*item)); 566 BUG_ON(ret); 567 dest_offset = btrfs_item_ptr_offset(path->nodes[0], 568 path->slots[0]); 569 copy_extent_buffer(path->nodes[0], eb, dest_offset, 570 (unsigned long)item, sizeof(*item)); 571 572 ins.objectid = btrfs_file_extent_disk_bytenr(eb, item); 573 ins.offset = btrfs_file_extent_disk_num_bytes(eb, item); 574 ins.type = BTRFS_EXTENT_ITEM_KEY; 575 offset = key->offset - btrfs_file_extent_offset(eb, item); 576 577 if (ins.objectid > 0) { 578 u64 csum_start; 579 u64 csum_end; 580 LIST_HEAD(ordered_sums); 581 /* 582 * is this extent already allocated in the extent 583 * allocation tree? If so, just add a reference 584 */ 585 ret = btrfs_lookup_extent(root, ins.objectid, 586 ins.offset); 587 if (ret == 0) { 588 ret = btrfs_inc_extent_ref(trans, root, 589 ins.objectid, ins.offset, 590 0, root->root_key.objectid, 591 key->objectid, offset); 592 BUG_ON(ret); 593 } else { 594 /* 595 * insert the extent pointer in the extent 596 * allocation tree 597 */ 598 ret = btrfs_alloc_logged_file_extent(trans, 599 root, root->root_key.objectid, 600 key->objectid, offset, &ins); 601 BUG_ON(ret); 602 } 603 btrfs_release_path(path); 604 605 if (btrfs_file_extent_compression(eb, item)) { 606 csum_start = ins.objectid; 607 csum_end = csum_start + ins.offset; 608 } else { 609 csum_start = ins.objectid + 610 btrfs_file_extent_offset(eb, item); 611 csum_end = csum_start + 612 btrfs_file_extent_num_bytes(eb, item); 613 } 614 615 ret = btrfs_lookup_csums_range(root->log_root, 616 csum_start, csum_end - 1, 617 &ordered_sums, 0); 618 BUG_ON(ret); 619 while (!list_empty(&ordered_sums)) { 620 struct btrfs_ordered_sum *sums; 621 sums = list_entry(ordered_sums.next, 622 struct btrfs_ordered_sum, 623 list); 624 ret = btrfs_csum_file_blocks(trans, 625 root->fs_info->csum_root, 626 sums); 627 BUG_ON(ret); 628 list_del(&sums->list); 629 kfree(sums); 630 } 631 } else { 632 btrfs_release_path(path); 633 } 634 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) { 635 /* inline extents are easy, we just overwrite them */ 636 ret = overwrite_item(trans, root, path, eb, slot, key); 637 BUG_ON(ret); 638 } 639 640 inode_set_bytes(inode, saved_nbytes); 641 btrfs_update_inode(trans, root, inode); 642 out: 643 if (inode) 644 iput(inode); 645 return ret; 646 } 647 648 /* 649 * when cleaning up conflicts between the directory names in the 650 * subvolume, directory names in the log and directory names in the 651 * inode back references, we may have to unlink inodes from directories. 652 * 653 * This is a helper function to do the unlink of a specific directory 654 * item 655 */ 656 static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans, 657 struct btrfs_root *root, 658 struct btrfs_path *path, 659 struct inode *dir, 660 struct btrfs_dir_item *di) 661 { 662 struct inode *inode; 663 char *name; 664 int name_len; 665 struct extent_buffer *leaf; 666 struct btrfs_key location; 667 int ret; 668 669 leaf = path->nodes[0]; 670 671 btrfs_dir_item_key_to_cpu(leaf, di, &location); 672 name_len = btrfs_dir_name_len(leaf, di); 673 name = kmalloc(name_len, GFP_NOFS); 674 if (!name) 675 return -ENOMEM; 676 677 read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len); 678 btrfs_release_path(path); 679 680 inode = read_one_inode(root, location.objectid); 681 if (!inode) { 682 kfree(name); 683 return -EIO; 684 } 685 686 ret = link_to_fixup_dir(trans, root, path, location.objectid); 687 BUG_ON(ret); 688 689 ret = btrfs_unlink_inode(trans, root, dir, inode, name, name_len); 690 BUG_ON(ret); 691 kfree(name); 692 693 iput(inode); 694 return ret; 695 } 696 697 /* 698 * helper function to see if a given name and sequence number found 699 * in an inode back reference are already in a directory and correctly 700 * point to this inode 701 */ 702 static noinline int inode_in_dir(struct btrfs_root *root, 703 struct btrfs_path *path, 704 u64 dirid, u64 objectid, u64 index, 705 const char *name, int name_len) 706 { 707 struct btrfs_dir_item *di; 708 struct btrfs_key location; 709 int match = 0; 710 711 di = btrfs_lookup_dir_index_item(NULL, root, path, dirid, 712 index, name, name_len, 0); 713 if (di && !IS_ERR(di)) { 714 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location); 715 if (location.objectid != objectid) 716 goto out; 717 } else 718 goto out; 719 btrfs_release_path(path); 720 721 di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0); 722 if (di && !IS_ERR(di)) { 723 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location); 724 if (location.objectid != objectid) 725 goto out; 726 } else 727 goto out; 728 match = 1; 729 out: 730 btrfs_release_path(path); 731 return match; 732 } 733 734 /* 735 * helper function to check a log tree for a named back reference in 736 * an inode. This is used to decide if a back reference that is 737 * found in the subvolume conflicts with what we find in the log. 738 * 739 * inode backreferences may have multiple refs in a single item, 740 * during replay we process one reference at a time, and we don't 741 * want to delete valid links to a file from the subvolume if that 742 * link is also in the log. 743 */ 744 static noinline int backref_in_log(struct btrfs_root *log, 745 struct btrfs_key *key, 746 char *name, int namelen) 747 { 748 struct btrfs_path *path; 749 struct btrfs_inode_ref *ref; 750 unsigned long ptr; 751 unsigned long ptr_end; 752 unsigned long name_ptr; 753 int found_name_len; 754 int item_size; 755 int ret; 756 int match = 0; 757 758 path = btrfs_alloc_path(); 759 if (!path) 760 return -ENOMEM; 761 762 ret = btrfs_search_slot(NULL, log, key, path, 0, 0); 763 if (ret != 0) 764 goto out; 765 766 item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]); 767 ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]); 768 ptr_end = ptr + item_size; 769 while (ptr < ptr_end) { 770 ref = (struct btrfs_inode_ref *)ptr; 771 found_name_len = btrfs_inode_ref_name_len(path->nodes[0], ref); 772 if (found_name_len == namelen) { 773 name_ptr = (unsigned long)(ref + 1); 774 ret = memcmp_extent_buffer(path->nodes[0], name, 775 name_ptr, namelen); 776 if (ret == 0) { 777 match = 1; 778 goto out; 779 } 780 } 781 ptr = (unsigned long)(ref + 1) + found_name_len; 782 } 783 out: 784 btrfs_free_path(path); 785 return match; 786 } 787 788 789 /* 790 * replay one inode back reference item found in the log tree. 791 * eb, slot and key refer to the buffer and key found in the log tree. 792 * root is the destination we are replaying into, and path is for temp 793 * use by this function. (it should be released on return). 794 */ 795 static noinline int add_inode_ref(struct btrfs_trans_handle *trans, 796 struct btrfs_root *root, 797 struct btrfs_root *log, 798 struct btrfs_path *path, 799 struct extent_buffer *eb, int slot, 800 struct btrfs_key *key) 801 { 802 struct inode *dir; 803 int ret; 804 struct btrfs_inode_ref *ref; 805 struct inode *inode; 806 char *name; 807 int namelen; 808 unsigned long ref_ptr; 809 unsigned long ref_end; 810 int search_done = 0; 811 812 /* 813 * it is possible that we didn't log all the parent directories 814 * for a given inode. If we don't find the dir, just don't 815 * copy the back ref in. The link count fixup code will take 816 * care of the rest 817 */ 818 dir = read_one_inode(root, key->offset); 819 if (!dir) 820 return -ENOENT; 821 822 inode = read_one_inode(root, key->objectid); 823 if (!inode) { 824 iput(dir); 825 return -EIO; 826 } 827 828 ref_ptr = btrfs_item_ptr_offset(eb, slot); 829 ref_end = ref_ptr + btrfs_item_size_nr(eb, slot); 830 831 again: 832 ref = (struct btrfs_inode_ref *)ref_ptr; 833 834 namelen = btrfs_inode_ref_name_len(eb, ref); 835 name = kmalloc(namelen, GFP_NOFS); 836 BUG_ON(!name); 837 838 read_extent_buffer(eb, name, (unsigned long)(ref + 1), namelen); 839 840 /* if we already have a perfect match, we're done */ 841 if (inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode), 842 btrfs_inode_ref_index(eb, ref), 843 name, namelen)) { 844 goto out; 845 } 846 847 /* 848 * look for a conflicting back reference in the metadata. 849 * if we find one we have to unlink that name of the file 850 * before we add our new link. Later on, we overwrite any 851 * existing back reference, and we don't want to create 852 * dangling pointers in the directory. 853 */ 854 855 if (search_done) 856 goto insert; 857 858 ret = btrfs_search_slot(NULL, root, key, path, 0, 0); 859 if (ret == 0) { 860 char *victim_name; 861 int victim_name_len; 862 struct btrfs_inode_ref *victim_ref; 863 unsigned long ptr; 864 unsigned long ptr_end; 865 struct extent_buffer *leaf = path->nodes[0]; 866 867 /* are we trying to overwrite a back ref for the root directory 868 * if so, just jump out, we're done 869 */ 870 if (key->objectid == key->offset) 871 goto out_nowrite; 872 873 /* check all the names in this back reference to see 874 * if they are in the log. if so, we allow them to stay 875 * otherwise they must be unlinked as a conflict 876 */ 877 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); 878 ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]); 879 while (ptr < ptr_end) { 880 victim_ref = (struct btrfs_inode_ref *)ptr; 881 victim_name_len = btrfs_inode_ref_name_len(leaf, 882 victim_ref); 883 victim_name = kmalloc(victim_name_len, GFP_NOFS); 884 BUG_ON(!victim_name); 885 886 read_extent_buffer(leaf, victim_name, 887 (unsigned long)(victim_ref + 1), 888 victim_name_len); 889 890 if (!backref_in_log(log, key, victim_name, 891 victim_name_len)) { 892 btrfs_inc_nlink(inode); 893 btrfs_release_path(path); 894 895 ret = btrfs_unlink_inode(trans, root, dir, 896 inode, victim_name, 897 victim_name_len); 898 } 899 kfree(victim_name); 900 ptr = (unsigned long)(victim_ref + 1) + victim_name_len; 901 } 902 BUG_ON(ret); 903 904 /* 905 * NOTE: we have searched root tree and checked the 906 * coresponding ref, it does not need to check again. 907 */ 908 search_done = 1; 909 } 910 btrfs_release_path(path); 911 912 insert: 913 /* insert our name */ 914 ret = btrfs_add_link(trans, dir, inode, name, namelen, 0, 915 btrfs_inode_ref_index(eb, ref)); 916 BUG_ON(ret); 917 918 btrfs_update_inode(trans, root, inode); 919 920 out: 921 ref_ptr = (unsigned long)(ref + 1) + namelen; 922 kfree(name); 923 if (ref_ptr < ref_end) 924 goto again; 925 926 /* finally write the back reference in the inode */ 927 ret = overwrite_item(trans, root, path, eb, slot, key); 928 BUG_ON(ret); 929 930 out_nowrite: 931 btrfs_release_path(path); 932 iput(dir); 933 iput(inode); 934 return 0; 935 } 936 937 static int insert_orphan_item(struct btrfs_trans_handle *trans, 938 struct btrfs_root *root, u64 offset) 939 { 940 int ret; 941 ret = btrfs_find_orphan_item(root, offset); 942 if (ret > 0) 943 ret = btrfs_insert_orphan_item(trans, root, offset); 944 return ret; 945 } 946 947 948 /* 949 * There are a few corners where the link count of the file can't 950 * be properly maintained during replay. So, instead of adding 951 * lots of complexity to the log code, we just scan the backrefs 952 * for any file that has been through replay. 953 * 954 * The scan will update the link count on the inode to reflect the 955 * number of back refs found. If it goes down to zero, the iput 956 * will free the inode. 957 */ 958 static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans, 959 struct btrfs_root *root, 960 struct inode *inode) 961 { 962 struct btrfs_path *path; 963 int ret; 964 struct btrfs_key key; 965 u64 nlink = 0; 966 unsigned long ptr; 967 unsigned long ptr_end; 968 int name_len; 969 u64 ino = btrfs_ino(inode); 970 971 key.objectid = ino; 972 key.type = BTRFS_INODE_REF_KEY; 973 key.offset = (u64)-1; 974 975 path = btrfs_alloc_path(); 976 if (!path) 977 return -ENOMEM; 978 979 while (1) { 980 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 981 if (ret < 0) 982 break; 983 if (ret > 0) { 984 if (path->slots[0] == 0) 985 break; 986 path->slots[0]--; 987 } 988 btrfs_item_key_to_cpu(path->nodes[0], &key, 989 path->slots[0]); 990 if (key.objectid != ino || 991 key.type != BTRFS_INODE_REF_KEY) 992 break; 993 ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]); 994 ptr_end = ptr + btrfs_item_size_nr(path->nodes[0], 995 path->slots[0]); 996 while (ptr < ptr_end) { 997 struct btrfs_inode_ref *ref; 998 999 ref = (struct btrfs_inode_ref *)ptr; 1000 name_len = btrfs_inode_ref_name_len(path->nodes[0], 1001 ref); 1002 ptr = (unsigned long)(ref + 1) + name_len; 1003 nlink++; 1004 } 1005 1006 if (key.offset == 0) 1007 break; 1008 key.offset--; 1009 btrfs_release_path(path); 1010 } 1011 btrfs_release_path(path); 1012 if (nlink != inode->i_nlink) { 1013 inode->i_nlink = nlink; 1014 btrfs_update_inode(trans, root, inode); 1015 } 1016 BTRFS_I(inode)->index_cnt = (u64)-1; 1017 1018 if (inode->i_nlink == 0) { 1019 if (S_ISDIR(inode->i_mode)) { 1020 ret = replay_dir_deletes(trans, root, NULL, path, 1021 ino, 1); 1022 BUG_ON(ret); 1023 } 1024 ret = insert_orphan_item(trans, root, ino); 1025 BUG_ON(ret); 1026 } 1027 btrfs_free_path(path); 1028 1029 return 0; 1030 } 1031 1032 static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans, 1033 struct btrfs_root *root, 1034 struct btrfs_path *path) 1035 { 1036 int ret; 1037 struct btrfs_key key; 1038 struct inode *inode; 1039 1040 key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID; 1041 key.type = BTRFS_ORPHAN_ITEM_KEY; 1042 key.offset = (u64)-1; 1043 while (1) { 1044 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 1045 if (ret < 0) 1046 break; 1047 1048 if (ret == 1) { 1049 if (path->slots[0] == 0) 1050 break; 1051 path->slots[0]--; 1052 } 1053 1054 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 1055 if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID || 1056 key.type != BTRFS_ORPHAN_ITEM_KEY) 1057 break; 1058 1059 ret = btrfs_del_item(trans, root, path); 1060 if (ret) 1061 goto out; 1062 1063 btrfs_release_path(path); 1064 inode = read_one_inode(root, key.offset); 1065 if (!inode) 1066 return -EIO; 1067 1068 ret = fixup_inode_link_count(trans, root, inode); 1069 BUG_ON(ret); 1070 1071 iput(inode); 1072 1073 /* 1074 * fixup on a directory may create new entries, 1075 * make sure we always look for the highset possible 1076 * offset 1077 */ 1078 key.offset = (u64)-1; 1079 } 1080 ret = 0; 1081 out: 1082 btrfs_release_path(path); 1083 return ret; 1084 } 1085 1086 1087 /* 1088 * record a given inode in the fixup dir so we can check its link 1089 * count when replay is done. The link count is incremented here 1090 * so the inode won't go away until we check it 1091 */ 1092 static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans, 1093 struct btrfs_root *root, 1094 struct btrfs_path *path, 1095 u64 objectid) 1096 { 1097 struct btrfs_key key; 1098 int ret = 0; 1099 struct inode *inode; 1100 1101 inode = read_one_inode(root, objectid); 1102 if (!inode) 1103 return -EIO; 1104 1105 key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID; 1106 btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY); 1107 key.offset = objectid; 1108 1109 ret = btrfs_insert_empty_item(trans, root, path, &key, 0); 1110 1111 btrfs_release_path(path); 1112 if (ret == 0) { 1113 btrfs_inc_nlink(inode); 1114 btrfs_update_inode(trans, root, inode); 1115 } else if (ret == -EEXIST) { 1116 ret = 0; 1117 } else { 1118 BUG(); 1119 } 1120 iput(inode); 1121 1122 return ret; 1123 } 1124 1125 /* 1126 * when replaying the log for a directory, we only insert names 1127 * for inodes that actually exist. This means an fsync on a directory 1128 * does not implicitly fsync all the new files in it 1129 */ 1130 static noinline int insert_one_name(struct btrfs_trans_handle *trans, 1131 struct btrfs_root *root, 1132 struct btrfs_path *path, 1133 u64 dirid, u64 index, 1134 char *name, int name_len, u8 type, 1135 struct btrfs_key *location) 1136 { 1137 struct inode *inode; 1138 struct inode *dir; 1139 int ret; 1140 1141 inode = read_one_inode(root, location->objectid); 1142 if (!inode) 1143 return -ENOENT; 1144 1145 dir = read_one_inode(root, dirid); 1146 if (!dir) { 1147 iput(inode); 1148 return -EIO; 1149 } 1150 ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index); 1151 1152 /* FIXME, put inode into FIXUP list */ 1153 1154 iput(inode); 1155 iput(dir); 1156 return ret; 1157 } 1158 1159 /* 1160 * take a single entry in a log directory item and replay it into 1161 * the subvolume. 1162 * 1163 * if a conflicting item exists in the subdirectory already, 1164 * the inode it points to is unlinked and put into the link count 1165 * fix up tree. 1166 * 1167 * If a name from the log points to a file or directory that does 1168 * not exist in the FS, it is skipped. fsyncs on directories 1169 * do not force down inodes inside that directory, just changes to the 1170 * names or unlinks in a directory. 1171 */ 1172 static noinline int replay_one_name(struct btrfs_trans_handle *trans, 1173 struct btrfs_root *root, 1174 struct btrfs_path *path, 1175 struct extent_buffer *eb, 1176 struct btrfs_dir_item *di, 1177 struct btrfs_key *key) 1178 { 1179 char *name; 1180 int name_len; 1181 struct btrfs_dir_item *dst_di; 1182 struct btrfs_key found_key; 1183 struct btrfs_key log_key; 1184 struct inode *dir; 1185 u8 log_type; 1186 int exists; 1187 int ret; 1188 1189 dir = read_one_inode(root, key->objectid); 1190 if (!dir) 1191 return -EIO; 1192 1193 name_len = btrfs_dir_name_len(eb, di); 1194 name = kmalloc(name_len, GFP_NOFS); 1195 if (!name) 1196 return -ENOMEM; 1197 1198 log_type = btrfs_dir_type(eb, di); 1199 read_extent_buffer(eb, name, (unsigned long)(di + 1), 1200 name_len); 1201 1202 btrfs_dir_item_key_to_cpu(eb, di, &log_key); 1203 exists = btrfs_lookup_inode(trans, root, path, &log_key, 0); 1204 if (exists == 0) 1205 exists = 1; 1206 else 1207 exists = 0; 1208 btrfs_release_path(path); 1209 1210 if (key->type == BTRFS_DIR_ITEM_KEY) { 1211 dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid, 1212 name, name_len, 1); 1213 } else if (key->type == BTRFS_DIR_INDEX_KEY) { 1214 dst_di = btrfs_lookup_dir_index_item(trans, root, path, 1215 key->objectid, 1216 key->offset, name, 1217 name_len, 1); 1218 } else { 1219 BUG(); 1220 } 1221 if (IS_ERR_OR_NULL(dst_di)) { 1222 /* we need a sequence number to insert, so we only 1223 * do inserts for the BTRFS_DIR_INDEX_KEY types 1224 */ 1225 if (key->type != BTRFS_DIR_INDEX_KEY) 1226 goto out; 1227 goto insert; 1228 } 1229 1230 btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key); 1231 /* the existing item matches the logged item */ 1232 if (found_key.objectid == log_key.objectid && 1233 found_key.type == log_key.type && 1234 found_key.offset == log_key.offset && 1235 btrfs_dir_type(path->nodes[0], dst_di) == log_type) { 1236 goto out; 1237 } 1238 1239 /* 1240 * don't drop the conflicting directory entry if the inode 1241 * for the new entry doesn't exist 1242 */ 1243 if (!exists) 1244 goto out; 1245 1246 ret = drop_one_dir_item(trans, root, path, dir, dst_di); 1247 BUG_ON(ret); 1248 1249 if (key->type == BTRFS_DIR_INDEX_KEY) 1250 goto insert; 1251 out: 1252 btrfs_release_path(path); 1253 kfree(name); 1254 iput(dir); 1255 return 0; 1256 1257 insert: 1258 btrfs_release_path(path); 1259 ret = insert_one_name(trans, root, path, key->objectid, key->offset, 1260 name, name_len, log_type, &log_key); 1261 1262 BUG_ON(ret && ret != -ENOENT); 1263 goto out; 1264 } 1265 1266 /* 1267 * find all the names in a directory item and reconcile them into 1268 * the subvolume. Only BTRFS_DIR_ITEM_KEY types will have more than 1269 * one name in a directory item, but the same code gets used for 1270 * both directory index types 1271 */ 1272 static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans, 1273 struct btrfs_root *root, 1274 struct btrfs_path *path, 1275 struct extent_buffer *eb, int slot, 1276 struct btrfs_key *key) 1277 { 1278 int ret; 1279 u32 item_size = btrfs_item_size_nr(eb, slot); 1280 struct btrfs_dir_item *di; 1281 int name_len; 1282 unsigned long ptr; 1283 unsigned long ptr_end; 1284 1285 ptr = btrfs_item_ptr_offset(eb, slot); 1286 ptr_end = ptr + item_size; 1287 while (ptr < ptr_end) { 1288 di = (struct btrfs_dir_item *)ptr; 1289 if (verify_dir_item(root, eb, di)) 1290 return -EIO; 1291 name_len = btrfs_dir_name_len(eb, di); 1292 ret = replay_one_name(trans, root, path, eb, di, key); 1293 BUG_ON(ret); 1294 ptr = (unsigned long)(di + 1); 1295 ptr += name_len; 1296 } 1297 return 0; 1298 } 1299 1300 /* 1301 * directory replay has two parts. There are the standard directory 1302 * items in the log copied from the subvolume, and range items 1303 * created in the log while the subvolume was logged. 1304 * 1305 * The range items tell us which parts of the key space the log 1306 * is authoritative for. During replay, if a key in the subvolume 1307 * directory is in a logged range item, but not actually in the log 1308 * that means it was deleted from the directory before the fsync 1309 * and should be removed. 1310 */ 1311 static noinline int find_dir_range(struct btrfs_root *root, 1312 struct btrfs_path *path, 1313 u64 dirid, int key_type, 1314 u64 *start_ret, u64 *end_ret) 1315 { 1316 struct btrfs_key key; 1317 u64 found_end; 1318 struct btrfs_dir_log_item *item; 1319 int ret; 1320 int nritems; 1321 1322 if (*start_ret == (u64)-1) 1323 return 1; 1324 1325 key.objectid = dirid; 1326 key.type = key_type; 1327 key.offset = *start_ret; 1328 1329 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 1330 if (ret < 0) 1331 goto out; 1332 if (ret > 0) { 1333 if (path->slots[0] == 0) 1334 goto out; 1335 path->slots[0]--; 1336 } 1337 if (ret != 0) 1338 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 1339 1340 if (key.type != key_type || key.objectid != dirid) { 1341 ret = 1; 1342 goto next; 1343 } 1344 item = btrfs_item_ptr(path->nodes[0], path->slots[0], 1345 struct btrfs_dir_log_item); 1346 found_end = btrfs_dir_log_end(path->nodes[0], item); 1347 1348 if (*start_ret >= key.offset && *start_ret <= found_end) { 1349 ret = 0; 1350 *start_ret = key.offset; 1351 *end_ret = found_end; 1352 goto out; 1353 } 1354 ret = 1; 1355 next: 1356 /* check the next slot in the tree to see if it is a valid item */ 1357 nritems = btrfs_header_nritems(path->nodes[0]); 1358 if (path->slots[0] >= nritems) { 1359 ret = btrfs_next_leaf(root, path); 1360 if (ret) 1361 goto out; 1362 } else { 1363 path->slots[0]++; 1364 } 1365 1366 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 1367 1368 if (key.type != key_type || key.objectid != dirid) { 1369 ret = 1; 1370 goto out; 1371 } 1372 item = btrfs_item_ptr(path->nodes[0], path->slots[0], 1373 struct btrfs_dir_log_item); 1374 found_end = btrfs_dir_log_end(path->nodes[0], item); 1375 *start_ret = key.offset; 1376 *end_ret = found_end; 1377 ret = 0; 1378 out: 1379 btrfs_release_path(path); 1380 return ret; 1381 } 1382 1383 /* 1384 * this looks for a given directory item in the log. If the directory 1385 * item is not in the log, the item is removed and the inode it points 1386 * to is unlinked 1387 */ 1388 static noinline int check_item_in_log(struct btrfs_trans_handle *trans, 1389 struct btrfs_root *root, 1390 struct btrfs_root *log, 1391 struct btrfs_path *path, 1392 struct btrfs_path *log_path, 1393 struct inode *dir, 1394 struct btrfs_key *dir_key) 1395 { 1396 int ret; 1397 struct extent_buffer *eb; 1398 int slot; 1399 u32 item_size; 1400 struct btrfs_dir_item *di; 1401 struct btrfs_dir_item *log_di; 1402 int name_len; 1403 unsigned long ptr; 1404 unsigned long ptr_end; 1405 char *name; 1406 struct inode *inode; 1407 struct btrfs_key location; 1408 1409 again: 1410 eb = path->nodes[0]; 1411 slot = path->slots[0]; 1412 item_size = btrfs_item_size_nr(eb, slot); 1413 ptr = btrfs_item_ptr_offset(eb, slot); 1414 ptr_end = ptr + item_size; 1415 while (ptr < ptr_end) { 1416 di = (struct btrfs_dir_item *)ptr; 1417 if (verify_dir_item(root, eb, di)) { 1418 ret = -EIO; 1419 goto out; 1420 } 1421 1422 name_len = btrfs_dir_name_len(eb, di); 1423 name = kmalloc(name_len, GFP_NOFS); 1424 if (!name) { 1425 ret = -ENOMEM; 1426 goto out; 1427 } 1428 read_extent_buffer(eb, name, (unsigned long)(di + 1), 1429 name_len); 1430 log_di = NULL; 1431 if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) { 1432 log_di = btrfs_lookup_dir_item(trans, log, log_path, 1433 dir_key->objectid, 1434 name, name_len, 0); 1435 } else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) { 1436 log_di = btrfs_lookup_dir_index_item(trans, log, 1437 log_path, 1438 dir_key->objectid, 1439 dir_key->offset, 1440 name, name_len, 0); 1441 } 1442 if (IS_ERR_OR_NULL(log_di)) { 1443 btrfs_dir_item_key_to_cpu(eb, di, &location); 1444 btrfs_release_path(path); 1445 btrfs_release_path(log_path); 1446 inode = read_one_inode(root, location.objectid); 1447 if (!inode) { 1448 kfree(name); 1449 return -EIO; 1450 } 1451 1452 ret = link_to_fixup_dir(trans, root, 1453 path, location.objectid); 1454 BUG_ON(ret); 1455 btrfs_inc_nlink(inode); 1456 ret = btrfs_unlink_inode(trans, root, dir, inode, 1457 name, name_len); 1458 BUG_ON(ret); 1459 kfree(name); 1460 iput(inode); 1461 1462 /* there might still be more names under this key 1463 * check and repeat if required 1464 */ 1465 ret = btrfs_search_slot(NULL, root, dir_key, path, 1466 0, 0); 1467 if (ret == 0) 1468 goto again; 1469 ret = 0; 1470 goto out; 1471 } 1472 btrfs_release_path(log_path); 1473 kfree(name); 1474 1475 ptr = (unsigned long)(di + 1); 1476 ptr += name_len; 1477 } 1478 ret = 0; 1479 out: 1480 btrfs_release_path(path); 1481 btrfs_release_path(log_path); 1482 return ret; 1483 } 1484 1485 /* 1486 * deletion replay happens before we copy any new directory items 1487 * out of the log or out of backreferences from inodes. It 1488 * scans the log to find ranges of keys that log is authoritative for, 1489 * and then scans the directory to find items in those ranges that are 1490 * not present in the log. 1491 * 1492 * Anything we don't find in the log is unlinked and removed from the 1493 * directory. 1494 */ 1495 static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans, 1496 struct btrfs_root *root, 1497 struct btrfs_root *log, 1498 struct btrfs_path *path, 1499 u64 dirid, int del_all) 1500 { 1501 u64 range_start; 1502 u64 range_end; 1503 int key_type = BTRFS_DIR_LOG_ITEM_KEY; 1504 int ret = 0; 1505 struct btrfs_key dir_key; 1506 struct btrfs_key found_key; 1507 struct btrfs_path *log_path; 1508 struct inode *dir; 1509 1510 dir_key.objectid = dirid; 1511 dir_key.type = BTRFS_DIR_ITEM_KEY; 1512 log_path = btrfs_alloc_path(); 1513 if (!log_path) 1514 return -ENOMEM; 1515 1516 dir = read_one_inode(root, dirid); 1517 /* it isn't an error if the inode isn't there, that can happen 1518 * because we replay the deletes before we copy in the inode item 1519 * from the log 1520 */ 1521 if (!dir) { 1522 btrfs_free_path(log_path); 1523 return 0; 1524 } 1525 again: 1526 range_start = 0; 1527 range_end = 0; 1528 while (1) { 1529 if (del_all) 1530 range_end = (u64)-1; 1531 else { 1532 ret = find_dir_range(log, path, dirid, key_type, 1533 &range_start, &range_end); 1534 if (ret != 0) 1535 break; 1536 } 1537 1538 dir_key.offset = range_start; 1539 while (1) { 1540 int nritems; 1541 ret = btrfs_search_slot(NULL, root, &dir_key, path, 1542 0, 0); 1543 if (ret < 0) 1544 goto out; 1545 1546 nritems = btrfs_header_nritems(path->nodes[0]); 1547 if (path->slots[0] >= nritems) { 1548 ret = btrfs_next_leaf(root, path); 1549 if (ret) 1550 break; 1551 } 1552 btrfs_item_key_to_cpu(path->nodes[0], &found_key, 1553 path->slots[0]); 1554 if (found_key.objectid != dirid || 1555 found_key.type != dir_key.type) 1556 goto next_type; 1557 1558 if (found_key.offset > range_end) 1559 break; 1560 1561 ret = check_item_in_log(trans, root, log, path, 1562 log_path, dir, 1563 &found_key); 1564 BUG_ON(ret); 1565 if (found_key.offset == (u64)-1) 1566 break; 1567 dir_key.offset = found_key.offset + 1; 1568 } 1569 btrfs_release_path(path); 1570 if (range_end == (u64)-1) 1571 break; 1572 range_start = range_end + 1; 1573 } 1574 1575 next_type: 1576 ret = 0; 1577 if (key_type == BTRFS_DIR_LOG_ITEM_KEY) { 1578 key_type = BTRFS_DIR_LOG_INDEX_KEY; 1579 dir_key.type = BTRFS_DIR_INDEX_KEY; 1580 btrfs_release_path(path); 1581 goto again; 1582 } 1583 out: 1584 btrfs_release_path(path); 1585 btrfs_free_path(log_path); 1586 iput(dir); 1587 return ret; 1588 } 1589 1590 /* 1591 * the process_func used to replay items from the log tree. This 1592 * gets called in two different stages. The first stage just looks 1593 * for inodes and makes sure they are all copied into the subvolume. 1594 * 1595 * The second stage copies all the other item types from the log into 1596 * the subvolume. The two stage approach is slower, but gets rid of 1597 * lots of complexity around inodes referencing other inodes that exist 1598 * only in the log (references come from either directory items or inode 1599 * back refs). 1600 */ 1601 static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb, 1602 struct walk_control *wc, u64 gen) 1603 { 1604 int nritems; 1605 struct btrfs_path *path; 1606 struct btrfs_root *root = wc->replay_dest; 1607 struct btrfs_key key; 1608 int level; 1609 int i; 1610 int ret; 1611 1612 btrfs_read_buffer(eb, gen); 1613 1614 level = btrfs_header_level(eb); 1615 1616 if (level != 0) 1617 return 0; 1618 1619 path = btrfs_alloc_path(); 1620 if (!path) 1621 return -ENOMEM; 1622 1623 nritems = btrfs_header_nritems(eb); 1624 for (i = 0; i < nritems; i++) { 1625 btrfs_item_key_to_cpu(eb, &key, i); 1626 1627 /* inode keys are done during the first stage */ 1628 if (key.type == BTRFS_INODE_ITEM_KEY && 1629 wc->stage == LOG_WALK_REPLAY_INODES) { 1630 struct btrfs_inode_item *inode_item; 1631 u32 mode; 1632 1633 inode_item = btrfs_item_ptr(eb, i, 1634 struct btrfs_inode_item); 1635 mode = btrfs_inode_mode(eb, inode_item); 1636 if (S_ISDIR(mode)) { 1637 ret = replay_dir_deletes(wc->trans, 1638 root, log, path, key.objectid, 0); 1639 BUG_ON(ret); 1640 } 1641 ret = overwrite_item(wc->trans, root, path, 1642 eb, i, &key); 1643 BUG_ON(ret); 1644 1645 /* for regular files, make sure corresponding 1646 * orhpan item exist. extents past the new EOF 1647 * will be truncated later by orphan cleanup. 1648 */ 1649 if (S_ISREG(mode)) { 1650 ret = insert_orphan_item(wc->trans, root, 1651 key.objectid); 1652 BUG_ON(ret); 1653 } 1654 1655 ret = link_to_fixup_dir(wc->trans, root, 1656 path, key.objectid); 1657 BUG_ON(ret); 1658 } 1659 if (wc->stage < LOG_WALK_REPLAY_ALL) 1660 continue; 1661 1662 /* these keys are simply copied */ 1663 if (key.type == BTRFS_XATTR_ITEM_KEY) { 1664 ret = overwrite_item(wc->trans, root, path, 1665 eb, i, &key); 1666 BUG_ON(ret); 1667 } else if (key.type == BTRFS_INODE_REF_KEY) { 1668 ret = add_inode_ref(wc->trans, root, log, path, 1669 eb, i, &key); 1670 BUG_ON(ret && ret != -ENOENT); 1671 } else if (key.type == BTRFS_EXTENT_DATA_KEY) { 1672 ret = replay_one_extent(wc->trans, root, path, 1673 eb, i, &key); 1674 BUG_ON(ret); 1675 } else if (key.type == BTRFS_DIR_ITEM_KEY || 1676 key.type == BTRFS_DIR_INDEX_KEY) { 1677 ret = replay_one_dir_item(wc->trans, root, path, 1678 eb, i, &key); 1679 BUG_ON(ret); 1680 } 1681 } 1682 btrfs_free_path(path); 1683 return 0; 1684 } 1685 1686 static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans, 1687 struct btrfs_root *root, 1688 struct btrfs_path *path, int *level, 1689 struct walk_control *wc) 1690 { 1691 u64 root_owner; 1692 u64 bytenr; 1693 u64 ptr_gen; 1694 struct extent_buffer *next; 1695 struct extent_buffer *cur; 1696 struct extent_buffer *parent; 1697 u32 blocksize; 1698 int ret = 0; 1699 1700 WARN_ON(*level < 0); 1701 WARN_ON(*level >= BTRFS_MAX_LEVEL); 1702 1703 while (*level > 0) { 1704 WARN_ON(*level < 0); 1705 WARN_ON(*level >= BTRFS_MAX_LEVEL); 1706 cur = path->nodes[*level]; 1707 1708 if (btrfs_header_level(cur) != *level) 1709 WARN_ON(1); 1710 1711 if (path->slots[*level] >= 1712 btrfs_header_nritems(cur)) 1713 break; 1714 1715 bytenr = btrfs_node_blockptr(cur, path->slots[*level]); 1716 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]); 1717 blocksize = btrfs_level_size(root, *level - 1); 1718 1719 parent = path->nodes[*level]; 1720 root_owner = btrfs_header_owner(parent); 1721 1722 next = btrfs_find_create_tree_block(root, bytenr, blocksize); 1723 if (!next) 1724 return -ENOMEM; 1725 1726 if (*level == 1) { 1727 ret = wc->process_func(root, next, wc, ptr_gen); 1728 if (ret) 1729 return ret; 1730 1731 path->slots[*level]++; 1732 if (wc->free) { 1733 btrfs_read_buffer(next, ptr_gen); 1734 1735 btrfs_tree_lock(next); 1736 btrfs_set_lock_blocking(next); 1737 clean_tree_block(trans, root, next); 1738 btrfs_wait_tree_block_writeback(next); 1739 btrfs_tree_unlock(next); 1740 1741 WARN_ON(root_owner != 1742 BTRFS_TREE_LOG_OBJECTID); 1743 ret = btrfs_free_reserved_extent(root, 1744 bytenr, blocksize); 1745 BUG_ON(ret); 1746 } 1747 free_extent_buffer(next); 1748 continue; 1749 } 1750 btrfs_read_buffer(next, ptr_gen); 1751 1752 WARN_ON(*level <= 0); 1753 if (path->nodes[*level-1]) 1754 free_extent_buffer(path->nodes[*level-1]); 1755 path->nodes[*level-1] = next; 1756 *level = btrfs_header_level(next); 1757 path->slots[*level] = 0; 1758 cond_resched(); 1759 } 1760 WARN_ON(*level < 0); 1761 WARN_ON(*level >= BTRFS_MAX_LEVEL); 1762 1763 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]); 1764 1765 cond_resched(); 1766 return 0; 1767 } 1768 1769 static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans, 1770 struct btrfs_root *root, 1771 struct btrfs_path *path, int *level, 1772 struct walk_control *wc) 1773 { 1774 u64 root_owner; 1775 int i; 1776 int slot; 1777 int ret; 1778 1779 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) { 1780 slot = path->slots[i]; 1781 if (slot + 1 < btrfs_header_nritems(path->nodes[i])) { 1782 path->slots[i]++; 1783 *level = i; 1784 WARN_ON(*level == 0); 1785 return 0; 1786 } else { 1787 struct extent_buffer *parent; 1788 if (path->nodes[*level] == root->node) 1789 parent = path->nodes[*level]; 1790 else 1791 parent = path->nodes[*level + 1]; 1792 1793 root_owner = btrfs_header_owner(parent); 1794 ret = wc->process_func(root, path->nodes[*level], wc, 1795 btrfs_header_generation(path->nodes[*level])); 1796 if (ret) 1797 return ret; 1798 1799 if (wc->free) { 1800 struct extent_buffer *next; 1801 1802 next = path->nodes[*level]; 1803 1804 btrfs_tree_lock(next); 1805 btrfs_set_lock_blocking(next); 1806 clean_tree_block(trans, root, next); 1807 btrfs_wait_tree_block_writeback(next); 1808 btrfs_tree_unlock(next); 1809 1810 WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID); 1811 ret = btrfs_free_reserved_extent(root, 1812 path->nodes[*level]->start, 1813 path->nodes[*level]->len); 1814 BUG_ON(ret); 1815 } 1816 free_extent_buffer(path->nodes[*level]); 1817 path->nodes[*level] = NULL; 1818 *level = i + 1; 1819 } 1820 } 1821 return 1; 1822 } 1823 1824 /* 1825 * drop the reference count on the tree rooted at 'snap'. This traverses 1826 * the tree freeing any blocks that have a ref count of zero after being 1827 * decremented. 1828 */ 1829 static int walk_log_tree(struct btrfs_trans_handle *trans, 1830 struct btrfs_root *log, struct walk_control *wc) 1831 { 1832 int ret = 0; 1833 int wret; 1834 int level; 1835 struct btrfs_path *path; 1836 int i; 1837 int orig_level; 1838 1839 path = btrfs_alloc_path(); 1840 if (!path) 1841 return -ENOMEM; 1842 1843 level = btrfs_header_level(log->node); 1844 orig_level = level; 1845 path->nodes[level] = log->node; 1846 extent_buffer_get(log->node); 1847 path->slots[level] = 0; 1848 1849 while (1) { 1850 wret = walk_down_log_tree(trans, log, path, &level, wc); 1851 if (wret > 0) 1852 break; 1853 if (wret < 0) 1854 ret = wret; 1855 1856 wret = walk_up_log_tree(trans, log, path, &level, wc); 1857 if (wret > 0) 1858 break; 1859 if (wret < 0) 1860 ret = wret; 1861 } 1862 1863 /* was the root node processed? if not, catch it here */ 1864 if (path->nodes[orig_level]) { 1865 wc->process_func(log, path->nodes[orig_level], wc, 1866 btrfs_header_generation(path->nodes[orig_level])); 1867 if (wc->free) { 1868 struct extent_buffer *next; 1869 1870 next = path->nodes[orig_level]; 1871 1872 btrfs_tree_lock(next); 1873 btrfs_set_lock_blocking(next); 1874 clean_tree_block(trans, log, next); 1875 btrfs_wait_tree_block_writeback(next); 1876 btrfs_tree_unlock(next); 1877 1878 WARN_ON(log->root_key.objectid != 1879 BTRFS_TREE_LOG_OBJECTID); 1880 ret = btrfs_free_reserved_extent(log, next->start, 1881 next->len); 1882 BUG_ON(ret); 1883 } 1884 } 1885 1886 for (i = 0; i <= orig_level; i++) { 1887 if (path->nodes[i]) { 1888 free_extent_buffer(path->nodes[i]); 1889 path->nodes[i] = NULL; 1890 } 1891 } 1892 btrfs_free_path(path); 1893 return ret; 1894 } 1895 1896 /* 1897 * helper function to update the item for a given subvolumes log root 1898 * in the tree of log roots 1899 */ 1900 static int update_log_root(struct btrfs_trans_handle *trans, 1901 struct btrfs_root *log) 1902 { 1903 int ret; 1904 1905 if (log->log_transid == 1) { 1906 /* insert root item on the first sync */ 1907 ret = btrfs_insert_root(trans, log->fs_info->log_root_tree, 1908 &log->root_key, &log->root_item); 1909 } else { 1910 ret = btrfs_update_root(trans, log->fs_info->log_root_tree, 1911 &log->root_key, &log->root_item); 1912 } 1913 return ret; 1914 } 1915 1916 static int wait_log_commit(struct btrfs_trans_handle *trans, 1917 struct btrfs_root *root, unsigned long transid) 1918 { 1919 DEFINE_WAIT(wait); 1920 int index = transid % 2; 1921 1922 /* 1923 * we only allow two pending log transactions at a time, 1924 * so we know that if ours is more than 2 older than the 1925 * current transaction, we're done 1926 */ 1927 do { 1928 prepare_to_wait(&root->log_commit_wait[index], 1929 &wait, TASK_UNINTERRUPTIBLE); 1930 mutex_unlock(&root->log_mutex); 1931 1932 if (root->fs_info->last_trans_log_full_commit != 1933 trans->transid && root->log_transid < transid + 2 && 1934 atomic_read(&root->log_commit[index])) 1935 schedule(); 1936 1937 finish_wait(&root->log_commit_wait[index], &wait); 1938 mutex_lock(&root->log_mutex); 1939 } while (root->log_transid < transid + 2 && 1940 atomic_read(&root->log_commit[index])); 1941 return 0; 1942 } 1943 1944 static int wait_for_writer(struct btrfs_trans_handle *trans, 1945 struct btrfs_root *root) 1946 { 1947 DEFINE_WAIT(wait); 1948 while (atomic_read(&root->log_writers)) { 1949 prepare_to_wait(&root->log_writer_wait, 1950 &wait, TASK_UNINTERRUPTIBLE); 1951 mutex_unlock(&root->log_mutex); 1952 if (root->fs_info->last_trans_log_full_commit != 1953 trans->transid && atomic_read(&root->log_writers)) 1954 schedule(); 1955 mutex_lock(&root->log_mutex); 1956 finish_wait(&root->log_writer_wait, &wait); 1957 } 1958 return 0; 1959 } 1960 1961 /* 1962 * btrfs_sync_log does sends a given tree log down to the disk and 1963 * updates the super blocks to record it. When this call is done, 1964 * you know that any inodes previously logged are safely on disk only 1965 * if it returns 0. 1966 * 1967 * Any other return value means you need to call btrfs_commit_transaction. 1968 * Some of the edge cases for fsyncing directories that have had unlinks 1969 * or renames done in the past mean that sometimes the only safe 1970 * fsync is to commit the whole FS. When btrfs_sync_log returns -EAGAIN, 1971 * that has happened. 1972 */ 1973 int btrfs_sync_log(struct btrfs_trans_handle *trans, 1974 struct btrfs_root *root) 1975 { 1976 int index1; 1977 int index2; 1978 int mark; 1979 int ret; 1980 struct btrfs_root *log = root->log_root; 1981 struct btrfs_root *log_root_tree = root->fs_info->log_root_tree; 1982 unsigned long log_transid = 0; 1983 1984 mutex_lock(&root->log_mutex); 1985 index1 = root->log_transid % 2; 1986 if (atomic_read(&root->log_commit[index1])) { 1987 wait_log_commit(trans, root, root->log_transid); 1988 mutex_unlock(&root->log_mutex); 1989 return 0; 1990 } 1991 atomic_set(&root->log_commit[index1], 1); 1992 1993 /* wait for previous tree log sync to complete */ 1994 if (atomic_read(&root->log_commit[(index1 + 1) % 2])) 1995 wait_log_commit(trans, root, root->log_transid - 1); 1996 1997 while (1) { 1998 unsigned long batch = root->log_batch; 1999 if (root->log_multiple_pids) { 2000 mutex_unlock(&root->log_mutex); 2001 schedule_timeout_uninterruptible(1); 2002 mutex_lock(&root->log_mutex); 2003 } 2004 wait_for_writer(trans, root); 2005 if (batch == root->log_batch) 2006 break; 2007 } 2008 2009 /* bail out if we need to do a full commit */ 2010 if (root->fs_info->last_trans_log_full_commit == trans->transid) { 2011 ret = -EAGAIN; 2012 mutex_unlock(&root->log_mutex); 2013 goto out; 2014 } 2015 2016 log_transid = root->log_transid; 2017 if (log_transid % 2 == 0) 2018 mark = EXTENT_DIRTY; 2019 else 2020 mark = EXTENT_NEW; 2021 2022 /* we start IO on all the marked extents here, but we don't actually 2023 * wait for them until later. 2024 */ 2025 ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark); 2026 BUG_ON(ret); 2027 2028 btrfs_set_root_node(&log->root_item, log->node); 2029 2030 root->log_batch = 0; 2031 root->log_transid++; 2032 log->log_transid = root->log_transid; 2033 root->log_start_pid = 0; 2034 smp_mb(); 2035 /* 2036 * IO has been started, blocks of the log tree have WRITTEN flag set 2037 * in their headers. new modifications of the log will be written to 2038 * new positions. so it's safe to allow log writers to go in. 2039 */ 2040 mutex_unlock(&root->log_mutex); 2041 2042 mutex_lock(&log_root_tree->log_mutex); 2043 log_root_tree->log_batch++; 2044 atomic_inc(&log_root_tree->log_writers); 2045 mutex_unlock(&log_root_tree->log_mutex); 2046 2047 ret = update_log_root(trans, log); 2048 2049 mutex_lock(&log_root_tree->log_mutex); 2050 if (atomic_dec_and_test(&log_root_tree->log_writers)) { 2051 smp_mb(); 2052 if (waitqueue_active(&log_root_tree->log_writer_wait)) 2053 wake_up(&log_root_tree->log_writer_wait); 2054 } 2055 2056 if (ret) { 2057 BUG_ON(ret != -ENOSPC); 2058 root->fs_info->last_trans_log_full_commit = trans->transid; 2059 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark); 2060 mutex_unlock(&log_root_tree->log_mutex); 2061 ret = -EAGAIN; 2062 goto out; 2063 } 2064 2065 index2 = log_root_tree->log_transid % 2; 2066 if (atomic_read(&log_root_tree->log_commit[index2])) { 2067 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark); 2068 wait_log_commit(trans, log_root_tree, 2069 log_root_tree->log_transid); 2070 mutex_unlock(&log_root_tree->log_mutex); 2071 ret = 0; 2072 goto out; 2073 } 2074 atomic_set(&log_root_tree->log_commit[index2], 1); 2075 2076 if (atomic_read(&log_root_tree->log_commit[(index2 + 1) % 2])) { 2077 wait_log_commit(trans, log_root_tree, 2078 log_root_tree->log_transid - 1); 2079 } 2080 2081 wait_for_writer(trans, log_root_tree); 2082 2083 /* 2084 * now that we've moved on to the tree of log tree roots, 2085 * check the full commit flag again 2086 */ 2087 if (root->fs_info->last_trans_log_full_commit == trans->transid) { 2088 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark); 2089 mutex_unlock(&log_root_tree->log_mutex); 2090 ret = -EAGAIN; 2091 goto out_wake_log_root; 2092 } 2093 2094 ret = btrfs_write_and_wait_marked_extents(log_root_tree, 2095 &log_root_tree->dirty_log_pages, 2096 EXTENT_DIRTY | EXTENT_NEW); 2097 BUG_ON(ret); 2098 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark); 2099 2100 btrfs_set_super_log_root(&root->fs_info->super_for_commit, 2101 log_root_tree->node->start); 2102 btrfs_set_super_log_root_level(&root->fs_info->super_for_commit, 2103 btrfs_header_level(log_root_tree->node)); 2104 2105 log_root_tree->log_batch = 0; 2106 log_root_tree->log_transid++; 2107 smp_mb(); 2108 2109 mutex_unlock(&log_root_tree->log_mutex); 2110 2111 /* 2112 * nobody else is going to jump in and write the the ctree 2113 * super here because the log_commit atomic below is protecting 2114 * us. We must be called with a transaction handle pinning 2115 * the running transaction open, so a full commit can't hop 2116 * in and cause problems either. 2117 */ 2118 btrfs_scrub_pause_super(root); 2119 write_ctree_super(trans, root->fs_info->tree_root, 1); 2120 btrfs_scrub_continue_super(root); 2121 ret = 0; 2122 2123 mutex_lock(&root->log_mutex); 2124 if (root->last_log_commit < log_transid) 2125 root->last_log_commit = log_transid; 2126 mutex_unlock(&root->log_mutex); 2127 2128 out_wake_log_root: 2129 atomic_set(&log_root_tree->log_commit[index2], 0); 2130 smp_mb(); 2131 if (waitqueue_active(&log_root_tree->log_commit_wait[index2])) 2132 wake_up(&log_root_tree->log_commit_wait[index2]); 2133 out: 2134 atomic_set(&root->log_commit[index1], 0); 2135 smp_mb(); 2136 if (waitqueue_active(&root->log_commit_wait[index1])) 2137 wake_up(&root->log_commit_wait[index1]); 2138 return ret; 2139 } 2140 2141 static void free_log_tree(struct btrfs_trans_handle *trans, 2142 struct btrfs_root *log) 2143 { 2144 int ret; 2145 u64 start; 2146 u64 end; 2147 struct walk_control wc = { 2148 .free = 1, 2149 .process_func = process_one_buffer 2150 }; 2151 2152 ret = walk_log_tree(trans, log, &wc); 2153 BUG_ON(ret); 2154 2155 while (1) { 2156 ret = find_first_extent_bit(&log->dirty_log_pages, 2157 0, &start, &end, EXTENT_DIRTY | EXTENT_NEW); 2158 if (ret) 2159 break; 2160 2161 clear_extent_bits(&log->dirty_log_pages, start, end, 2162 EXTENT_DIRTY | EXTENT_NEW, GFP_NOFS); 2163 } 2164 2165 free_extent_buffer(log->node); 2166 kfree(log); 2167 } 2168 2169 /* 2170 * free all the extents used by the tree log. This should be called 2171 * at commit time of the full transaction 2172 */ 2173 int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root) 2174 { 2175 if (root->log_root) { 2176 free_log_tree(trans, root->log_root); 2177 root->log_root = NULL; 2178 } 2179 return 0; 2180 } 2181 2182 int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans, 2183 struct btrfs_fs_info *fs_info) 2184 { 2185 if (fs_info->log_root_tree) { 2186 free_log_tree(trans, fs_info->log_root_tree); 2187 fs_info->log_root_tree = NULL; 2188 } 2189 return 0; 2190 } 2191 2192 /* 2193 * If both a file and directory are logged, and unlinks or renames are 2194 * mixed in, we have a few interesting corners: 2195 * 2196 * create file X in dir Y 2197 * link file X to X.link in dir Y 2198 * fsync file X 2199 * unlink file X but leave X.link 2200 * fsync dir Y 2201 * 2202 * After a crash we would expect only X.link to exist. But file X 2203 * didn't get fsync'd again so the log has back refs for X and X.link. 2204 * 2205 * We solve this by removing directory entries and inode backrefs from the 2206 * log when a file that was logged in the current transaction is 2207 * unlinked. Any later fsync will include the updated log entries, and 2208 * we'll be able to reconstruct the proper directory items from backrefs. 2209 * 2210 * This optimizations allows us to avoid relogging the entire inode 2211 * or the entire directory. 2212 */ 2213 int btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans, 2214 struct btrfs_root *root, 2215 const char *name, int name_len, 2216 struct inode *dir, u64 index) 2217 { 2218 struct btrfs_root *log; 2219 struct btrfs_dir_item *di; 2220 struct btrfs_path *path; 2221 int ret; 2222 int err = 0; 2223 int bytes_del = 0; 2224 u64 dir_ino = btrfs_ino(dir); 2225 2226 if (BTRFS_I(dir)->logged_trans < trans->transid) 2227 return 0; 2228 2229 ret = join_running_log_trans(root); 2230 if (ret) 2231 return 0; 2232 2233 mutex_lock(&BTRFS_I(dir)->log_mutex); 2234 2235 log = root->log_root; 2236 path = btrfs_alloc_path(); 2237 if (!path) { 2238 err = -ENOMEM; 2239 goto out_unlock; 2240 } 2241 2242 di = btrfs_lookup_dir_item(trans, log, path, dir_ino, 2243 name, name_len, -1); 2244 if (IS_ERR(di)) { 2245 err = PTR_ERR(di); 2246 goto fail; 2247 } 2248 if (di) { 2249 ret = btrfs_delete_one_dir_name(trans, log, path, di); 2250 bytes_del += name_len; 2251 BUG_ON(ret); 2252 } 2253 btrfs_release_path(path); 2254 di = btrfs_lookup_dir_index_item(trans, log, path, dir_ino, 2255 index, name, name_len, -1); 2256 if (IS_ERR(di)) { 2257 err = PTR_ERR(di); 2258 goto fail; 2259 } 2260 if (di) { 2261 ret = btrfs_delete_one_dir_name(trans, log, path, di); 2262 bytes_del += name_len; 2263 BUG_ON(ret); 2264 } 2265 2266 /* update the directory size in the log to reflect the names 2267 * we have removed 2268 */ 2269 if (bytes_del) { 2270 struct btrfs_key key; 2271 2272 key.objectid = dir_ino; 2273 key.offset = 0; 2274 key.type = BTRFS_INODE_ITEM_KEY; 2275 btrfs_release_path(path); 2276 2277 ret = btrfs_search_slot(trans, log, &key, path, 0, 1); 2278 if (ret < 0) { 2279 err = ret; 2280 goto fail; 2281 } 2282 if (ret == 0) { 2283 struct btrfs_inode_item *item; 2284 u64 i_size; 2285 2286 item = btrfs_item_ptr(path->nodes[0], path->slots[0], 2287 struct btrfs_inode_item); 2288 i_size = btrfs_inode_size(path->nodes[0], item); 2289 if (i_size > bytes_del) 2290 i_size -= bytes_del; 2291 else 2292 i_size = 0; 2293 btrfs_set_inode_size(path->nodes[0], item, i_size); 2294 btrfs_mark_buffer_dirty(path->nodes[0]); 2295 } else 2296 ret = 0; 2297 btrfs_release_path(path); 2298 } 2299 fail: 2300 btrfs_free_path(path); 2301 out_unlock: 2302 mutex_unlock(&BTRFS_I(dir)->log_mutex); 2303 if (ret == -ENOSPC) { 2304 root->fs_info->last_trans_log_full_commit = trans->transid; 2305 ret = 0; 2306 } 2307 btrfs_end_log_trans(root); 2308 2309 return err; 2310 } 2311 2312 /* see comments for btrfs_del_dir_entries_in_log */ 2313 int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans, 2314 struct btrfs_root *root, 2315 const char *name, int name_len, 2316 struct inode *inode, u64 dirid) 2317 { 2318 struct btrfs_root *log; 2319 u64 index; 2320 int ret; 2321 2322 if (BTRFS_I(inode)->logged_trans < trans->transid) 2323 return 0; 2324 2325 ret = join_running_log_trans(root); 2326 if (ret) 2327 return 0; 2328 log = root->log_root; 2329 mutex_lock(&BTRFS_I(inode)->log_mutex); 2330 2331 ret = btrfs_del_inode_ref(trans, log, name, name_len, btrfs_ino(inode), 2332 dirid, &index); 2333 mutex_unlock(&BTRFS_I(inode)->log_mutex); 2334 if (ret == -ENOSPC) { 2335 root->fs_info->last_trans_log_full_commit = trans->transid; 2336 ret = 0; 2337 } 2338 btrfs_end_log_trans(root); 2339 2340 return ret; 2341 } 2342 2343 /* 2344 * creates a range item in the log for 'dirid'. first_offset and 2345 * last_offset tell us which parts of the key space the log should 2346 * be considered authoritative for. 2347 */ 2348 static noinline int insert_dir_log_key(struct btrfs_trans_handle *trans, 2349 struct btrfs_root *log, 2350 struct btrfs_path *path, 2351 int key_type, u64 dirid, 2352 u64 first_offset, u64 last_offset) 2353 { 2354 int ret; 2355 struct btrfs_key key; 2356 struct btrfs_dir_log_item *item; 2357 2358 key.objectid = dirid; 2359 key.offset = first_offset; 2360 if (key_type == BTRFS_DIR_ITEM_KEY) 2361 key.type = BTRFS_DIR_LOG_ITEM_KEY; 2362 else 2363 key.type = BTRFS_DIR_LOG_INDEX_KEY; 2364 ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item)); 2365 if (ret) 2366 return ret; 2367 2368 item = btrfs_item_ptr(path->nodes[0], path->slots[0], 2369 struct btrfs_dir_log_item); 2370 btrfs_set_dir_log_end(path->nodes[0], item, last_offset); 2371 btrfs_mark_buffer_dirty(path->nodes[0]); 2372 btrfs_release_path(path); 2373 return 0; 2374 } 2375 2376 /* 2377 * log all the items included in the current transaction for a given 2378 * directory. This also creates the range items in the log tree required 2379 * to replay anything deleted before the fsync 2380 */ 2381 static noinline int log_dir_items(struct btrfs_trans_handle *trans, 2382 struct btrfs_root *root, struct inode *inode, 2383 struct btrfs_path *path, 2384 struct btrfs_path *dst_path, int key_type, 2385 u64 min_offset, u64 *last_offset_ret) 2386 { 2387 struct btrfs_key min_key; 2388 struct btrfs_key max_key; 2389 struct btrfs_root *log = root->log_root; 2390 struct extent_buffer *src; 2391 int err = 0; 2392 int ret; 2393 int i; 2394 int nritems; 2395 u64 first_offset = min_offset; 2396 u64 last_offset = (u64)-1; 2397 u64 ino = btrfs_ino(inode); 2398 2399 log = root->log_root; 2400 max_key.objectid = ino; 2401 max_key.offset = (u64)-1; 2402 max_key.type = key_type; 2403 2404 min_key.objectid = ino; 2405 min_key.type = key_type; 2406 min_key.offset = min_offset; 2407 2408 path->keep_locks = 1; 2409 2410 ret = btrfs_search_forward(root, &min_key, &max_key, 2411 path, 0, trans->transid); 2412 2413 /* 2414 * we didn't find anything from this transaction, see if there 2415 * is anything at all 2416 */ 2417 if (ret != 0 || min_key.objectid != ino || min_key.type != key_type) { 2418 min_key.objectid = ino; 2419 min_key.type = key_type; 2420 min_key.offset = (u64)-1; 2421 btrfs_release_path(path); 2422 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0); 2423 if (ret < 0) { 2424 btrfs_release_path(path); 2425 return ret; 2426 } 2427 ret = btrfs_previous_item(root, path, ino, key_type); 2428 2429 /* if ret == 0 there are items for this type, 2430 * create a range to tell us the last key of this type. 2431 * otherwise, there are no items in this directory after 2432 * *min_offset, and we create a range to indicate that. 2433 */ 2434 if (ret == 0) { 2435 struct btrfs_key tmp; 2436 btrfs_item_key_to_cpu(path->nodes[0], &tmp, 2437 path->slots[0]); 2438 if (key_type == tmp.type) 2439 first_offset = max(min_offset, tmp.offset) + 1; 2440 } 2441 goto done; 2442 } 2443 2444 /* go backward to find any previous key */ 2445 ret = btrfs_previous_item(root, path, ino, key_type); 2446 if (ret == 0) { 2447 struct btrfs_key tmp; 2448 btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]); 2449 if (key_type == tmp.type) { 2450 first_offset = tmp.offset; 2451 ret = overwrite_item(trans, log, dst_path, 2452 path->nodes[0], path->slots[0], 2453 &tmp); 2454 if (ret) { 2455 err = ret; 2456 goto done; 2457 } 2458 } 2459 } 2460 btrfs_release_path(path); 2461 2462 /* find the first key from this transaction again */ 2463 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0); 2464 if (ret != 0) { 2465 WARN_ON(1); 2466 goto done; 2467 } 2468 2469 /* 2470 * we have a block from this transaction, log every item in it 2471 * from our directory 2472 */ 2473 while (1) { 2474 struct btrfs_key tmp; 2475 src = path->nodes[0]; 2476 nritems = btrfs_header_nritems(src); 2477 for (i = path->slots[0]; i < nritems; i++) { 2478 btrfs_item_key_to_cpu(src, &min_key, i); 2479 2480 if (min_key.objectid != ino || min_key.type != key_type) 2481 goto done; 2482 ret = overwrite_item(trans, log, dst_path, src, i, 2483 &min_key); 2484 if (ret) { 2485 err = ret; 2486 goto done; 2487 } 2488 } 2489 path->slots[0] = nritems; 2490 2491 /* 2492 * look ahead to the next item and see if it is also 2493 * from this directory and from this transaction 2494 */ 2495 ret = btrfs_next_leaf(root, path); 2496 if (ret == 1) { 2497 last_offset = (u64)-1; 2498 goto done; 2499 } 2500 btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]); 2501 if (tmp.objectid != ino || tmp.type != key_type) { 2502 last_offset = (u64)-1; 2503 goto done; 2504 } 2505 if (btrfs_header_generation(path->nodes[0]) != trans->transid) { 2506 ret = overwrite_item(trans, log, dst_path, 2507 path->nodes[0], path->slots[0], 2508 &tmp); 2509 if (ret) 2510 err = ret; 2511 else 2512 last_offset = tmp.offset; 2513 goto done; 2514 } 2515 } 2516 done: 2517 btrfs_release_path(path); 2518 btrfs_release_path(dst_path); 2519 2520 if (err == 0) { 2521 *last_offset_ret = last_offset; 2522 /* 2523 * insert the log range keys to indicate where the log 2524 * is valid 2525 */ 2526 ret = insert_dir_log_key(trans, log, path, key_type, 2527 ino, first_offset, last_offset); 2528 if (ret) 2529 err = ret; 2530 } 2531 return err; 2532 } 2533 2534 /* 2535 * logging directories is very similar to logging inodes, We find all the items 2536 * from the current transaction and write them to the log. 2537 * 2538 * The recovery code scans the directory in the subvolume, and if it finds a 2539 * key in the range logged that is not present in the log tree, then it means 2540 * that dir entry was unlinked during the transaction. 2541 * 2542 * In order for that scan to work, we must include one key smaller than 2543 * the smallest logged by this transaction and one key larger than the largest 2544 * key logged by this transaction. 2545 */ 2546 static noinline int log_directory_changes(struct btrfs_trans_handle *trans, 2547 struct btrfs_root *root, struct inode *inode, 2548 struct btrfs_path *path, 2549 struct btrfs_path *dst_path) 2550 { 2551 u64 min_key; 2552 u64 max_key; 2553 int ret; 2554 int key_type = BTRFS_DIR_ITEM_KEY; 2555 2556 again: 2557 min_key = 0; 2558 max_key = 0; 2559 while (1) { 2560 ret = log_dir_items(trans, root, inode, path, 2561 dst_path, key_type, min_key, 2562 &max_key); 2563 if (ret) 2564 return ret; 2565 if (max_key == (u64)-1) 2566 break; 2567 min_key = max_key + 1; 2568 } 2569 2570 if (key_type == BTRFS_DIR_ITEM_KEY) { 2571 key_type = BTRFS_DIR_INDEX_KEY; 2572 goto again; 2573 } 2574 return 0; 2575 } 2576 2577 /* 2578 * a helper function to drop items from the log before we relog an 2579 * inode. max_key_type indicates the highest item type to remove. 2580 * This cannot be run for file data extents because it does not 2581 * free the extents they point to. 2582 */ 2583 static int drop_objectid_items(struct btrfs_trans_handle *trans, 2584 struct btrfs_root *log, 2585 struct btrfs_path *path, 2586 u64 objectid, int max_key_type) 2587 { 2588 int ret; 2589 struct btrfs_key key; 2590 struct btrfs_key found_key; 2591 2592 key.objectid = objectid; 2593 key.type = max_key_type; 2594 key.offset = (u64)-1; 2595 2596 while (1) { 2597 ret = btrfs_search_slot(trans, log, &key, path, -1, 1); 2598 BUG_ON(ret == 0); 2599 if (ret < 0) 2600 break; 2601 2602 if (path->slots[0] == 0) 2603 break; 2604 2605 path->slots[0]--; 2606 btrfs_item_key_to_cpu(path->nodes[0], &found_key, 2607 path->slots[0]); 2608 2609 if (found_key.objectid != objectid) 2610 break; 2611 2612 ret = btrfs_del_item(trans, log, path); 2613 if (ret) 2614 break; 2615 btrfs_release_path(path); 2616 } 2617 btrfs_release_path(path); 2618 return ret; 2619 } 2620 2621 static noinline int copy_items(struct btrfs_trans_handle *trans, 2622 struct btrfs_root *log, 2623 struct btrfs_path *dst_path, 2624 struct extent_buffer *src, 2625 int start_slot, int nr, int inode_only) 2626 { 2627 unsigned long src_offset; 2628 unsigned long dst_offset; 2629 struct btrfs_file_extent_item *extent; 2630 struct btrfs_inode_item *inode_item; 2631 int ret; 2632 struct btrfs_key *ins_keys; 2633 u32 *ins_sizes; 2634 char *ins_data; 2635 int i; 2636 struct list_head ordered_sums; 2637 2638 INIT_LIST_HEAD(&ordered_sums); 2639 2640 ins_data = kmalloc(nr * sizeof(struct btrfs_key) + 2641 nr * sizeof(u32), GFP_NOFS); 2642 if (!ins_data) 2643 return -ENOMEM; 2644 2645 ins_sizes = (u32 *)ins_data; 2646 ins_keys = (struct btrfs_key *)(ins_data + nr * sizeof(u32)); 2647 2648 for (i = 0; i < nr; i++) { 2649 ins_sizes[i] = btrfs_item_size_nr(src, i + start_slot); 2650 btrfs_item_key_to_cpu(src, ins_keys + i, i + start_slot); 2651 } 2652 ret = btrfs_insert_empty_items(trans, log, dst_path, 2653 ins_keys, ins_sizes, nr); 2654 if (ret) { 2655 kfree(ins_data); 2656 return ret; 2657 } 2658 2659 for (i = 0; i < nr; i++, dst_path->slots[0]++) { 2660 dst_offset = btrfs_item_ptr_offset(dst_path->nodes[0], 2661 dst_path->slots[0]); 2662 2663 src_offset = btrfs_item_ptr_offset(src, start_slot + i); 2664 2665 copy_extent_buffer(dst_path->nodes[0], src, dst_offset, 2666 src_offset, ins_sizes[i]); 2667 2668 if (inode_only == LOG_INODE_EXISTS && 2669 ins_keys[i].type == BTRFS_INODE_ITEM_KEY) { 2670 inode_item = btrfs_item_ptr(dst_path->nodes[0], 2671 dst_path->slots[0], 2672 struct btrfs_inode_item); 2673 btrfs_set_inode_size(dst_path->nodes[0], inode_item, 0); 2674 2675 /* set the generation to zero so the recover code 2676 * can tell the difference between an logging 2677 * just to say 'this inode exists' and a logging 2678 * to say 'update this inode with these values' 2679 */ 2680 btrfs_set_inode_generation(dst_path->nodes[0], 2681 inode_item, 0); 2682 } 2683 /* take a reference on file data extents so that truncates 2684 * or deletes of this inode don't have to relog the inode 2685 * again 2686 */ 2687 if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY) { 2688 int found_type; 2689 extent = btrfs_item_ptr(src, start_slot + i, 2690 struct btrfs_file_extent_item); 2691 2692 if (btrfs_file_extent_generation(src, extent) < trans->transid) 2693 continue; 2694 2695 found_type = btrfs_file_extent_type(src, extent); 2696 if (found_type == BTRFS_FILE_EXTENT_REG || 2697 found_type == BTRFS_FILE_EXTENT_PREALLOC) { 2698 u64 ds, dl, cs, cl; 2699 ds = btrfs_file_extent_disk_bytenr(src, 2700 extent); 2701 /* ds == 0 is a hole */ 2702 if (ds == 0) 2703 continue; 2704 2705 dl = btrfs_file_extent_disk_num_bytes(src, 2706 extent); 2707 cs = btrfs_file_extent_offset(src, extent); 2708 cl = btrfs_file_extent_num_bytes(src, 2709 extent); 2710 if (btrfs_file_extent_compression(src, 2711 extent)) { 2712 cs = 0; 2713 cl = dl; 2714 } 2715 2716 ret = btrfs_lookup_csums_range( 2717 log->fs_info->csum_root, 2718 ds + cs, ds + cs + cl - 1, 2719 &ordered_sums, 0); 2720 BUG_ON(ret); 2721 } 2722 } 2723 } 2724 2725 btrfs_mark_buffer_dirty(dst_path->nodes[0]); 2726 btrfs_release_path(dst_path); 2727 kfree(ins_data); 2728 2729 /* 2730 * we have to do this after the loop above to avoid changing the 2731 * log tree while trying to change the log tree. 2732 */ 2733 ret = 0; 2734 while (!list_empty(&ordered_sums)) { 2735 struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next, 2736 struct btrfs_ordered_sum, 2737 list); 2738 if (!ret) 2739 ret = btrfs_csum_file_blocks(trans, log, sums); 2740 list_del(&sums->list); 2741 kfree(sums); 2742 } 2743 return ret; 2744 } 2745 2746 /* log a single inode in the tree log. 2747 * At least one parent directory for this inode must exist in the tree 2748 * or be logged already. 2749 * 2750 * Any items from this inode changed by the current transaction are copied 2751 * to the log tree. An extra reference is taken on any extents in this 2752 * file, allowing us to avoid a whole pile of corner cases around logging 2753 * blocks that have been removed from the tree. 2754 * 2755 * See LOG_INODE_ALL and related defines for a description of what inode_only 2756 * does. 2757 * 2758 * This handles both files and directories. 2759 */ 2760 static int btrfs_log_inode(struct btrfs_trans_handle *trans, 2761 struct btrfs_root *root, struct inode *inode, 2762 int inode_only) 2763 { 2764 struct btrfs_path *path; 2765 struct btrfs_path *dst_path; 2766 struct btrfs_key min_key; 2767 struct btrfs_key max_key; 2768 struct btrfs_root *log = root->log_root; 2769 struct extent_buffer *src = NULL; 2770 int err = 0; 2771 int ret; 2772 int nritems; 2773 int ins_start_slot = 0; 2774 int ins_nr; 2775 u64 ino = btrfs_ino(inode); 2776 2777 log = root->log_root; 2778 2779 path = btrfs_alloc_path(); 2780 if (!path) 2781 return -ENOMEM; 2782 dst_path = btrfs_alloc_path(); 2783 if (!dst_path) { 2784 btrfs_free_path(path); 2785 return -ENOMEM; 2786 } 2787 2788 min_key.objectid = ino; 2789 min_key.type = BTRFS_INODE_ITEM_KEY; 2790 min_key.offset = 0; 2791 2792 max_key.objectid = ino; 2793 2794 /* today the code can only do partial logging of directories */ 2795 if (!S_ISDIR(inode->i_mode)) 2796 inode_only = LOG_INODE_ALL; 2797 2798 if (inode_only == LOG_INODE_EXISTS || S_ISDIR(inode->i_mode)) 2799 max_key.type = BTRFS_XATTR_ITEM_KEY; 2800 else 2801 max_key.type = (u8)-1; 2802 max_key.offset = (u64)-1; 2803 2804 ret = btrfs_commit_inode_delayed_items(trans, inode); 2805 if (ret) { 2806 btrfs_free_path(path); 2807 btrfs_free_path(dst_path); 2808 return ret; 2809 } 2810 2811 mutex_lock(&BTRFS_I(inode)->log_mutex); 2812 2813 /* 2814 * a brute force approach to making sure we get the most uptodate 2815 * copies of everything. 2816 */ 2817 if (S_ISDIR(inode->i_mode)) { 2818 int max_key_type = BTRFS_DIR_LOG_INDEX_KEY; 2819 2820 if (inode_only == LOG_INODE_EXISTS) 2821 max_key_type = BTRFS_XATTR_ITEM_KEY; 2822 ret = drop_objectid_items(trans, log, path, ino, max_key_type); 2823 } else { 2824 ret = btrfs_truncate_inode_items(trans, log, inode, 0, 0); 2825 } 2826 if (ret) { 2827 err = ret; 2828 goto out_unlock; 2829 } 2830 path->keep_locks = 1; 2831 2832 while (1) { 2833 ins_nr = 0; 2834 ret = btrfs_search_forward(root, &min_key, &max_key, 2835 path, 0, trans->transid); 2836 if (ret != 0) 2837 break; 2838 again: 2839 /* note, ins_nr might be > 0 here, cleanup outside the loop */ 2840 if (min_key.objectid != ino) 2841 break; 2842 if (min_key.type > max_key.type) 2843 break; 2844 2845 src = path->nodes[0]; 2846 if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) { 2847 ins_nr++; 2848 goto next_slot; 2849 } else if (!ins_nr) { 2850 ins_start_slot = path->slots[0]; 2851 ins_nr = 1; 2852 goto next_slot; 2853 } 2854 2855 ret = copy_items(trans, log, dst_path, src, ins_start_slot, 2856 ins_nr, inode_only); 2857 if (ret) { 2858 err = ret; 2859 goto out_unlock; 2860 } 2861 ins_nr = 1; 2862 ins_start_slot = path->slots[0]; 2863 next_slot: 2864 2865 nritems = btrfs_header_nritems(path->nodes[0]); 2866 path->slots[0]++; 2867 if (path->slots[0] < nritems) { 2868 btrfs_item_key_to_cpu(path->nodes[0], &min_key, 2869 path->slots[0]); 2870 goto again; 2871 } 2872 if (ins_nr) { 2873 ret = copy_items(trans, log, dst_path, src, 2874 ins_start_slot, 2875 ins_nr, inode_only); 2876 if (ret) { 2877 err = ret; 2878 goto out_unlock; 2879 } 2880 ins_nr = 0; 2881 } 2882 btrfs_release_path(path); 2883 2884 if (min_key.offset < (u64)-1) 2885 min_key.offset++; 2886 else if (min_key.type < (u8)-1) 2887 min_key.type++; 2888 else if (min_key.objectid < (u64)-1) 2889 min_key.objectid++; 2890 else 2891 break; 2892 } 2893 if (ins_nr) { 2894 ret = copy_items(trans, log, dst_path, src, 2895 ins_start_slot, 2896 ins_nr, inode_only); 2897 if (ret) { 2898 err = ret; 2899 goto out_unlock; 2900 } 2901 ins_nr = 0; 2902 } 2903 WARN_ON(ins_nr); 2904 if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) { 2905 btrfs_release_path(path); 2906 btrfs_release_path(dst_path); 2907 ret = log_directory_changes(trans, root, inode, path, dst_path); 2908 if (ret) { 2909 err = ret; 2910 goto out_unlock; 2911 } 2912 } 2913 BTRFS_I(inode)->logged_trans = trans->transid; 2914 out_unlock: 2915 mutex_unlock(&BTRFS_I(inode)->log_mutex); 2916 2917 btrfs_free_path(path); 2918 btrfs_free_path(dst_path); 2919 return err; 2920 } 2921 2922 /* 2923 * follow the dentry parent pointers up the chain and see if any 2924 * of the directories in it require a full commit before they can 2925 * be logged. Returns zero if nothing special needs to be done or 1 if 2926 * a full commit is required. 2927 */ 2928 static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans, 2929 struct inode *inode, 2930 struct dentry *parent, 2931 struct super_block *sb, 2932 u64 last_committed) 2933 { 2934 int ret = 0; 2935 struct btrfs_root *root; 2936 struct dentry *old_parent = NULL; 2937 2938 /* 2939 * for regular files, if its inode is already on disk, we don't 2940 * have to worry about the parents at all. This is because 2941 * we can use the last_unlink_trans field to record renames 2942 * and other fun in this file. 2943 */ 2944 if (S_ISREG(inode->i_mode) && 2945 BTRFS_I(inode)->generation <= last_committed && 2946 BTRFS_I(inode)->last_unlink_trans <= last_committed) 2947 goto out; 2948 2949 if (!S_ISDIR(inode->i_mode)) { 2950 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb) 2951 goto out; 2952 inode = parent->d_inode; 2953 } 2954 2955 while (1) { 2956 BTRFS_I(inode)->logged_trans = trans->transid; 2957 smp_mb(); 2958 2959 if (BTRFS_I(inode)->last_unlink_trans > last_committed) { 2960 root = BTRFS_I(inode)->root; 2961 2962 /* 2963 * make sure any commits to the log are forced 2964 * to be full commits 2965 */ 2966 root->fs_info->last_trans_log_full_commit = 2967 trans->transid; 2968 ret = 1; 2969 break; 2970 } 2971 2972 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb) 2973 break; 2974 2975 if (IS_ROOT(parent)) 2976 break; 2977 2978 parent = dget_parent(parent); 2979 dput(old_parent); 2980 old_parent = parent; 2981 inode = parent->d_inode; 2982 2983 } 2984 dput(old_parent); 2985 out: 2986 return ret; 2987 } 2988 2989 static int inode_in_log(struct btrfs_trans_handle *trans, 2990 struct inode *inode) 2991 { 2992 struct btrfs_root *root = BTRFS_I(inode)->root; 2993 int ret = 0; 2994 2995 mutex_lock(&root->log_mutex); 2996 if (BTRFS_I(inode)->logged_trans == trans->transid && 2997 BTRFS_I(inode)->last_sub_trans <= root->last_log_commit) 2998 ret = 1; 2999 mutex_unlock(&root->log_mutex); 3000 return ret; 3001 } 3002 3003 3004 /* 3005 * helper function around btrfs_log_inode to make sure newly created 3006 * parent directories also end up in the log. A minimal inode and backref 3007 * only logging is done of any parent directories that are older than 3008 * the last committed transaction 3009 */ 3010 int btrfs_log_inode_parent(struct btrfs_trans_handle *trans, 3011 struct btrfs_root *root, struct inode *inode, 3012 struct dentry *parent, int exists_only) 3013 { 3014 int inode_only = exists_only ? LOG_INODE_EXISTS : LOG_INODE_ALL; 3015 struct super_block *sb; 3016 struct dentry *old_parent = NULL; 3017 int ret = 0; 3018 u64 last_committed = root->fs_info->last_trans_committed; 3019 3020 sb = inode->i_sb; 3021 3022 if (btrfs_test_opt(root, NOTREELOG)) { 3023 ret = 1; 3024 goto end_no_trans; 3025 } 3026 3027 if (root->fs_info->last_trans_log_full_commit > 3028 root->fs_info->last_trans_committed) { 3029 ret = 1; 3030 goto end_no_trans; 3031 } 3032 3033 if (root != BTRFS_I(inode)->root || 3034 btrfs_root_refs(&root->root_item) == 0) { 3035 ret = 1; 3036 goto end_no_trans; 3037 } 3038 3039 ret = check_parent_dirs_for_sync(trans, inode, parent, 3040 sb, last_committed); 3041 if (ret) 3042 goto end_no_trans; 3043 3044 if (inode_in_log(trans, inode)) { 3045 ret = BTRFS_NO_LOG_SYNC; 3046 goto end_no_trans; 3047 } 3048 3049 ret = start_log_trans(trans, root); 3050 if (ret) 3051 goto end_trans; 3052 3053 ret = btrfs_log_inode(trans, root, inode, inode_only); 3054 if (ret) 3055 goto end_trans; 3056 3057 /* 3058 * for regular files, if its inode is already on disk, we don't 3059 * have to worry about the parents at all. This is because 3060 * we can use the last_unlink_trans field to record renames 3061 * and other fun in this file. 3062 */ 3063 if (S_ISREG(inode->i_mode) && 3064 BTRFS_I(inode)->generation <= last_committed && 3065 BTRFS_I(inode)->last_unlink_trans <= last_committed) { 3066 ret = 0; 3067 goto end_trans; 3068 } 3069 3070 inode_only = LOG_INODE_EXISTS; 3071 while (1) { 3072 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb) 3073 break; 3074 3075 inode = parent->d_inode; 3076 if (root != BTRFS_I(inode)->root) 3077 break; 3078 3079 if (BTRFS_I(inode)->generation > 3080 root->fs_info->last_trans_committed) { 3081 ret = btrfs_log_inode(trans, root, inode, inode_only); 3082 if (ret) 3083 goto end_trans; 3084 } 3085 if (IS_ROOT(parent)) 3086 break; 3087 3088 parent = dget_parent(parent); 3089 dput(old_parent); 3090 old_parent = parent; 3091 } 3092 ret = 0; 3093 end_trans: 3094 dput(old_parent); 3095 if (ret < 0) { 3096 BUG_ON(ret != -ENOSPC); 3097 root->fs_info->last_trans_log_full_commit = trans->transid; 3098 ret = 1; 3099 } 3100 btrfs_end_log_trans(root); 3101 end_no_trans: 3102 return ret; 3103 } 3104 3105 /* 3106 * it is not safe to log dentry if the chunk root has added new 3107 * chunks. This returns 0 if the dentry was logged, and 1 otherwise. 3108 * If this returns 1, you must commit the transaction to safely get your 3109 * data on disk. 3110 */ 3111 int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans, 3112 struct btrfs_root *root, struct dentry *dentry) 3113 { 3114 struct dentry *parent = dget_parent(dentry); 3115 int ret; 3116 3117 ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent, 0); 3118 dput(parent); 3119 3120 return ret; 3121 } 3122 3123 /* 3124 * should be called during mount to recover any replay any log trees 3125 * from the FS 3126 */ 3127 int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) 3128 { 3129 int ret; 3130 struct btrfs_path *path; 3131 struct btrfs_trans_handle *trans; 3132 struct btrfs_key key; 3133 struct btrfs_key found_key; 3134 struct btrfs_key tmp_key; 3135 struct btrfs_root *log; 3136 struct btrfs_fs_info *fs_info = log_root_tree->fs_info; 3137 struct walk_control wc = { 3138 .process_func = process_one_buffer, 3139 .stage = 0, 3140 }; 3141 3142 path = btrfs_alloc_path(); 3143 if (!path) 3144 return -ENOMEM; 3145 3146 fs_info->log_root_recovering = 1; 3147 3148 trans = btrfs_start_transaction(fs_info->tree_root, 0); 3149 BUG_ON(IS_ERR(trans)); 3150 3151 wc.trans = trans; 3152 wc.pin = 1; 3153 3154 ret = walk_log_tree(trans, log_root_tree, &wc); 3155 BUG_ON(ret); 3156 3157 again: 3158 key.objectid = BTRFS_TREE_LOG_OBJECTID; 3159 key.offset = (u64)-1; 3160 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY); 3161 3162 while (1) { 3163 ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0); 3164 if (ret < 0) 3165 break; 3166 if (ret > 0) { 3167 if (path->slots[0] == 0) 3168 break; 3169 path->slots[0]--; 3170 } 3171 btrfs_item_key_to_cpu(path->nodes[0], &found_key, 3172 path->slots[0]); 3173 btrfs_release_path(path); 3174 if (found_key.objectid != BTRFS_TREE_LOG_OBJECTID) 3175 break; 3176 3177 log = btrfs_read_fs_root_no_radix(log_root_tree, 3178 &found_key); 3179 BUG_ON(IS_ERR(log)); 3180 3181 tmp_key.objectid = found_key.offset; 3182 tmp_key.type = BTRFS_ROOT_ITEM_KEY; 3183 tmp_key.offset = (u64)-1; 3184 3185 wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key); 3186 BUG_ON(IS_ERR_OR_NULL(wc.replay_dest)); 3187 3188 wc.replay_dest->log_root = log; 3189 btrfs_record_root_in_trans(trans, wc.replay_dest); 3190 ret = walk_log_tree(trans, log, &wc); 3191 BUG_ON(ret); 3192 3193 if (wc.stage == LOG_WALK_REPLAY_ALL) { 3194 ret = fixup_inode_link_counts(trans, wc.replay_dest, 3195 path); 3196 BUG_ON(ret); 3197 } 3198 3199 key.offset = found_key.offset - 1; 3200 wc.replay_dest->log_root = NULL; 3201 free_extent_buffer(log->node); 3202 free_extent_buffer(log->commit_root); 3203 kfree(log); 3204 3205 if (found_key.offset == 0) 3206 break; 3207 } 3208 btrfs_release_path(path); 3209 3210 /* step one is to pin it all, step two is to replay just inodes */ 3211 if (wc.pin) { 3212 wc.pin = 0; 3213 wc.process_func = replay_one_buffer; 3214 wc.stage = LOG_WALK_REPLAY_INODES; 3215 goto again; 3216 } 3217 /* step three is to replay everything */ 3218 if (wc.stage < LOG_WALK_REPLAY_ALL) { 3219 wc.stage++; 3220 goto again; 3221 } 3222 3223 btrfs_free_path(path); 3224 3225 free_extent_buffer(log_root_tree->node); 3226 log_root_tree->log_root = NULL; 3227 fs_info->log_root_recovering = 0; 3228 3229 /* step 4: commit the transaction, which also unpins the blocks */ 3230 btrfs_commit_transaction(trans, fs_info->tree_root); 3231 3232 kfree(log_root_tree); 3233 return 0; 3234 } 3235 3236 /* 3237 * there are some corner cases where we want to force a full 3238 * commit instead of allowing a directory to be logged. 3239 * 3240 * They revolve around files there were unlinked from the directory, and 3241 * this function updates the parent directory so that a full commit is 3242 * properly done if it is fsync'd later after the unlinks are done. 3243 */ 3244 void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans, 3245 struct inode *dir, struct inode *inode, 3246 int for_rename) 3247 { 3248 /* 3249 * when we're logging a file, if it hasn't been renamed 3250 * or unlinked, and its inode is fully committed on disk, 3251 * we don't have to worry about walking up the directory chain 3252 * to log its parents. 3253 * 3254 * So, we use the last_unlink_trans field to put this transid 3255 * into the file. When the file is logged we check it and 3256 * don't log the parents if the file is fully on disk. 3257 */ 3258 if (S_ISREG(inode->i_mode)) 3259 BTRFS_I(inode)->last_unlink_trans = trans->transid; 3260 3261 /* 3262 * if this directory was already logged any new 3263 * names for this file/dir will get recorded 3264 */ 3265 smp_mb(); 3266 if (BTRFS_I(dir)->logged_trans == trans->transid) 3267 return; 3268 3269 /* 3270 * if the inode we're about to unlink was logged, 3271 * the log will be properly updated for any new names 3272 */ 3273 if (BTRFS_I(inode)->logged_trans == trans->transid) 3274 return; 3275 3276 /* 3277 * when renaming files across directories, if the directory 3278 * there we're unlinking from gets fsync'd later on, there's 3279 * no way to find the destination directory later and fsync it 3280 * properly. So, we have to be conservative and force commits 3281 * so the new name gets discovered. 3282 */ 3283 if (for_rename) 3284 goto record; 3285 3286 /* we can safely do the unlink without any special recording */ 3287 return; 3288 3289 record: 3290 BTRFS_I(dir)->last_unlink_trans = trans->transid; 3291 } 3292 3293 /* 3294 * Call this after adding a new name for a file and it will properly 3295 * update the log to reflect the new name. 3296 * 3297 * It will return zero if all goes well, and it will return 1 if a 3298 * full transaction commit is required. 3299 */ 3300 int btrfs_log_new_name(struct btrfs_trans_handle *trans, 3301 struct inode *inode, struct inode *old_dir, 3302 struct dentry *parent) 3303 { 3304 struct btrfs_root * root = BTRFS_I(inode)->root; 3305 3306 /* 3307 * this will force the logging code to walk the dentry chain 3308 * up for the file 3309 */ 3310 if (S_ISREG(inode->i_mode)) 3311 BTRFS_I(inode)->last_unlink_trans = trans->transid; 3312 3313 /* 3314 * if this inode hasn't been logged and directory we're renaming it 3315 * from hasn't been logged, we don't need to log it 3316 */ 3317 if (BTRFS_I(inode)->logged_trans <= 3318 root->fs_info->last_trans_committed && 3319 (!old_dir || BTRFS_I(old_dir)->logged_trans <= 3320 root->fs_info->last_trans_committed)) 3321 return 0; 3322 3323 return btrfs_log_inode_parent(trans, root, inode, parent, 1); 3324 } 3325 3326