kernel/fs/btrfs/tree-log.c

   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 <linux/blkdev.h>
  22 #include <linux/list_sort.h>
  23 #include "tree-log.h"
  24 #include "disk-io.h"
  25 #include "locking.h"
  26 #include "print-tree.h"
  27 #include "backref.h"
  28 #include "hash.h"
  29
  30 /* magic values for the inode_only field in btrfs_log_inode:
  31  *
  32  * LOG_INODE_ALL means to log everything
  33  * LOG_INODE_EXISTS means to log just enough to recreate the inode
  34  * during log replay
  35  */
  36 #define LOG_INODE_ALL 0
  37 #define LOG_INODE_EXISTS 1
  38
  39 /*
  40  * directory trouble cases
  41  *
  42  * 1) on rename or unlink, if the inode being unlinked isn't in the fsync
  43  * log, we must force a full commit before doing an fsync of the directory
  44  * where the unlink was done.
  45  * ---> record transid of last unlink/rename per directory
  46  *
  47  * mkdir foo/some_dir
  48  * normal commit
  49  * rename foo/some_dir foo2/some_dir
  50  * mkdir foo/some_dir
  51  * fsync foo/some_dir/some_file
  52  *
  53  * The fsync above will unlink the original some_dir without recording
  54  * it in its new location (foo2).  After a crash, some_dir will be gone
  55  * unless the fsync of some_file forces a full commit
  56  *
  57  * 2) we must log any new names for any file or dir that is in the fsync
  58  * log. ---> check inode while renaming/linking.
  59  *
  60  * 2a) we must log any new names for any file or dir during rename
  61  * when the directory they are being removed from was logged.
  62  * ---> check inode and old parent dir during rename
  63  *
  64  *  2a is actually the more important variant.  With the extra logging
  65  *  a crash might unlink the old name without recreating the new one
  66  *
  67  * 3) after a crash, we must go through any directories with a link count
  68  * of zero and redo the rm -rf
  69  *
  70  * mkdir f1/foo
  71  * normal commit
  72  * rm -rf f1/foo
  73  * fsync(f1)
  74  *
  75  * The directory f1 was fully removed from the FS, but fsync was never
  76  * called on f1, only its parent dir.  After a crash the rm -rf must
  77  * be replayed.  This must be able to recurse down the entire
  78  * directory tree.  The inode link count fixup code takes care of the
  79  * ugly details.
  80  */
  81
  82 /*
  83  * stages for the tree walking.  The first
  84  * stage (0) is to only pin down the blocks we find
  85  * the second stage (1) is to make sure that all the inodes
  86  * we find in the log are created in the subvolume.
  87  *
  88  * The last stage is to deal with directories and links and extents
  89  * and all the other fun semantics
  90  */
  91 #define LOG_WALK_PIN_ONLY 0
  92 #define LOG_WALK_REPLAY_INODES 1
  93 #define LOG_WALK_REPLAY_DIR_INDEX 2
  94 #define LOG_WALK_REPLAY_ALL 3
  95
  96 static int btrfs_log_inode(struct btrfs_trans_handle *trans,
  97                            struct btrfs_root *root, struct inode *inode,
  98                            int inode_only,
  99                            const loff_t start,
 100                            const loff_t end,
 101                            struct btrfs_log_ctx *ctx);
 102 static int link_to_fixup_dir(struct btrfs_trans_handle *trans,
 103                              struct btrfs_root *root,
 104                              struct btrfs_path *path, u64 objectid);
 105 static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
 106                                        struct btrfs_root *root,
 107                                        struct btrfs_root *log,
 108                                        struct btrfs_path *path,
 109                                        u64 dirid, int del_all);
 110
 111 /*
 112  * tree logging is a special write ahead log used to make sure that
 113  * fsyncs and O_SYNCs can happen without doing full tree commits.
 114  *
 115  * Full tree commits are expensive because they require commonly
 116  * modified blocks to be recowed, creating many dirty pages in the
 117  * extent tree an 4x-6x higher write load than ext3.
 118  *
 119  * Instead of doing a tree commit on every fsync, we use the
 120  * key ranges and transaction ids to find items for a given file or directory
 121  * that have changed in this transaction.  Those items are copied into
 122  * a special tree (one per subvolume root), that tree is written to disk
 123  * and then the fsync is considered complete.
 124  *
 125  * After a crash, items are copied out of the log-tree back into the
 126  * subvolume tree.  Any file data extents found are recorded in the extent
 127  * allocation tree, and the log-tree freed.
 128  *
 129  * The log tree is read three times, once to pin down all the extents it is
 130  * using in ram and once, once to create all the inodes logged in the tree
 131  * and once to do all the other items.
 132  */
 133
 134 /*
 135  * start a sub transaction and setup the log tree
 136  * this increments the log tree writer count to make the people
 137  * syncing the tree wait for us to finish
 138  */
 139 static int start_log_trans(struct btrfs_trans_handle *trans,
 140                            struct btrfs_root *root,
 141                            struct btrfs_log_ctx *ctx)
 142 {
 143         int ret = 0;
 144
 145         mutex_lock(&root->log_mutex);
 146
 147         if (root->log_root) {
 148                 if (btrfs_need_log_full_commit(root->fs_info, trans)) {
 149                         ret = -EAGAIN;
 150                         goto out;
 151                 }
 152
 153                 if (!root->log_start_pid) {
 154                         clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
 155                         root->log_start_pid = current->pid;
 156                 } else if (root->log_start_pid != current->pid) {
 157                         set_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
 158                 }
 159         } else {
 160                 mutex_lock(&root->fs_info->tree_log_mutex);
 161                 if (!root->fs_info->log_root_tree)
 162                         ret = btrfs_init_log_root_tree(trans, root->fs_info);
 163                 mutex_unlock(&root->fs_info->tree_log_mutex);
 164                 if (ret)
 165                         goto out;
 166
 167                 ret = btrfs_add_log_tree(trans, root);
 168                 if (ret)
 169                         goto out;
 170
 171                 clear_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state);
 172                 root->log_start_pid = current->pid;
 173         }
 174
 175         atomic_inc(&root->log_batch);
 176         atomic_inc(&root->log_writers);
 177         if (ctx) {
 178                 int index = root->log_transid % 2;
 179                 list_add_tail(&ctx->list, &root->log_ctxs[index]);
 180                 ctx->log_transid = root->log_transid;
 181         }
 182
 183 out:
 184         mutex_unlock(&root->log_mutex);
 185         return ret;
 186 }
 187
 188 /*
 189  * returns 0 if there was a log transaction running and we were able
 190  * to join, or returns -ENOENT if there were not transactions
 191  * in progress
 192  */
 193 static int join_running_log_trans(struct btrfs_root *root)
 194 {
 195         int ret = -ENOENT;
 196
 197         smp_mb();
 198         if (!root->log_root)
 199                 return -ENOENT;
 200
 201         mutex_lock(&root->log_mutex);
 202         if (root->log_root) {
 203                 ret = 0;
 204                 atomic_inc(&root->log_writers);
 205         }
 206         mutex_unlock(&root->log_mutex);
 207         return ret;
 208 }
 209
 210 /*
 211  * This either makes the current running log transaction wait
 212  * until you call btrfs_end_log_trans() or it makes any future
 213  * log transactions wait until you call btrfs_end_log_trans()
 214  */
 215 int btrfs_pin_log_trans(struct btrfs_root *root)
 216 {
 217         int ret = -ENOENT;
 218
 219         mutex_lock(&root->log_mutex);
 220         atomic_inc(&root->log_writers);
 221         mutex_unlock(&root->log_mutex);
 222         return ret;
 223 }
 224
 225 /*
 226  * indicate we're done making changes to the log tree
 227  * and wake up anyone waiting to do a sync
 228  */
 229 void btrfs_end_log_trans(struct btrfs_root *root)
 230 {
 231         if (atomic_dec_and_test(&root->log_writers)) {
 232                 /*
 233                  * Implicit memory barrier after atomic_dec_and_test
 234                  */
 235                 if (waitqueue_active(&root->log_writer_wait))
 236                         wake_up(&root->log_writer_wait);
 237         }
 238 }
 239
 240
 241 /*
 242  * the walk control struct is used to pass state down the chain when
 243  * processing the log tree.  The stage field tells us which part
 244  * of the log tree processing we are currently doing.  The others
 245  * are state fields used for that specific part
 246  */
 247 struct walk_control {
 248         /* should we free the extent on disk when done?  This is used
 249          * at transaction commit time while freeing a log tree
 250          */
 251         int free;
 252
 253         /* should we write out the extent buffer?  This is used
 254          * while flushing the log tree to disk during a sync
 255          */
 256         int write;
 257
 258         /* should we wait for the extent buffer io to finish?  Also used
 259          * while flushing the log tree to disk for a sync
 260          */
 261         int wait;
 262
 263         /* pin only walk, we record which extents on disk belong to the
 264          * log trees
 265          */
 266         int pin;
 267
 268         /* what stage of the replay code we're currently in */
 269         int stage;
 270
 271         /* the root we are currently replaying */
 272         struct btrfs_root *replay_dest;
 273
 274         /* the trans handle for the current replay */
 275         struct btrfs_trans_handle *trans;
 276
 277         /* the function that gets used to process blocks we find in the
 278          * tree.  Note the extent_buffer might not be up to date when it is
 279          * passed in, and it must be checked or read if you need the data
 280          * inside it
 281          */
 282         int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb,
 283                             struct walk_control *wc, u64 gen);
 284 };
 285
 286 /*
 287  * process_func used to pin down extents, write them or wait on them
 288  */
 289 static int process_one_buffer(struct btrfs_root *log,
 290                               struct extent_buffer *eb,
 291                               struct walk_control *wc, u64 gen)
 292 {
 293         int ret = 0;
 294
 295         /*
 296          * If this fs is mixed then we need to be able to process the leaves to
 297          * pin down any logged extents, so we have to read the block.
 298          */
 299         if (btrfs_fs_incompat(log->fs_info, MIXED_GROUPS)) {
 300                 ret = btrfs_read_buffer(eb, gen);
 301                 if (ret)
 302                         return ret;
 303         }
 304
 305         if (wc->pin)
 306                 ret = btrfs_pin_extent_for_log_replay(log->fs_info->extent_root,
 307                                                       eb->start, eb->len);
 308
 309         if (!ret && btrfs_buffer_uptodate(eb, gen, 0)) {
 310                 if (wc->pin && btrfs_header_level(eb) == 0)
 311                         ret = btrfs_exclude_logged_extents(log, eb);
 312                 if (wc->write)
 313                         btrfs_write_tree_block(eb);
 314                 if (wc->wait)
 315                         btrfs_wait_tree_block_writeback(eb);
 316         }
 317         return ret;
 318 }
 319
 320 /*
 321  * Item overwrite used by replay and tree logging.  eb, slot and key all refer
 322  * to the src data we are copying out.
 323  *
 324  * root is the tree we are copying into, and path is a scratch
 325  * path for use in this function (it should be released on entry and
 326  * will be released on exit).
 327  *
 328  * If the key is already in the destination tree the existing item is
 329  * overwritten.  If the existing item isn't big enough, it is extended.
 330  * If it is too large, it is truncated.
 331  *
 332  * If the key isn't in the destination yet, a new item is inserted.
 333  */
 334 static noinline int overwrite_item(struct btrfs_trans_handle *trans,
 335                                    struct btrfs_root *root,
 336                                    struct btrfs_path *path,
 337                                    struct extent_buffer *eb, int slot,
 338                                    struct btrfs_key *key)
 339 {
 340         int ret;
 341         u32 item_size;
 342         u64 saved_i_size = 0;
 343         int save_old_i_size = 0;
 344         unsigned long src_ptr;
 345         unsigned long dst_ptr;
 346         int overwrite_root = 0;
 347         bool inode_item = key->type == BTRFS_INODE_ITEM_KEY;
 348
 349         if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
 350                 overwrite_root = 1;
 351
 352         item_size = btrfs_item_size_nr(eb, slot);
 353         src_ptr = btrfs_item_ptr_offset(eb, slot);
 354
 355         /* look for the key in the destination tree */
 356         ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
 357         if (ret < 0)
 358                 return ret;
 359
 360         if (ret == 0) {
 361                 char *src_copy;
 362                 char *dst_copy;
 363                 u32 dst_size = btrfs_item_size_nr(path->nodes[0],
 364                                                   path->slots[0]);
 365                 if (dst_size != item_size)
 366                         goto insert;
 367
 368                 if (item_size == 0) {
 369                         btrfs_release_path(path);
 370                         return 0;
 371                 }
 372                 dst_copy = kmalloc(item_size, GFP_NOFS);
 373                 src_copy = kmalloc(item_size, GFP_NOFS);
 374                 if (!dst_copy || !src_copy) {
 375                         btrfs_release_path(path);
 376                         kfree(dst_copy);
 377                         kfree(src_copy);
 378                         return -ENOMEM;
 379                 }
 380
 381                 read_extent_buffer(eb, src_copy, src_ptr, item_size);
 382
 383                 dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
 384                 read_extent_buffer(path->nodes[0], dst_copy, dst_ptr,
 385                                    item_size);
 386                 ret = memcmp(dst_copy, src_copy, item_size);
 387
 388                 kfree(dst_copy);
 389                 kfree(src_copy);
 390                 /*
 391                  * they have the same contents, just return, this saves
 392                  * us from cowing blocks in the destination tree and doing
 393                  * extra writes that may not have been done by a previous
 394                  * sync
 395                  */
 396                 if (ret == 0) {
 397                         btrfs_release_path(path);
 398                         return 0;
 399                 }
 400
 401                 /*
 402                  * We need to load the old nbytes into the inode so when we
 403                  * replay the extents we've logged we get the right nbytes.
 404                  */
 405                 if (inode_item) {
 406                         struct btrfs_inode_item *item;
 407                         u64 nbytes;
 408                         u32 mode;
 409
 410                         item = btrfs_item_ptr(path->nodes[0], path->slots[0],
 411                                               struct btrfs_inode_item);
 412                         nbytes = btrfs_inode_nbytes(path->nodes[0], item);
 413                         item = btrfs_item_ptr(eb, slot,
 414                                               struct btrfs_inode_item);
 415                         btrfs_set_inode_nbytes(eb, item, nbytes);
 416
 417                         /*
 418                          * If this is a directory we need to reset the i_size to
 419                          * 0 so that we can set it up properly when replaying
 420                          * the rest of the items in this log.
 421                          */
 422                         mode = btrfs_inode_mode(eb, item);
 423                         if (S_ISDIR(mode))
 424                                 btrfs_set_inode_size(eb, item, 0);
 425                 }
 426         } else if (inode_item) {
 427                 struct btrfs_inode_item *item;
 428                 u32 mode;
 429
 430                 /*
 431                  * New inode, set nbytes to 0 so that the nbytes comes out
 432                  * properly when we replay the extents.
 433                  */
 434                 item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
 435                 btrfs_set_inode_nbytes(eb, item, 0);
 436
 437                 /*
 438                  * If this is a directory we need to reset the i_size to 0 so
 439                  * that we can set it up properly when replaying the rest of
 440                  * the items in this log.
 441                  */
 442                 mode = btrfs_inode_mode(eb, item);
 443                 if (S_ISDIR(mode))
 444                         btrfs_set_inode_size(eb, item, 0);
 445         }
 446 insert:
 447         btrfs_release_path(path);
 448         /* try to insert the key into the destination tree */
 449         path->skip_release_on_error = 1;
 450         ret = btrfs_insert_empty_item(trans, root, path,
 451                                       key, item_size);
 452         path->skip_release_on_error = 0;
 453
 454         /* make sure any existing item is the correct size */
 455         if (ret == -EEXIST || ret == -EOVERFLOW) {
 456                 u32 found_size;
 457                 found_size = btrfs_item_size_nr(path->nodes[0],
 458                                                 path->slots[0]);
 459                 if (found_size > item_size)
 460                         btrfs_truncate_item(root, path, item_size, 1);
 461                 else if (found_size < item_size)
 462                         btrfs_extend_item(root, path,
 463                                           item_size - found_size);
 464         } else if (ret) {
 465                 return ret;
 466         }
 467         dst_ptr = btrfs_item_ptr_offset(path->nodes[0],
 468                                         path->slots[0]);
 469
 470         /* don't overwrite an existing inode if the generation number
 471          * was logged as zero.  This is done when the tree logging code
 472          * is just logging an inode to make sure it exists after recovery.
 473          *
 474          * Also, don't overwrite i_size on directories during replay.
 475          * log replay inserts and removes directory items based on the
 476          * state of the tree found in the subvolume, and i_size is modified
 477          * as it goes
 478          */
 479         if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
 480                 struct btrfs_inode_item *src_item;
 481                 struct btrfs_inode_item *dst_item;
 482
 483                 src_item = (struct btrfs_inode_item *)src_ptr;
 484                 dst_item = (struct btrfs_inode_item *)dst_ptr;
 485
 486                 if (btrfs_inode_generation(eb, src_item) == 0) {
 487                         struct extent_buffer *dst_eb = path->nodes[0];
 488                         const u64 ino_size = btrfs_inode_size(eb, src_item);
 489
 490                         /*
 491                          * For regular files an ino_size == 0 is used only when
 492                          * logging that an inode exists, as part of a directory
 493                          * fsync, and the inode wasn't fsynced before. In this
 494                          * case don't set the size of the inode in the fs/subvol
 495                          * tree, otherwise we would be throwing valid data away.
 496                          */
 497                         if (S_ISREG(btrfs_inode_mode(eb, src_item)) &&
 498                             S_ISREG(btrfs_inode_mode(dst_eb, dst_item)) &&
 499                             ino_size != 0) {
 500                                 struct btrfs_map_token token;
 501
 502                                 btrfs_init_map_token(&token);
 503                                 btrfs_set_token_inode_size(dst_eb, dst_item,
 504                                                            ino_size, &token);
 505                         }
 506                         goto no_copy;
 507                 }
 508
 509                 if (overwrite_root &&
 510                     S_ISDIR(btrfs_inode_mode(eb, src_item)) &&
 511                     S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) {
 512                         save_old_i_size = 1;
 513                         saved_i_size = btrfs_inode_size(path->nodes[0],
 514                                                         dst_item);
 515                 }
 516         }
 517
 518         copy_extent_buffer(path->nodes[0], eb, dst_ptr,
 519                            src_ptr, item_size);
 520
 521         if (save_old_i_size) {
 522                 struct btrfs_inode_item *dst_item;
 523                 dst_item = (struct btrfs_inode_item *)dst_ptr;
 524                 btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size);
 525         }
 526
 527         /* make sure the generation is filled in */
 528         if (key->type == BTRFS_INODE_ITEM_KEY) {
 529                 struct btrfs_inode_item *dst_item;
 530                 dst_item = (struct btrfs_inode_item *)dst_ptr;
 531                 if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) {
 532                         btrfs_set_inode_generation(path->nodes[0], dst_item,
 533                                                    trans->transid);
 534                 }
 535         }
 536 no_copy:
 537         btrfs_mark_buffer_dirty(path->nodes[0]);
 538         btrfs_release_path(path);
 539         return 0;
 540 }
 541
 542 /*
 543  * simple helper to read an inode off the disk from a given root
 544  * This can only be called for subvolume roots and not for the log
 545  */
 546 static noinline struct inode *read_one_inode(struct btrfs_root *root,
 547                                              u64 objectid)
 548 {
 549         struct btrfs_key key;
 550         struct inode *inode;
 551
 552         key.objectid = objectid;
 553         key.type = BTRFS_INODE_ITEM_KEY;
 554         key.offset = 0;
 555         inode = btrfs_iget(root->fs_info->sb, &key, root, NULL);
 556         if (IS_ERR(inode)) {
 557                 inode = NULL;
 558         } else if (is_bad_inode(inode)) {
 559                 iput(inode);
 560                 inode = NULL;
 561         }
 562         return inode;
 563 }
 564
 565 /* replays a single extent in 'eb' at 'slot' with 'key' into the
 566  * subvolume 'root'.  path is released on entry and should be released
 567  * on exit.
 568  *
 569  * extents in the log tree have not been allocated out of the extent
 570  * tree yet.  So, this completes the allocation, taking a reference
 571  * as required if the extent already exists or creating a new extent
 572  * if it isn't in the extent allocation tree yet.
 573  *
 574  * The extent is inserted into the file, dropping any existing extents
 575  * from the file that overlap the new one.
 576  */
 577 static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
 578                                       struct btrfs_root *root,
 579                                       struct btrfs_path *path,
 580                                       struct extent_buffer *eb, int slot,
 581                                       struct btrfs_key *key)
 582 {
 583         int found_type;
 584         u64 extent_end;
 585         u64 start = key->offset;
 586         u64 nbytes = 0;
 587         struct btrfs_file_extent_item *item;
 588         struct inode *inode = NULL;
 589         unsigned long size;
 590         int ret = 0;
 591
 592         item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
 593         found_type = btrfs_file_extent_type(eb, item);
 594
 595         if (found_type == BTRFS_FILE_EXTENT_REG ||
 596             found_type == BTRFS_FILE_EXTENT_PREALLOC) {
 597                 nbytes = btrfs_file_extent_num_bytes(eb, item);
 598                 extent_end = start + nbytes;
 599
 600                 /*
 601                  * We don't add to the inodes nbytes if we are prealloc or a
 602                  * hole.
 603                  */
 604                 if (btrfs_file_extent_disk_bytenr(eb, item) == 0)
 605                         nbytes = 0;
 606         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
 607                 size = btrfs_file_extent_inline_len(eb, slot, item);
 608                 nbytes = btrfs_file_extent_ram_bytes(eb, item);
 609                 extent_end = ALIGN(start + size, root->sectorsize);
 610         } else {
 611                 ret = 0;
 612                 goto out;
 613         }
 614
 615         inode = read_one_inode(root, key->objectid);
 616         if (!inode) {
 617                 ret = -EIO;
 618                 goto out;
 619         }
 620
 621         /*
 622          * first check to see if we already have this extent in the
 623          * file.  This must be done before the btrfs_drop_extents run
 624          * so we don't try to drop this extent.
 625          */
 626         ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
 627                                        start, 0);
 628
 629         if (ret == 0 &&
 630             (found_type == BTRFS_FILE_EXTENT_REG ||
 631              found_type == BTRFS_FILE_EXTENT_PREALLOC)) {
 632                 struct btrfs_file_extent_item cmp1;
 633                 struct btrfs_file_extent_item cmp2;
 634                 struct btrfs_file_extent_item *existing;
 635                 struct extent_buffer *leaf;
 636
 637                 leaf = path->nodes[0];
 638                 existing = btrfs_item_ptr(leaf, path->slots[0],
 639                                           struct btrfs_file_extent_item);
 640
 641                 read_extent_buffer(eb, &cmp1, (unsigned long)item,
 642                                    sizeof(cmp1));
 643                 read_extent_buffer(leaf, &cmp2, (unsigned long)existing,
 644                                    sizeof(cmp2));
 645
 646                 /*
 647                  * we already have a pointer to this exact extent,
 648                  * we don't have to do anything
 649                  */
 650                 if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) {
 651                         btrfs_release_path(path);
 652                         goto out;
 653                 }
 654         }
 655         btrfs_release_path(path);
 656
 657         /* drop any overlapping extents */
 658         ret = btrfs_drop_extents(trans, root, inode, start, extent_end, 1);
 659         if (ret)
 660                 goto out;
 661
 662         if (found_type == BTRFS_FILE_EXTENT_REG ||
 663             found_type == BTRFS_FILE_EXTENT_PREALLOC) {
 664                 u64 offset;
 665                 unsigned long dest_offset;
 666                 struct btrfs_key ins;
 667
 668                 ret = btrfs_insert_empty_item(trans, root, path, key,
 669                                               sizeof(*item));
 670                 if (ret)
 671                         goto out;
 672                 dest_offset = btrfs_item_ptr_offset(path->nodes[0],
 673                                                     path->slots[0]);
 674                 copy_extent_buffer(path->nodes[0], eb, dest_offset,
 675                                 (unsigned long)item,  sizeof(*item));
 676
 677                 ins.objectid = btrfs_file_extent_disk_bytenr(eb, item);
 678                 ins.offset = btrfs_file_extent_disk_num_bytes(eb, item);
 679                 ins.type = BTRFS_EXTENT_ITEM_KEY;
 680                 offset = key->offset - btrfs_file_extent_offset(eb, item);
 681
 682                 if (ins.objectid > 0) {
 683                         u64 csum_start;
 684                         u64 csum_end;
 685                         LIST_HEAD(ordered_sums);
 686                         /*
 687                          * is this extent already allocated in the extent
 688                          * allocation tree?  If so, just add a reference
 689                          */
 690                         ret = btrfs_lookup_data_extent(root, ins.objectid,
 691                                                 ins.offset);
 692                         if (ret == 0) {
 693                                 ret = btrfs_inc_extent_ref(trans, root,
 694                                                 ins.objectid, ins.offset,
 695                                                 0, root->root_key.objectid,
 696                                                 key->objectid, offset);
 697                                 if (ret)
 698                                         goto out;
 699                         } else {
 700                                 /*
 701                                  * insert the extent pointer in the extent
 702                                  * allocation tree
 703                                  */
 704                                 ret = btrfs_alloc_logged_file_extent(trans,
 705                                                 root, root->root_key.objectid,
 706                                                 key->objectid, offset, &ins);
 707                                 if (ret)
 708                                         goto out;
 709                         }
 710                         btrfs_release_path(path);
 711
 712                         if (btrfs_file_extent_compression(eb, item)) {
 713                                 csum_start = ins.objectid;
 714                                 csum_end = csum_start + ins.offset;
 715                         } else {
 716                                 csum_start = ins.objectid +
 717                                         btrfs_file_extent_offset(eb, item);
 718                                 csum_end = csum_start +
 719                                         btrfs_file_extent_num_bytes(eb, item);
 720                         }
 721
 722                         ret = btrfs_lookup_csums_range(root->log_root,
 723                                                 csum_start, csum_end - 1,
 724                                                 &ordered_sums, 0);
 725                         if (ret)
 726                                 goto out;
 727                         /*
 728                          * Now delete all existing cums in the csum root that
 729                          * cover our range. We do this because we can have an
 730                          * extent that is completely referenced by one file
 731                          * extent item and partially referenced by another
 732                          * file extent item (like after using the clone or
 733                          * extent_same ioctls). In this case if we end up doing
 734                          * the replay of the one that partially references the
 735                          * extent first, and we do not do the csum deletion
 736                          * below, we can get 2 csum items in the csum tree that
 737                          * overlap each other. For example, imagine our log has
 738                          * the two following file extent items:
 739                          *
 740                          * key (257 EXTENT_DATA 409600)
 741                          *     extent data disk byte 12845056 nr 102400
 742                          *     extent data offset 20480 nr 20480 ram 102400
 743                          *
 744                          * key (257 EXTENT_DATA 819200)
 745                          *     extent data disk byte 12845056 nr 102400
 746                          *     extent data offset 0 nr 102400 ram 102400
 747                          *
 748                          * Where the second one fully references the 100K extent
 749                          * that starts at disk byte 12845056, and the log tree
 750                          * has a single csum item that covers the entire range
 751                          * of the extent:
 752                          *
 753                          * key (EXTENT_CSUM EXTENT_CSUM 12845056) itemsize 100
 754                          *
 755                          * After the first file extent item is replayed, the
 756                          * csum tree gets the following csum item:
 757                          *
 758                          * key (EXTENT_CSUM EXTENT_CSUM 12865536) itemsize 20
 759                          *
 760                          * Which covers the 20K sub-range starting at offset 20K
 761                          * of our extent. Now when we replay the second file
 762                          * extent item, if we do not delete existing csum items
 763                          * that cover any of its blocks, we end up getting two
 764                          * csum items in our csum tree that overlap each other:
 765                          *
 766                          * key (EXTENT_CSUM EXTENT_CSUM 12845056) itemsize 100
 767                          * key (EXTENT_CSUM EXTENT_CSUM 12865536) itemsize 20
 768                          *
 769                          * Which is a problem, because after this anyone trying
 770                          * to lookup up for the checksum of any block of our
 771                          * extent starting at an offset of 40K or higher, will
 772                          * end up looking at the second csum item only, which
 773                          * does not contain the checksum for any block starting
 774                          * at offset 40K or higher of our extent.
 775                          */
 776                         while (!list_empty(&ordered_sums)) {
 777                                 struct btrfs_ordered_sum *sums;
 778                                 sums = list_entry(ordered_sums.next,
 779                                                 struct btrfs_ordered_sum,
 780                                                 list);
 781                                 if (!ret)
 782                                         ret = btrfs_del_csums(trans,
 783                                                       root->fs_info->csum_root,
 784                                                       sums->bytenr,
 785                                                       sums->len);
 786                                 if (!ret)
 787                                         ret = btrfs_csum_file_blocks(trans,
 788                                                 root->fs_info->csum_root,
 789                                                 sums);
 790                                 list_del(&sums->list);
 791                                 kfree(sums);
 792                         }
 793                         if (ret)
 794                                 goto out;
 795                 } else {
 796                         btrfs_release_path(path);
 797                 }
 798         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
 799                 /* inline extents are easy, we just overwrite them */
 800                 ret = overwrite_item(trans, root, path, eb, slot, key);
 801                 if (ret)
 802                         goto out;
 803         }
 804
 805         inode_add_bytes(inode, nbytes);
 806         ret = btrfs_update_inode(trans, root, inode);
 807 out:
 808         if (inode)
 809                 iput(inode);
 810         return ret;
 811 }
 812
 813 /*
 814  * when cleaning up conflicts between the directory names in the
 815  * subvolume, directory names in the log and directory names in the
 816  * inode back references, we may have to unlink inodes from directories.
 817  *
 818  * This is a helper function to do the unlink of a specific directory
 819  * item
 820  */
 821 static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
 822                                       struct btrfs_root *root,
 823                                       struct btrfs_path *path,
 824                                       struct inode *dir,
 825                                       struct btrfs_dir_item *di)
 826 {
 827         struct inode *inode;
 828         char *name;
 829         int name_len;
 830         struct extent_buffer *leaf;
 831         struct btrfs_key location;
 832         int ret;
 833
 834         leaf = path->nodes[0];
 835
 836         btrfs_dir_item_key_to_cpu(leaf, di, &location);
 837         name_len = btrfs_dir_name_len(leaf, di);
 838         name = kmalloc(name_len, GFP_NOFS);
 839         if (!name)
 840                 return -ENOMEM;
 841
 842         read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len);
 843         btrfs_release_path(path);
 844
 845         inode = read_one_inode(root, location.objectid);
 846         if (!inode) {
 847                 ret = -EIO;
 848                 goto out;
 849         }
 850
 851         ret = link_to_fixup_dir(trans, root, path, location.objectid);
 852         if (ret)
 853                 goto out;
 854
 855         ret = btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
 856         if (ret)
 857                 goto out;
 858         else
 859                 ret = btrfs_run_delayed_items(trans, root);
 860 out:
 861         kfree(name);
 862         iput(inode);
 863         return ret;
 864 }
 865
 866 /*
 867  * helper function to see if a given name and sequence number found
 868  * in an inode back reference are already in a directory and correctly
 869  * point to this inode
 870  */
 871 static noinline int inode_in_dir(struct btrfs_root *root,
 872                                  struct btrfs_path *path,
 873                                  u64 dirid, u64 objectid, u64 index,
 874                                  const char *name, int name_len)
 875 {
 876         struct btrfs_dir_item *di;
 877         struct btrfs_key location;
 878         int match = 0;
 879
 880         di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
 881                                          index, name, name_len, 0);
 882         if (di && !IS_ERR(di)) {
 883                 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
 884                 if (location.objectid != objectid)
 885                         goto out;
 886         } else
 887                 goto out;
 888         btrfs_release_path(path);
 889
 890         di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
 891         if (di && !IS_ERR(di)) {
 892                 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
 893                 if (location.objectid != objectid)
 894                         goto out;
 895         } else
 896                 goto out;
 897         match = 1;
 898 out:
 899         btrfs_release_path(path);
 900         return match;
 901 }
 902
 903 /*
 904  * helper function to check a log tree for a named back reference in
 905  * an inode.  This is used to decide if a back reference that is
 906  * found in the subvolume conflicts with what we find in the log.
 907  *
 908  * inode backreferences may have multiple refs in a single item,
 909  * during replay we process one reference at a time, and we don't
 910  * want to delete valid links to a file from the subvolume if that
 911  * link is also in the log.
 912  */
 913 static noinline int backref_in_log(struct btrfs_root *log,
 914                                    struct btrfs_key *key,
 915                                    u64 ref_objectid,
 916                                    const char *name, int namelen)
 917 {
 918         struct btrfs_path *path;
 919         struct btrfs_inode_ref *ref;
 920         unsigned long ptr;
 921         unsigned long ptr_end;
 922         unsigned long name_ptr;
 923         int found_name_len;
 924         int item_size;
 925         int ret;
 926         int match = 0;
 927
 928         path = btrfs_alloc_path();
 929         if (!path)
 930                 return -ENOMEM;
 931
 932         ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
 933         if (ret != 0)
 934                 goto out;
 935
 936         ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
 937
 938         if (key->type == BTRFS_INODE_EXTREF_KEY) {
 939                 if (btrfs_find_name_in_ext_backref(path, ref_objectid,
 940                                                    name, namelen, NULL))
 941                         match = 1;
 942
 943                 goto out;
 944         }
 945
 946         item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
 947         ptr_end = ptr + item_size;
 948         while (ptr < ptr_end) {
 949                 ref = (struct btrfs_inode_ref *)ptr;
 950                 found_name_len = btrfs_inode_ref_name_len(path->nodes[0], ref);
 951                 if (found_name_len == namelen) {
 952                         name_ptr = (unsigned long)(ref + 1);
 953                         ret = memcmp_extent_buffer(path->nodes[0], name,
 954                                                    name_ptr, namelen);
 955                         if (ret == 0) {
 956                                 match = 1;
 957                                 goto out;
 958                         }
 959                 }
 960                 ptr = (unsigned long)(ref + 1) + found_name_len;
 961         }
 962 out:
 963         btrfs_free_path(path);
 964         return match;
 965 }
 966
 967 static inline int __add_inode_ref(struct btrfs_trans_handle *trans,
 968                                   struct btrfs_root *root,
 969                                   struct btrfs_path *path,
 970                                   struct btrfs_root *log_root,
 971                                   struct inode *dir, struct inode *inode,
 972                                   struct extent_buffer *eb,
 973                                   u64 inode_objectid, u64 parent_objectid,
 974                                   u64 ref_index, char *name, int namelen,
 975                                   int *search_done)
 976 {
 977         int ret;
 978         char *victim_name;
 979         int victim_name_len;
 980         struct extent_buffer *leaf;
 981         struct btrfs_dir_item *di;
 982         struct btrfs_key search_key;
 983         struct btrfs_inode_extref *extref;
 984
 985 again:
 986         /* Search old style refs */
 987         search_key.objectid = inode_objectid;
 988         search_key.type = BTRFS_INODE_REF_KEY;
 989         search_key.offset = parent_objectid;
 990         ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
 991         if (ret == 0) {
 992                 struct btrfs_inode_ref *victim_ref;
 993                 unsigned long ptr;
 994                 unsigned long ptr_end;
 995
 996                 leaf = path->nodes[0];
 997
 998                 /* are we trying to overwrite a back ref for the root directory
 999                  * if so, just jump out, we're done
1000                  */
1001                 if (search_key.objectid == search_key.offset)
1002                         return 1;
1003
1004                 /* check all the names in this back reference to see
1005                  * if they are in the log.  if so, we allow them to stay
1006                  * otherwise they must be unlinked as a conflict
1007                  */
1008                 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
1009                 ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]);
1010                 while (ptr < ptr_end) {
1011                         victim_ref = (struct btrfs_inode_ref *)ptr;
1012                         victim_name_len = btrfs_inode_ref_name_len(leaf,
1013                                                                    victim_ref);
1014                         victim_name = kmalloc(victim_name_len, GFP_NOFS);
1015                         if (!victim_name)
1016                                 return -ENOMEM;
1017
1018                         read_extent_buffer(leaf, victim_name,
1019                                            (unsigned long)(victim_ref + 1),
1020                                            victim_name_len);
1021
1022                         if (!backref_in_log(log_root, &search_key,
1023                                             parent_objectid,
1024                                             victim_name,
1025                                             victim_name_len)) {
1026                                 inc_nlink(inode);
1027                                 btrfs_release_path(path);
1028
1029                                 ret = btrfs_unlink_inode(trans, root, dir,
1030                                                          inode, victim_name,
1031                                                          victim_name_len);
1032                                 kfree(victim_name);
1033                                 if (ret)
1034                                         return ret;
1035                                 ret = btrfs_run_delayed_items(trans, root);
1036                                 if (ret)
1037                                         return ret;
1038                                 *search_done = 1;
1039                                 goto again;
1040                         }
1041                         kfree(victim_name);
1042
1043                         ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
1044                 }
1045
1046                 /*
1047                  * NOTE: we have searched root tree and checked the
1048                  * coresponding ref, it does not need to check again.
1049                  */
1050                 *search_done = 1;
1051         }
1052         btrfs_release_path(path);
1053
1054         /* Same search but for extended refs */
1055         extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen,
1056                                            inode_objectid, parent_objectid, 0,
1057                                            0);
1058         if (!IS_ERR_OR_NULL(extref)) {
1059                 u32 item_size;
1060                 u32 cur_offset = 0;
1061                 unsigned long base;
1062                 struct inode *victim_parent;
1063
1064                 leaf = path->nodes[0];
1065
1066                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1067                 base = btrfs_item_ptr_offset(leaf, path->slots[0]);
1068
1069                 while (cur_offset < item_size) {
1070                         extref = (struct btrfs_inode_extref *)(base + cur_offset);
1071
1072                         victim_name_len = btrfs_inode_extref_name_len(leaf, extref);
1073
1074                         if (btrfs_inode_extref_parent(leaf, extref) != parent_objectid)
1075                                 goto next;
1076
1077                         victim_name = kmalloc(victim_name_len, GFP_NOFS);
1078                         if (!victim_name)
1079                                 return -ENOMEM;
1080                         read_extent_buffer(leaf, victim_name, (unsigned long)&extref->name,
1081                                            victim_name_len);
1082
1083                         search_key.objectid = inode_objectid;
1084                         search_key.type = BTRFS_INODE_EXTREF_KEY;
1085                         search_key.offset = btrfs_extref_hash(parent_objectid,
1086                                                               victim_name,
1087                                                               victim_name_len);
1088                         ret = 0;
1089                         if (!backref_in_log(log_root, &search_key,
1090                                             parent_objectid, victim_name,
1091                                             victim_name_len)) {
1092                                 ret = -ENOENT;
1093                                 victim_parent = read_one_inode(root,
1094                                                                parent_objectid);
1095                                 if (victim_parent) {
1096                                         inc_nlink(inode);
1097                                         btrfs_release_path(path);
1098
1099                                         ret = btrfs_unlink_inode(trans, root,
1100                                                                  victim_parent,
1101                                                                  inode,
1102                                                                  victim_name,
1103                                                                  victim_name_len);
1104                                         if (!ret)
1105                                                 ret = btrfs_run_delayed_items(
1106                                                                   trans, root);
1107                                 }
1108                                 iput(victim_parent);
1109                                 kfree(victim_name);
1110                                 if (ret)
1111                                         return ret;
1112                                 *search_done = 1;
1113                                 goto again;
1114                         }
1115                         kfree(victim_name);
1116                         if (ret)
1117                                 return ret;
1118 next:
1119                         cur_offset += victim_name_len + sizeof(*extref);
1120                 }
1121                 *search_done = 1;
1122         }
1123         btrfs_release_path(path);
1124
1125         /* look for a conflicting sequence number */
1126         di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
1127                                          ref_index, name, namelen, 0);
1128         if (di && !IS_ERR(di)) {
1129                 ret = drop_one_dir_item(trans, root, path, dir, di);
1130                 if (ret)
1131                         return ret;
1132         }
1133         btrfs_release_path(path);
1134
1135         /* look for a conflicing name */
1136         di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir),
1137                                    name, namelen, 0);
1138         if (di && !IS_ERR(di)) {
1139                 ret = drop_one_dir_item(trans, root, path, dir, di);
1140                 if (ret)
1141                         return ret;
1142         }
1143         btrfs_release_path(path);
1144
1145         return 0;
1146 }
1147
1148 static int extref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
1149                              u32 *namelen, char **name, u64 *index,
1150                              u64 *parent_objectid)
1151 {
1152         struct btrfs_inode_extref *extref;
1153
1154         extref = (struct btrfs_inode_extref *)ref_ptr;
1155
1156         *namelen = btrfs_inode_extref_name_len(eb, extref);
1157         *name = kmalloc(*namelen, GFP_NOFS);
1158         if (*name == NULL)
1159                 return -ENOMEM;
1160
1161         read_extent_buffer(eb, *name, (unsigned long)&extref->name,
1162                            *namelen);
1163
1164         *index = btrfs_inode_extref_index(eb, extref);
1165         if (parent_objectid)
1166                 *parent_objectid = btrfs_inode_extref_parent(eb, extref);
1167
1168         return 0;
1169 }
1170
1171 static int ref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
1172                           u32 *namelen, char **name, u64 *index)
1173 {
1174         struct btrfs_inode_ref *ref;
1175
1176         ref = (struct btrfs_inode_ref *)ref_ptr;
1177
1178         *namelen = btrfs_inode_ref_name_len(eb, ref);
1179         *name = kmalloc(*namelen, GFP_NOFS);
1180         if (*name == NULL)
1181                 return -ENOMEM;
1182
1183         read_extent_buffer(eb, *name, (unsigned long)(ref + 1), *namelen);
1184
1185         *index = btrfs_inode_ref_index(eb, ref);
1186
1187         return 0;
1188 }
1189
1190 /*
1191  * replay one inode back reference item found in the log tree.
1192  * eb, slot and key refer to the buffer and key found in the log tree.
1193  * root is the destination we are replaying into, and path is for temp
1194  * use by this function.  (it should be released on return).
1195  */
1196 static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
1197                                   struct btrfs_root *root,
1198                                   struct btrfs_root *log,
1199                                   struct btrfs_path *path,
1200                                   struct extent_buffer *eb, int slot,
1201                                   struct btrfs_key *key)
1202 {
1203         struct inode *dir = NULL;
1204         struct inode *inode = NULL;
1205         unsigned long ref_ptr;
1206         unsigned long ref_end;
1207         char *name = NULL;
1208         int namelen;
1209         int ret;
1210         int search_done = 0;
1211         int log_ref_ver = 0;
1212         u64 parent_objectid;
1213         u64 inode_objectid;
1214         u64 ref_index = 0;
1215         int ref_struct_size;
1216
1217         ref_ptr = btrfs_item_ptr_offset(eb, slot);
1218         ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
1219
1220         if (key->type == BTRFS_INODE_EXTREF_KEY) {
1221                 struct btrfs_inode_extref *r;
1222
1223                 ref_struct_size = sizeof(struct btrfs_inode_extref);
1224                 log_ref_ver = 1;
1225                 r = (struct btrfs_inode_extref *)ref_ptr;
1226                 parent_objectid = btrfs_inode_extref_parent(eb, r);
1227         } else {
1228                 ref_struct_size = sizeof(struct btrfs_inode_ref);
1229                 parent_objectid = key->offset;
1230         }
1231         inode_objectid = key->objectid;
1232
1233         /*
1234          * it is possible that we didn't log all the parent directories
1235          * for a given inode.  If we don't find the dir, just don't
1236          * copy the back ref in.  The link count fixup code will take
1237          * care of the rest
1238          */
1239         dir = read_one_inode(root, parent_objectid);
1240         if (!dir) {
1241                 ret = -ENOENT;
1242                 goto out;
1243         }
1244
1245         inode = read_one_inode(root, inode_objectid);
1246         if (!inode) {
1247                 ret = -EIO;
1248                 goto out;
1249         }
1250
1251         while (ref_ptr < ref_end) {
1252                 if (log_ref_ver) {
1253                         ret = extref_get_fields(eb, ref_ptr, &namelen, &name,
1254                                                 &ref_index, &parent_objectid);
1255                         /*
1256                          * parent object can change from one array
1257                          * item to another.
1258                          */
1259                         if (!dir)
1260                                 dir = read_one_inode(root, parent_objectid);
1261                         if (!dir) {
1262                                 ret = -ENOENT;
1263                                 goto out;
1264                         }
1265                 } else {
1266                         ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
1267                                              &ref_index);
1268                 }
1269                 if (ret)
1270                         goto out;
1271
1272                 /* if we already have a perfect match, we're done */
1273                 if (!inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
1274                                   ref_index, name, namelen)) {
1275                         /*
1276                          * look for a conflicting back reference in the
1277                          * metadata. if we find one we have to unlink that name
1278                          * of the file before we add our new link.  Later on, we
1279                          * overwrite any existing back reference, and we don't
1280                          * want to create dangling pointers in the directory.
1281                          */
1282
1283                         if (!search_done) {
1284                                 ret = __add_inode_ref(trans, root, path, log,
1285                                                       dir, inode, eb,
1286                                                       inode_objectid,
1287                                                       parent_objectid,
1288                                                       ref_index, name, namelen,
1289                                                       &search_done);
1290                                 if (ret) {
1291                                         if (ret == 1)
1292                                                 ret = 0;
1293                                         goto out;
1294                                 }
1295                         }
1296
1297                         /* insert our name */
1298                         ret = btrfs_add_link(trans, dir, inode, name, namelen,
1299                                              0, ref_index);
1300                         if (ret)
1301                                 goto out;
1302
1303                         btrfs_update_inode(trans, root, inode);
1304                 }
1305
1306                 ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
1307                 kfree(name);
1308                 name = NULL;
1309                 if (log_ref_ver) {
1310                         iput(dir);
1311                         dir = NULL;
1312                 }
1313         }
1314
1315         /* finally write the back reference in the inode */
1316         ret = overwrite_item(trans, root, path, eb, slot, key);
1317 out:
1318         btrfs_release_path(path);
1319         kfree(name);
1320         iput(dir);
1321         iput(inode);
1322         return ret;
1323 }
1324
1325 static int insert_orphan_item(struct btrfs_trans_handle *trans,
1326                               struct btrfs_root *root, u64 ino)
1327 {
1328         int ret;
1329
1330         ret = btrfs_insert_orphan_item(trans, root, ino);
1331         if (ret == -EEXIST)
1332                 ret = 0;
1333
1334         return ret;
1335 }
1336
1337 static int count_inode_extrefs(struct btrfs_root *root,
1338                                struct inode *inode, struct btrfs_path *path)
1339 {
1340         int ret = 0;
1341         int name_len;
1342         unsigned int nlink = 0;
1343         u32 item_size;
1344         u32 cur_offset = 0;
1345         u64 inode_objectid = btrfs_ino(inode);
1346         u64 offset = 0;
1347         unsigned long ptr;
1348         struct btrfs_inode_extref *extref;
1349         struct extent_buffer *leaf;
1350
1351         while (1) {
1352                 ret = btrfs_find_one_extref(root, inode_objectid, offset, path,
1353                                             &extref, &offset);
1354                 if (ret)
1355                         break;
1356
1357                 leaf = path->nodes[0];
1358                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1359                 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
1360                 cur_offset = 0;
1361
1362                 while (cur_offset < item_size) {
1363                         extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
1364                         name_len = btrfs_inode_extref_name_len(leaf, extref);
1365
1366                         nlink++;
1367
1368                         cur_offset += name_len + sizeof(*extref);
1369                 }
1370
1371                 offset++;
1372                 btrfs_release_path(path);
1373         }
1374         btrfs_release_path(path);
1375
1376         if (ret < 0 && ret != -ENOENT)
1377                 return ret;
1378         return nlink;
1379 }
1380
1381 static int count_inode_refs(struct btrfs_root *root,
1382                                struct inode *inode, struct btrfs_path *path)
1383 {
1384         int ret;
1385         struct btrfs_key key;
1386         unsigned int nlink = 0;
1387         unsigned long ptr;
1388         unsigned long ptr_end;
1389         int name_len;
1390         u64 ino = btrfs_ino(inode);
1391
1392         key.objectid = ino;
1393         key.type = BTRFS_INODE_REF_KEY;
1394         key.offset = (u64)-1;
1395
1396         while (1) {
1397                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1398                 if (ret < 0)
1399                         break;
1400                 if (ret > 0) {
1401                         if (path->slots[0] == 0)
1402                                 break;
1403                         path->slots[0]--;
1404                 }
1405 process_slot:
1406                 btrfs_item_key_to_cpu(path->nodes[0], &key,
1407                                       path->slots[0]);
1408                 if (key.objectid != ino ||
1409                     key.type != BTRFS_INODE_REF_KEY)
1410                         break;
1411                 ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
1412                 ptr_end = ptr + btrfs_item_size_nr(path->nodes[0],
1413                                                    path->slots[0]);
1414                 while (ptr < ptr_end) {
1415                         struct btrfs_inode_ref *ref;
1416
1417                         ref = (struct btrfs_inode_ref *)ptr;
1418                         name_len = btrfs_inode_ref_name_len(path->nodes[0],
1419                                                             ref);
1420                         ptr = (unsigned long)(ref + 1) + name_len;
1421                         nlink++;
1422                 }
1423
1424                 if (key.offset == 0)
1425                         break;
1426                 if (path->slots[0] > 0) {
1427                         path->slots[0]--;
1428                         goto process_slot;
1429                 }
1430                 key.offset--;
1431                 btrfs_release_path(path);
1432         }
1433         btrfs_release_path(path);
1434
1435         return nlink;
1436 }
1437
1438 /*
1439  * There are a few corners where the link count of the file can't
1440  * be properly maintained during replay.  So, instead of adding
1441  * lots of complexity to the log code, we just scan the backrefs
1442  * for any file that has been through replay.
1443  *
1444  * The scan will update the link count on the inode to reflect the
1445  * number of back refs found.  If it goes down to zero, the iput
1446  * will free the inode.
1447  */
1448 static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
1449                                            struct btrfs_root *root,
1450                                            struct inode *inode)
1451 {
1452         struct btrfs_path *path;
1453         int ret;
1454         u64 nlink = 0;
1455         u64 ino = btrfs_ino(inode);
1456
1457         path = btrfs_alloc_path();
1458         if (!path)
1459                 return -ENOMEM;
1460
1461         ret = count_inode_refs(root, inode, path);
1462         if (ret < 0)
1463                 goto out;
1464
1465         nlink = ret;
1466
1467         ret = count_inode_extrefs(root, inode, path);
1468         if (ret < 0)
1469                 goto out;
1470
1471         nlink += ret;
1472
1473         ret = 0;
1474
1475         if (nlink != inode->i_nlink) {
1476                 set_nlink(inode, nlink);
1477                 btrfs_update_inode(trans, root, inode);
1478         }
1479         BTRFS_I(inode)->index_cnt = (u64)-1;
1480
1481         if (inode->i_nlink == 0) {
1482                 if (S_ISDIR(inode->i_mode)) {
1483                         ret = replay_dir_deletes(trans, root, NULL, path,
1484                                                  ino, 1);
1485                         if (ret)
1486                                 goto out;
1487                 }
1488                 ret = insert_orphan_item(trans, root, ino);
1489         }
1490
1491 out:
1492         btrfs_free_path(path);
1493         return ret;
1494 }
1495
1496 static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
1497                                             struct btrfs_root *root,
1498                                             struct btrfs_path *path)
1499 {
1500         int ret;
1501         struct btrfs_key key;
1502         struct inode *inode;
1503
1504         key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1505         key.type = BTRFS_ORPHAN_ITEM_KEY;
1506         key.offset = (u64)-1;
1507         while (1) {
1508                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1509                 if (ret < 0)
1510                         break;
1511
1512                 if (ret == 1) {
1513                         if (path->slots[0] == 0)
1514                                 break;
1515                         path->slots[0]--;
1516                 }
1517
1518                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1519                 if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
1520                     key.type != BTRFS_ORPHAN_ITEM_KEY)
1521                         break;
1522
1523                 ret = btrfs_del_item(trans, root, path);
1524                 if (ret)
1525                         goto out;
1526
1527                 btrfs_release_path(path);
1528                 inode = read_one_inode(root, key.offset);
1529                 if (!inode)
1530                         return -EIO;
1531
1532                 ret = fixup_inode_link_count(trans, root, inode);
1533                 iput(inode);
1534                 if (ret)
1535                         goto out;
1536
1537                 /*
1538                  * fixup on a directory may create new entries,
1539                  * make sure we always look for the highset possible
1540                  * offset
1541                  */
1542                 key.offset = (u64)-1;
1543         }
1544         ret = 0;
1545 out:
1546         btrfs_release_path(path);
1547         return ret;
1548 }
1549
1550
1551 /*
1552  * record a given inode in the fixup dir so we can check its link
1553  * count when replay is done.  The link count is incremented here
1554  * so the inode won't go away until we check it
1555  */
1556 static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
1557                                       struct btrfs_root *root,
1558                                       struct btrfs_path *path,
1559                                       u64 objectid)
1560 {
1561         struct btrfs_key key;
1562         int ret = 0;
1563         struct inode *inode;
1564
1565         inode = read_one_inode(root, objectid);
1566         if (!inode)
1567                 return -EIO;
1568
1569         key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1570         key.type = BTRFS_ORPHAN_ITEM_KEY;
1571         key.offset = objectid;
1572
1573         ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1574
1575         btrfs_release_path(path);
1576         if (ret == 0) {
1577                 if (!inode->i_nlink)
1578                         set_nlink(inode, 1);
1579                 else
1580                         inc_nlink(inode);
1581                 ret = btrfs_update_inode(trans, root, inode);
1582         } else if (ret == -EEXIST) {
1583                 ret = 0;
1584         } else {
1585                 BUG(); /* Logic Error */
1586         }
1587         iput(inode);
1588
1589         return ret;
1590 }
1591
1592 /*
1593  * when replaying the log for a directory, we only insert names
1594  * for inodes that actually exist.  This means an fsync on a directory
1595  * does not implicitly fsync all the new files in it
1596  */
1597 static noinline int insert_one_name(struct btrfs_trans_handle *trans,
1598                                     struct btrfs_root *root,
1599                                     u64 dirid, u64 index,
1600                                     char *name, int name_len,
1601                                     struct btrfs_key *location)
1602 {
1603         struct inode *inode;
1604         struct inode *dir;
1605         int ret;
1606
1607         inode = read_one_inode(root, location->objectid);
1608         if (!inode)
1609                 return -ENOENT;
1610
1611         dir = read_one_inode(root, dirid);
1612         if (!dir) {
1613                 iput(inode);
1614                 return -EIO;
1615         }
1616
1617         ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index);
1618
1619         /* FIXME, put inode into FIXUP list */
1620
1621         iput(inode);
1622         iput(dir);
1623         return ret;
1624 }
1625
1626 /*
1627  * Return true if an inode reference exists in the log for the given name,
1628  * inode and parent inode.
1629  */
1630 static bool name_in_log_ref(struct btrfs_root *log_root,
1631                             const char *name, const int name_len,
1632                             const u64 dirid, const u64 ino)
1633 {
1634         struct btrfs_key search_key;
1635
1636         search_key.objectid = ino;
1637         search_key.type = BTRFS_INODE_REF_KEY;
1638         search_key.offset = dirid;
1639         if (backref_in_log(log_root, &search_key, dirid, name, name_len))
1640                 return true;
1641
1642         search_key.type = BTRFS_INODE_EXTREF_KEY;
1643         search_key.offset = btrfs_extref_hash(dirid, name, name_len);
1644         if (backref_in_log(log_root, &search_key, dirid, name, name_len))
1645                 return true;
1646
1647         return false;
1648 }
1649
1650 /*
1651  * take a single entry in a log directory item and replay it into
1652  * the subvolume.
1653  *
1654  * if a conflicting item exists in the subdirectory already,
1655  * the inode it points to is unlinked and put into the link count
1656  * fix up tree.
1657  *
1658  * If a name from the log points to a file or directory that does
1659  * not exist in the FS, it is skipped.  fsyncs on directories
1660  * do not force down inodes inside that directory, just changes to the
1661  * names or unlinks in a directory.
1662  *
1663  * Returns < 0 on error, 0 if the name wasn't replayed (dentry points to a
1664  * non-existing inode) and 1 if the name was replayed.
1665  */
1666 static noinline int replay_one_name(struct btrfs_trans_handle *trans,
1667                                     struct btrfs_root *root,
1668                                     struct btrfs_path *path,
1669                                     struct extent_buffer *eb,
1670                                     struct btrfs_dir_item *di,
1671                                     struct btrfs_key *key)
1672 {
1673         char *name;
1674         int name_len;
1675         struct btrfs_dir_item *dst_di;
1676         struct btrfs_key found_key;
1677         struct btrfs_key log_key;
1678         struct inode *dir;
1679         u8 log_type;
1680         int exists;
1681         int ret = 0;
1682         bool update_size = (key->type == BTRFS_DIR_INDEX_KEY);
1683         bool name_added = false;
1684
1685         dir = read_one_inode(root, key->objectid);
1686         if (!dir)
1687                 return -EIO;
1688
1689         name_len = btrfs_dir_name_len(eb, di);
1690         name = kmalloc(name_len, GFP_NOFS);
1691         if (!name) {
1692                 ret = -ENOMEM;
1693                 goto out;
1694         }
1695
1696         log_type = btrfs_dir_type(eb, di);
1697         read_extent_buffer(eb, name, (unsigned long)(di + 1),
1698                    name_len);
1699
1700         btrfs_dir_item_key_to_cpu(eb, di, &log_key);
1701         exists = btrfs_lookup_inode(trans, root, path, &log_key, 0);
1702         if (exists == 0)
1703                 exists = 1;
1704         else
1705                 exists = 0;
1706         btrfs_release_path(path);
1707
1708         if (key->type == BTRFS_DIR_ITEM_KEY) {
1709                 dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
1710                                        name, name_len, 1);
1711         } else if (key->type == BTRFS_DIR_INDEX_KEY) {
1712                 dst_di = btrfs_lookup_dir_index_item(trans, root, path,
1713                                                      key->objectid,
1714                                                      key->offset, name,
1715                                                      name_len, 1);
1716         } else {
1717                 /* Corruption */
1718                 ret = -EINVAL;
1719                 goto out;
1720         }
1721         if (IS_ERR_OR_NULL(dst_di)) {
1722                 /* we need a sequence number to insert, so we only
1723                  * do inserts for the BTRFS_DIR_INDEX_KEY types
1724                  */
1725                 if (key->type != BTRFS_DIR_INDEX_KEY)
1726                         goto out;
1727                 goto insert;
1728         }
1729
1730         btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key);
1731         /* the existing item matches the logged item */
1732         if (found_key.objectid == log_key.objectid &&
1733             found_key.type == log_key.type &&
1734             found_key.offset == log_key.offset &&
1735             btrfs_dir_type(path->nodes[0], dst_di) == log_type) {
1736                 update_size = false;
1737                 goto out;
1738         }
1739
1740         /*
1741          * don't drop the conflicting directory entry if the inode
1742          * for the new entry doesn't exist
1743          */
1744         if (!exists)
1745                 goto out;
1746
1747         ret = drop_one_dir_item(trans, root, path, dir, dst_di);
1748         if (ret)
1749                 goto out;
1750
1751         if (key->type == BTRFS_DIR_INDEX_KEY)
1752                 goto insert;
1753 out:
1754         btrfs_release_path(path);
1755         if (!ret && update_size) {
1756                 btrfs_i_size_write(dir, dir->i_size + name_len * 2);
1757                 ret = btrfs_update_inode(trans, root, dir);
1758         }
1759         kfree(name);
1760         iput(dir);
1761         if (!ret && name_added)
1762                 ret = 1;
1763         return ret;
1764
1765 insert:
1766         if (name_in_log_ref(root->log_root, name, name_len,
1767                             key->objectid, log_key.objectid)) {
1768                 /* The dentry will be added later. */
1769                 ret = 0;
1770                 update_size = false;
1771                 goto out;
1772         }
1773         btrfs_release_path(path);
1774         ret = insert_one_name(trans, root, key->objectid, key->offset,
1775                               name, name_len, &log_key);
1776         if (ret && ret != -ENOENT && ret != -EEXIST)
1777                 goto out;
1778         if (!ret)
1779                 name_added = true;
1780         update_size = false;
1781         ret = 0;
1782         goto out;
1783 }
1784
1785 /*
1786  * find all the names in a directory item and reconcile them into
1787  * the subvolume.  Only BTRFS_DIR_ITEM_KEY types will have more than
1788  * one name in a directory item, but the same code gets used for
1789  * both directory index types
1790  */
1791 static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
1792                                         struct btrfs_root *root,
1793                                         struct btrfs_path *path,
1794                                         struct extent_buffer *eb, int slot,
1795                                         struct btrfs_key *key)
1796 {
1797         int ret = 0;
1798         u32 item_size = btrfs_item_size_nr(eb, slot);
1799         struct btrfs_dir_item *di;
1800         int name_len;
1801         unsigned long ptr;
1802         unsigned long ptr_end;
1803         struct btrfs_path *fixup_path = NULL;
1804
1805         ptr = btrfs_item_ptr_offset(eb, slot);
1806         ptr_end = ptr + item_size;
1807         while (ptr < ptr_end) {
1808                 di = (struct btrfs_dir_item *)ptr;
1809                 if (verify_dir_item(root, eb, di))
1810                         return -EIO;
1811                 name_len = btrfs_dir_name_len(eb, di);
1812                 ret = replay_one_name(trans, root, path, eb, di, key);
1813                 if (ret < 0)
1814                         break;
1815                 ptr = (unsigned long)(di + 1);
1816                 ptr += name_len;
1817
1818                 /*
1819                  * If this entry refers to a non-directory (directories can not
1820                  * have a link count > 1) and it was added in the transaction
1821                  * that was not committed, make sure we fixup the link count of
1822                  * the inode it the entry points to. Otherwise something like
1823                  * the following would result in a directory pointing to an
1824                  * inode with a wrong link that does not account for this dir
1825                  * entry:
1826                  *
1827                  * mkdir testdir
1828                  * touch testdir/foo
1829                  * touch testdir/bar
1830                  * sync
1831                  *
1832                  * ln testdir/bar testdir/bar_link
1833                  * ln testdir/foo testdir/foo_link
1834                  * xfs_io -c "fsync" testdir/bar
1835                  *
1836                  * <power failure>
1837                  *
1838                  * mount fs, log replay happens
1839                  *
1840                  * File foo would remain with a link count of 1 when it has two
1841                  * entries pointing to it in the directory testdir. This would
1842                  * make it impossible to ever delete the parent directory has
1843                  * it would result in stale dentries that can never be deleted.
1844                  */
1845                 if (ret == 1 && btrfs_dir_type(eb, di) != BTRFS_FT_DIR) {
1846                         struct btrfs_key di_key;
1847
1848                         if (!fixup_path) {
1849                                 fixup_path = btrfs_alloc_path();
1850                                 if (!fixup_path) {
1851                                         ret = -ENOMEM;
1852                                         break;
1853                                 }
1854                         }
1855
1856                         btrfs_dir_item_key_to_cpu(eb, di, &di_key);
1857                         ret = link_to_fixup_dir(trans, root, fixup_path,
1858                                                 di_key.objectid);
1859                         if (ret)
1860                                 break;
1861                 }
1862                 ret = 0;
1863         }
1864         btrfs_free_path(fixup_path);
1865         return ret;
1866 }
1867
1868 /*
1869  * directory replay has two parts.  There are the standard directory
1870  * items in the log copied from the subvolume, and range items
1871  * created in the log while the subvolume was logged.
1872  *
1873  * The range items tell us which parts of the key space the log
1874  * is authoritative for.  During replay, if a key in the subvolume
1875  * directory is in a logged range item, but not actually in the log
1876  * that means it was deleted from the directory before the fsync
1877  * and should be removed.
1878  */
1879 static noinline int find_dir_range(struct btrfs_root *root,
1880                                    struct btrfs_path *path,
1881                                    u64 dirid, int key_type,
1882                                    u64 *start_ret, u64 *end_ret)
1883 {
1884         struct btrfs_key key;
1885         u64 found_end;
1886         struct btrfs_dir_log_item *item;
1887         int ret;
1888         int nritems;
1889
1890         if (*start_ret == (u64)-1)
1891                 return 1;
1892
1893         key.objectid = dirid;
1894         key.type = key_type;
1895         key.offset = *start_ret;
1896
1897         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1898         if (ret < 0)
1899                 goto out;
1900         if (ret > 0) {
1901                 if (path->slots[0] == 0)
1902                         goto out;
1903                 path->slots[0]--;
1904         }
1905         if (ret != 0)
1906                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1907
1908         if (key.type != key_type || key.objectid != dirid) {
1909                 ret = 1;
1910                 goto next;
1911         }
1912         item = btrfs_item_ptr(path->nodes[0], path->slots[0],
1913                               struct btrfs_dir_log_item);
1914         found_end = btrfs_dir_log_end(path->nodes[0], item);
1915
1916         if (*start_ret >= key.offset && *start_ret <= found_end) {
1917                 ret = 0;
1918                 *start_ret = key.offset;
1919                 *end_ret = found_end;
1920                 goto out;
1921         }
1922         ret = 1;
1923 next:
1924         /* check the next slot in the tree to see if it is a valid item */
1925         nritems = btrfs_header_nritems(path->nodes[0]);
1926         path->slots[0]++;
1927         if (path->slots[0] >= nritems) {
1928                 ret = btrfs_next_leaf(root, path);
1929                 if (ret)
1930                         goto out;
1931         }
1932
1933         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1934
1935         if (key.type != key_type || key.objectid != dirid) {
1936                 ret = 1;
1937                 goto out;
1938         }
1939         item = btrfs_item_ptr(path->nodes[0], path->slots[0],
1940                               struct btrfs_dir_log_item);
1941         found_end = btrfs_dir_log_end(path->nodes[0], item);
1942         *start_ret = key.offset;
1943         *end_ret = found_end;
1944         ret = 0;
1945 out:
1946         btrfs_release_path(path);
1947         return ret;
1948 }
1949
1950 /*
1951  * this looks for a given directory item in the log.  If the directory
1952  * item is not in the log, the item is removed and the inode it points
1953  * to is unlinked
1954  */
1955 static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
1956                                       struct btrfs_root *root,
1957                                       struct btrfs_root *log,
1958                                       struct btrfs_path *path,
1959                                       struct btrfs_path *log_path,
1960                                       struct inode *dir,
1961                                       struct btrfs_key *dir_key)
1962 {
1963         int ret;
1964         struct extent_buffer *eb;
1965         int slot;
1966         u32 item_size;
1967         struct btrfs_dir_item *di;
1968         struct btrfs_dir_item *log_di;
1969         int name_len;
1970         unsigned long ptr;
1971         unsigned long ptr_end;
1972         char *name;
1973         struct inode *inode;
1974         struct btrfs_key location;
1975
1976 again:
1977         eb = path->nodes[0];
1978         slot = path->slots[0];
1979         item_size = btrfs_item_size_nr(eb, slot);
1980         ptr = btrfs_item_ptr_offset(eb, slot);
1981         ptr_end = ptr + item_size;
1982         while (ptr < ptr_end) {
1983                 di = (struct btrfs_dir_item *)ptr;
1984                 if (verify_dir_item(root, eb, di)) {
1985                         ret = -EIO;
1986                         goto out;
1987                 }
1988
1989                 name_len = btrfs_dir_name_len(eb, di);
1990                 name = kmalloc(name_len, GFP_NOFS);
1991                 if (!name) {
1992                         ret = -ENOMEM;
1993                         goto out;
1994                 }
1995                 read_extent_buffer(eb, name, (unsigned long)(di + 1),
1996                                   name_len);
1997                 log_di = NULL;
1998                 if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) {
1999                         log_di = btrfs_lookup_dir_item(trans, log, log_path,
2000                                                        dir_key->objectid,
2001                                                        name, name_len, 0);
2002                 } else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) {
2003                         log_di = btrfs_lookup_dir_index_item(trans, log,
2004                                                      log_path,
2005                                                      dir_key->objectid,
2006                                                      dir_key->offset,
2007                                                      name, name_len, 0);
2008                 }
2009                 if (!log_di || (IS_ERR(log_di) && PTR_ERR(log_di) == -ENOENT)) {
2010                         btrfs_dir_item_key_to_cpu(eb, di, &location);
2011                         btrfs_release_path(path);
2012                         btrfs_release_path(log_path);
2013                         inode = read_one_inode(root, location.objectid);
2014                         if (!inode) {
2015                                 kfree(name);
2016                                 return -EIO;
2017                         }
2018
2019                         ret = link_to_fixup_dir(trans, root,
2020                                                 path, location.objectid);
2021                         if (ret) {
2022                                 kfree(name);
2023                                 iput(inode);
2024                                 goto out;
2025                         }
2026
2027                         inc_nlink(inode);
2028                         ret = btrfs_unlink_inode(trans, root, dir, inode,
2029                                                  name, name_len);
2030                         if (!ret)
2031                                 ret = btrfs_run_delayed_items(trans, root);
2032                         kfree(name);
2033                         iput(inode);
2034                         if (ret)
2035                                 goto out;
2036
2037                         /* there might still be more names under this key
2038                          * check and repeat if required
2039                          */
2040                         ret = btrfs_search_slot(NULL, root, dir_key, path,
2041                                                 0, 0);
2042                         if (ret == 0)
2043                                 goto again;
2044                         ret = 0;
2045                         goto out;
2046                 } else if (IS_ERR(log_di)) {
2047                         kfree(name);
2048                         return PTR_ERR(log_di);
2049                 }
2050                 btrfs_release_path(log_path);
2051                 kfree(name);
2052
2053                 ptr = (unsigned long)(di + 1);
2054                 ptr += name_len;
2055         }
2056         ret = 0;
2057 out:
2058         btrfs_release_path(path);
2059         btrfs_release_path(log_path);
2060         return ret;
2061 }
2062
2063 static int replay_xattr_deletes(struct btrfs_trans_handle *trans,
2064                               struct btrfs_root *root,
2065                               struct btrfs_root *log,
2066                               struct btrfs_path *path,
2067                               const u64 ino)
2068 {
2069         struct btrfs_key search_key;
2070         struct btrfs_path *log_path;
2071         int i;
2072         int nritems;
2073         int ret;
2074
2075         log_path = btrfs_alloc_path();
2076         if (!log_path)
2077                 return -ENOMEM;
2078
2079         search_key.objectid = ino;
2080         search_key.type = BTRFS_XATTR_ITEM_KEY;
2081         search_key.offset = 0;
2082 again:
2083         ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
2084         if (ret < 0)
2085                 goto out;
2086 process_leaf:
2087         nritems = btrfs_header_nritems(path->nodes[0]);
2088         for (i = path->slots[0]; i < nritems; i++) {
2089                 struct btrfs_key key;
2090                 struct btrfs_dir_item *di;
2091                 struct btrfs_dir_item *log_di;
2092                 u32 total_size;
2093                 u32 cur;
2094
2095                 btrfs_item_key_to_cpu(path->nodes[0], &key, i);
2096                 if (key.objectid != ino || key.type != BTRFS_XATTR_ITEM_KEY) {
2097                         ret = 0;
2098                         goto out;
2099                 }
2100
2101                 di = btrfs_item_ptr(path->nodes[0], i, struct btrfs_dir_item);
2102                 total_size = btrfs_item_size_nr(path->nodes[0], i);
2103                 cur = 0;
2104                 while (cur < total_size) {
2105                         u16 name_len = btrfs_dir_name_len(path->nodes[0], di);
2106                         u16 data_len = btrfs_dir_data_len(path->nodes[0], di);
2107                         u32 this_len = sizeof(*di) + name_len + data_len;
2108                         char *name;
2109
2110                         name = kmalloc(name_len, GFP_NOFS);
2111                         if (!name) {
2112                                 ret = -ENOMEM;
2113                                 goto out;
2114                         }
2115                         read_extent_buffer(path->nodes[0], name,
2116                                            (unsigned long)(di + 1), name_len);
2117
2118                         log_di = btrfs_lookup_xattr(NULL, log, log_path, ino,
2119                                                     name, name_len, 0);
2120                         btrfs_release_path(log_path);
2121                         if (!log_di) {
2122                                 /* Doesn't exist in log tree, so delete it. */
2123                                 btrfs_release_path(path);
2124                                 di = btrfs_lookup_xattr(trans, root, path, ino,
2125                                                         name, name_len, -1);
2126                                 kfree(name);
2127                                 if (IS_ERR(di)) {
2128                                         ret = PTR_ERR(di);
2129                                         goto out;
2130                                 }
2131                                 ASSERT(di);
2132                                 ret = btrfs_delete_one_dir_name(trans, root,
2133                                                                 path, di);
2134                                 if (ret)
2135                                         goto out;
2136                                 btrfs_release_path(path);
2137                                 search_key = key;
2138                                 goto again;
2139                         }
2140                         kfree(name);
2141                         if (IS_ERR(log_di)) {
2142                                 ret = PTR_ERR(log_di);
2143                                 goto out;
2144                         }
2145                         cur += this_len;
2146                         di = (struct btrfs_dir_item *)((char *)di + this_len);
2147                 }
2148         }
2149         ret = btrfs_next_leaf(root, path);
2150         if (ret > 0)
2151                 ret = 0;
2152         else if (ret == 0)
2153                 goto process_leaf;
2154 out:
2155         btrfs_free_path(log_path);
2156         btrfs_release_path(path);
2157         return ret;
2158 }
2159
2160
2161 /*
2162  * deletion replay happens before we copy any new directory items
2163  * out of the log or out of backreferences from inodes.  It
2164  * scans the log to find ranges of keys that log is authoritative for,
2165  * and then scans the directory to find items in those ranges that are
2166  * not present in the log.
2167  *
2168  * Anything we don't find in the log is unlinked and removed from the
2169  * directory.
2170  */
2171 static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
2172                                        struct btrfs_root *root,
2173                                        struct btrfs_root *log,
2174                                        struct btrfs_path *path,
2175                                        u64 dirid, int del_all)
2176 {
2177         u64 range_start;
2178         u64 range_end;
2179         int key_type = BTRFS_DIR_LOG_ITEM_KEY;
2180         int ret = 0;
2181         struct btrfs_key dir_key;
2182         struct btrfs_key found_key;
2183         struct btrfs_path *log_path;
2184         struct inode *dir;
2185
2186         dir_key.objectid = dirid;
2187         dir_key.type = BTRFS_DIR_ITEM_KEY;
2188         log_path = btrfs_alloc_path();
2189         if (!log_path)
2190                 return -ENOMEM;
2191
2192         dir = read_one_inode(root, dirid);
2193         /* it isn't an error if the inode isn't there, that can happen
2194          * because we replay the deletes before we copy in the inode item
2195          * from the log
2196          */
2197         if (!dir) {
2198                 btrfs_free_path(log_path);
2199                 return 0;
2200         }
2201 again:
2202         range_start = 0;
2203         range_end = 0;
2204         while (1) {
2205                 if (del_all)
2206                         range_end = (u64)-1;
2207                 else {
2208                         ret = find_dir_range(log, path, dirid, key_type,
2209                                              &range_start, &range_end);
2210                         if (ret != 0)
2211                                 break;
2212                 }
2213
2214                 dir_key.offset = range_start;
2215                 while (1) {
2216                         int nritems;
2217                         ret = btrfs_search_slot(NULL, root, &dir_key, path,
2218                                                 0, 0);
2219                         if (ret < 0)
2220                                 goto out;
2221
2222                         nritems = btrfs_header_nritems(path->nodes[0]);
2223                         if (path->slots[0] >= nritems) {
2224                                 ret = btrfs_next_leaf(root, path);
2225                                 if (ret)
2226                                         break;
2227                         }
2228                         btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2229                                               path->slots[0]);
2230                         if (found_key.objectid != dirid ||
2231                             found_key.type != dir_key.type)
2232                                 goto next_type;
2233
2234                         if (found_key.offset > range_end)
2235                                 break;
2236
2237                         ret = check_item_in_log(trans, root, log, path,
2238                                                 log_path, dir,
2239                                                 &found_key);
2240                         if (ret)
2241                                 goto out;
2242                         if (found_key.offset == (u64)-1)
2243                                 break;
2244                         dir_key.offset = found_key.offset + 1;
2245                 }
2246                 btrfs_release_path(path);
2247                 if (range_end == (u64)-1)
2248                         break;
2249                 range_start = range_end + 1;
2250         }
2251
2252 next_type:
2253         ret = 0;
2254         if (key_type == BTRFS_DIR_LOG_ITEM_KEY) {
2255                 key_type = BTRFS_DIR_LOG_INDEX_KEY;
2256                 dir_key.type = BTRFS_DIR_INDEX_KEY;
2257                 btrfs_release_path(path);
2258                 goto again;
2259         }
2260 out:
2261         btrfs_release_path(path);
2262         btrfs_free_path(log_path);
2263         iput(dir);
2264         return ret;
2265 }
2266
2267 /*
2268  * the process_func used to replay items from the log tree.  This
2269  * gets called in two different stages.  The first stage just looks
2270  * for inodes and makes sure they are all copied into the subvolume.
2271  *
2272  * The second stage copies all the other item types from the log into
2273  * the subvolume.  The two stage approach is slower, but gets rid of
2274  * lots of complexity around inodes referencing other inodes that exist
2275  * only in the log (references come from either directory items or inode
2276  * back refs).
2277  */
2278 static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
2279                              struct walk_control *wc, u64 gen)
2280 {
2281         int nritems;
2282         struct btrfs_path *path;
2283         struct btrfs_root *root = wc->replay_dest;
2284         struct btrfs_key key;
2285         int level;
2286         int i;
2287         int ret;
2288
2289         ret = btrfs_read_buffer(eb, gen);
2290         if (ret)
2291                 return ret;
2292
2293         level = btrfs_header_level(eb);
2294
2295         if (level != 0)
2296                 return 0;
2297
2298         path = btrfs_alloc_path();
2299         if (!path)
2300                 return -ENOMEM;
2301
2302         nritems = btrfs_header_nritems(eb);
2303         for (i = 0; i < nritems; i++) {
2304                 btrfs_item_key_to_cpu(eb, &key, i);
2305
2306                 /* inode keys are done during the first stage */
2307                 if (key.type == BTRFS_INODE_ITEM_KEY &&
2308                     wc->stage == LOG_WALK_REPLAY_INODES) {
2309                         struct btrfs_inode_item *inode_item;
2310                         u32 mode;
2311
2312                         inode_item = btrfs_item_ptr(eb, i,
2313                                             struct btrfs_inode_item);
2314                         ret = replay_xattr_deletes(wc->trans, root, log,
2315                                                    path, key.objectid);
2316                         if (ret)
2317                                 break;
2318                         mode = btrfs_inode_mode(eb, inode_item);
2319                         if (S_ISDIR(mode)) {
2320                                 ret = replay_dir_deletes(wc->trans,
2321                                          root, log, path, key.objectid, 0);
2322                                 if (ret)
2323                                         break;
2324                         }
2325                         ret = overwrite_item(wc->trans, root, path,
2326                                              eb, i, &key);
2327                         if (ret)
2328                                 break;
2329
2330                         /* for regular files, make sure corresponding
2331                          * orhpan item exist. extents past the new EOF
2332                          * will be truncated later by orphan cleanup.
2333                          */
2334                         if (S_ISREG(mode)) {
2335                                 ret = insert_orphan_item(wc->trans, root,
2336                                                          key.objectid);
2337                                 if (ret)
2338                                         break;
2339                         }
2340
2341                         ret = link_to_fixup_dir(wc->trans, root,
2342                                                 path, key.objectid);
2343                         if (ret)
2344                                 break;
2345                 }
2346
2347                 if (key.type == BTRFS_DIR_INDEX_KEY &&
2348                     wc->stage == LOG_WALK_REPLAY_DIR_INDEX) {
2349                         ret = replay_one_dir_item(wc->trans, root, path,
2350                                                   eb, i, &key);
2351                         if (ret)
2352                                 break;
2353                 }
2354
2355                 if (wc->stage < LOG_WALK_REPLAY_ALL)
2356                         continue;
2357
2358                 /* these keys are simply copied */
2359                 if (key.type == BTRFS_XATTR_ITEM_KEY) {
2360                         ret = overwrite_item(wc->trans, root, path,
2361                                              eb, i, &key);
2362                         if (ret)
2363                                 break;
2364                 } else if (key.type == BTRFS_INODE_REF_KEY ||
2365                            key.type == BTRFS_INODE_EXTREF_KEY) {
2366                         ret = add_inode_ref(wc->trans, root, log, path,
2367                                             eb, i, &key);
2368                         if (ret && ret != -ENOENT)
2369                                 break;
2370                         ret = 0;
2371                 } else if (key.type == BTRFS_EXTENT_DATA_KEY) {
2372                         ret = replay_one_extent(wc->trans, root, path,
2373                                                 eb, i, &key);
2374                         if (ret)
2375                                 break;
2376                 } else if (key.type == BTRFS_DIR_ITEM_KEY) {
2377                         ret = replay_one_dir_item(wc->trans, root, path,
2378                                                   eb, i, &key);
2379                         if (ret)
2380                                 break;
2381                 }
2382         }
2383         btrfs_free_path(path);
2384         return ret;
2385 }
2386
2387 static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
2388                                    struct btrfs_root *root,
2389                                    struct btrfs_path *path, int *level,
2390                                    struct walk_control *wc)
2391 {
2392         u64 root_owner;
2393         u64 bytenr;
2394         u64 ptr_gen;
2395         struct extent_buffer *next;
2396         struct extent_buffer *cur;
2397         struct extent_buffer *parent;
2398         u32 blocksize;
2399         int ret = 0;
2400
2401         WARN_ON(*level < 0);
2402         WARN_ON(*level >= BTRFS_MAX_LEVEL);
2403
2404         while (*level > 0) {
2405                 WARN_ON(*level < 0);
2406                 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2407                 cur = path->nodes[*level];
2408
2409                 WARN_ON(btrfs_header_level(cur) != *level);
2410
2411                 if (path->slots[*level] >=
2412                     btrfs_header_nritems(cur))
2413                         break;
2414
2415                 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2416                 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2417                 blocksize = root->nodesize;
2418
2419                 parent = path->nodes[*level];
2420                 root_owner = btrfs_header_owner(parent);
2421
2422                 next = btrfs_find_create_tree_block(root, bytenr);
2423                 if (!next)
2424                         return -ENOMEM;
2425
2426                 if (*level == 1) {
2427                         ret = wc->process_func(root, next, wc, ptr_gen);
2428                         if (ret) {
2429                                 free_extent_buffer(next);
2430                                 return ret;
2431                         }
2432
2433                         path->slots[*level]++;
2434                         if (wc->free) {
2435                                 ret = btrfs_read_buffer(next, ptr_gen);
2436                                 if (ret) {
2437                                         free_extent_buffer(next);
2438                                         return ret;
2439                                 }
2440
2441                                 if (trans) {
2442                                         btrfs_tree_lock(next);
2443                                         btrfs_set_lock_blocking(next);
2444                                         clean_tree_block(trans, root->fs_info,
2445                                                         next);
2446                                         btrfs_wait_tree_block_writeback(next);
2447                                         btrfs_tree_unlock(next);
2448                                 }
2449
2450                                 WARN_ON(root_owner !=
2451                                         BTRFS_TREE_LOG_OBJECTID);
2452                                 ret = btrfs_free_and_pin_reserved_extent(root,
2453                                                          bytenr, blocksize);
2454                                 if (ret) {
2455                                         free_extent_buffer(next);
2456                                         return ret;
2457                                 }
2458                         }
2459                         free_extent_buffer(next);
2460                         continue;
2461                 }
2462                 ret = btrfs_read_buffer(next, ptr_gen);
2463                 if (ret) {
2464                         free_extent_buffer(next);
2465                         return ret;
2466                 }
2467
2468                 WARN_ON(*level <= 0);
2469                 if (path->nodes[*level-1])
2470                         free_extent_buffer(path->nodes[*level-1]);
2471                 path->nodes[*level-1] = next;
2472                 *level = btrfs_header_level(next);
2473                 path->slots[*level] = 0;
2474                 cond_resched();
2475         }
2476         WARN_ON(*level < 0);
2477         WARN_ON(*level >= BTRFS_MAX_LEVEL);
2478
2479         path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2480
2481         cond_resched();
2482         return 0;
2483 }
2484
2485 static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
2486                                  struct btrfs_root *root,
2487                                  struct btrfs_path *path, int *level,
2488                                  struct walk_control *wc)
2489 {
2490         u64 root_owner;
2491         int i;
2492         int slot;
2493         int ret;
2494
2495         for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2496                 slot = path->slots[i];
2497                 if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
2498                         path->slots[i]++;
2499                         *level = i;
2500                         WARN_ON(*level == 0);
2501                         return 0;
2502                 } else {
2503                         struct extent_buffer *parent;
2504                         if (path->nodes[*level] == root->node)
2505                                 parent = path->nodes[*level];
2506                         else
2507                                 parent = path->nodes[*level + 1];
2508
2509                         root_owner = btrfs_header_owner(parent);
2510                         ret = wc->process_func(root, path->nodes[*level], wc,
2511                                  btrfs_header_generation(path->nodes[*level]));
2512                         if (ret)
2513                                 return ret;
2514
2515                         if (wc->free) {
2516                                 struct extent_buffer *next;
2517
2518                                 next = path->nodes[*level];
2519
2520                                 if (trans) {
2521                                         btrfs_tree_lock(next);
2522                                         btrfs_set_lock_blocking(next);
2523                                         clean_tree_block(trans, root->fs_info,
2524                                                         next);
2525                                         btrfs_wait_tree_block_writeback(next);
2526                                         btrfs_tree_unlock(next);
2527                                 }
2528
2529                                 WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID);
2530                                 ret = btrfs_free_and_pin_reserved_extent(root,
2531                                                 path->nodes[*level]->start,
2532                                                 path->nodes[*level]->len);
2533                                 if (ret)
2534                                         return ret;
2535                         }
2536                         free_extent_buffer(path->nodes[*level]);
2537                         path->nodes[*level] = NULL;
2538                         *level = i + 1;
2539                 }
2540         }
2541         return 1;
2542 }
2543
2544 /*
2545  * drop the reference count on the tree rooted at 'snap'.  This traverses
2546  * the tree freeing any blocks that have a ref count of zero after being
2547  * decremented.
2548  */
2549 static int walk_log_tree(struct btrfs_trans_handle *trans,
2550                          struct btrfs_root *log, struct walk_control *wc)
2551 {
2552         int ret = 0;
2553         int wret;
2554         int level;
2555         struct btrfs_path *path;
2556         int orig_level;
2557
2558         path = btrfs_alloc_path();
2559         if (!path)
2560                 return -ENOMEM;
2561
2562         level = btrfs_header_level(log->node);
2563         orig_level = level;
2564         path->nodes[level] = log->node;
2565         extent_buffer_get(log->node);
2566         path->slots[level] = 0;
2567
2568         while (1) {
2569                 wret = walk_down_log_tree(trans, log, path, &level, wc);
2570                 if (wret > 0)
2571                         break;
2572                 if (wret < 0) {
2573                         ret = wret;
2574                         goto out;
2575                 }
2576
2577                 wret = walk_up_log_tree(trans, log, path, &level, wc);
2578                 if (wret > 0)
2579                         break;
2580                 if (wret < 0) {
2581                         ret = wret;
2582                         goto out;
2583                 }
2584         }
2585
2586         /* was the root node processed? if not, catch it here */
2587         if (path->nodes[orig_level]) {
2588                 ret = wc->process_func(log, path->nodes[orig_level], wc,
2589                          btrfs_header_generation(path->nodes[orig_level]));
2590                 if (ret)
2591                         goto out;
2592                 if (wc->free) {
2593                         struct extent_buffer *next;
2594
2595                         next = path->nodes[orig_level];
2596
2597                         if (trans) {
2598                                 btrfs_tree_lock(next);
2599                                 btrfs_set_lock_blocking(next);
2600                                 clean_tree_block(trans, log->fs_info, next);
2601                                 btrfs_wait_tree_block_writeback(next);
2602                                 btrfs_tree_unlock(next);
2603                         }
2604
2605                         WARN_ON(log->root_key.objectid !=
2606                                 BTRFS_TREE_LOG_OBJECTID);
2607                         ret = btrfs_free_and_pin_reserved_extent(log, next->start,
2608                                                          next->len);
2609                         if (ret)
2610                                 goto out;
2611                 }
2612         }
2613
2614 out:
2615         btrfs_free_path(path);
2616         return ret;
2617 }
2618
2619 /*
2620  * helper function to update the item for a given subvolumes log root
2621  * in the tree of log roots
2622  */
2623 static int update_log_root(struct btrfs_trans_handle *trans,
2624                            struct btrfs_root *log)
2625 {
2626         int ret;
2627
2628         if (log->log_transid == 1) {
2629                 /* insert root item on the first sync */
2630                 ret = btrfs_insert_root(trans, log->fs_info->log_root_tree,
2631                                 &log->root_key, &log->root_item);
2632         } else {
2633                 ret = btrfs_update_root(trans, log->fs_info->log_root_tree,
2634                                 &log->root_key, &log->root_item);
2635         }
2636         return ret;
2637 }
2638
2639 static void wait_log_commit(struct btrfs_root *root, int transid)
2640 {
2641         DEFINE_WAIT(wait);
2642         int index = transid % 2;
2643
2644         /*
2645          * we only allow two pending log transactions at a time,
2646          * so we know that if ours is more than 2 older than the
2647          * current transaction, we're done
2648          */
2649         do {
2650                 prepare_to_wait(&root->log_commit_wait[index],
2651                                 &wait, TASK_UNINTERRUPTIBLE);
2652                 mutex_unlock(&root->log_mutex);
2653
2654                 if (root->log_transid_committed < transid &&
2655                     atomic_read(&root->log_commit[index]))
2656                         schedule();
2657
2658                 finish_wait(&root->log_commit_wait[index], &wait);
2659                 mutex_lock(&root->log_mutex);
2660         } while (root->log_transid_committed < transid &&
2661                  atomic_read(&root->log_commit[index]));
2662 }
2663
2664 static void wait_for_writer(struct btrfs_root *root)
2665 {
2666         DEFINE_WAIT(wait);
2667
2668         while (atomic_read(&root->log_writers)) {
2669                 prepare_to_wait(&root->log_writer_wait,
2670                                 &wait, TASK_UNINTERRUPTIBLE);
2671                 mutex_unlock(&root->log_mutex);
2672                 if (atomic_read(&root->log_writers))
2673                         schedule();
2674                 finish_wait(&root->log_writer_wait, &wait);
2675                 mutex_lock(&root->log_mutex);
2676         }
2677 }
2678
2679 static inline void btrfs_remove_log_ctx(struct btrfs_root *root,
2680                                         struct btrfs_log_ctx *ctx)
2681 {
2682         if (!ctx)
2683                 return;
2684
2685         mutex_lock(&root->log_mutex);
2686         list_del_init(&ctx->list);
2687         mutex_unlock(&root->log_mutex);
2688 }
2689
2690 /*
2691  * Invoked in log mutex context, or be sure there is no other task which
2692  * can access the list.
2693  */
2694 static inline void btrfs_remove_all_log_ctxs(struct btrfs_root *root,
2695                                              int index, int error)
2696 {
2697         struct btrfs_log_ctx *ctx;
2698         struct btrfs_log_ctx *safe;
2699
2700         list_for_each_entry_safe(ctx, safe, &root->log_ctxs[index], list) {
2701                 list_del_init(&ctx->list);
2702                 ctx->log_ret = error;
2703         }
2704
2705         INIT_LIST_HEAD(&root->log_ctxs[index]);
2706 }
2707
2708 /*
2709  * btrfs_sync_log does sends a given tree log down to the disk and
2710  * updates the super blocks to record it.  When this call is done,
2711  * you know that any inodes previously logged are safely on disk only
2712  * if it returns 0.
2713  *
2714  * Any other return value means you need to call btrfs_commit_transaction.
2715  * Some of the edge cases for fsyncing directories that have had unlinks
2716  * or renames done in the past mean that sometimes the only safe
2717  * fsync is to commit the whole FS.  When btrfs_sync_log returns -EAGAIN,
2718  * that has happened.
2719  */
2720 int btrfs_sync_log(struct btrfs_trans_handle *trans,
2721                    struct btrfs_root *root, struct btrfs_log_ctx *ctx)
2722 {
2723         int index1;
2724         int index2;
2725         int mark;
2726         int ret;
2727         struct btrfs_root *log = root->log_root;
2728         struct btrfs_root *log_root_tree = root->fs_info->log_root_tree;
2729         int log_transid = 0;
2730         struct btrfs_log_ctx root_log_ctx;
2731         struct blk_plug plug;
2732
2733         mutex_lock(&root->log_mutex);
2734         log_transid = ctx->log_transid;
2735         if (root->log_transid_committed >= log_transid) {
2736                 mutex_unlock(&root->log_mutex);
2737                 return ctx->log_ret;
2738         }
2739
2740         index1 = log_transid % 2;
2741         if (atomic_read(&root->log_commit[index1])) {
2742                 wait_log_commit(root, log_transid);
2743                 mutex_unlock(&root->log_mutex);
2744                 return ctx->log_ret;
2745         }
2746         ASSERT(log_transid == root->log_transid);
2747         atomic_set(&root->log_commit[index1], 1);
2748
2749         /* wait for previous tree log sync to complete */
2750         if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
2751                 wait_log_commit(root, log_transid - 1);
2752
2753         while (1) {
2754                 int batch = atomic_read(&root->log_batch);
2755                 /* when we're on an ssd, just kick the log commit out */
2756                 if (!btrfs_test_opt(root, SSD) &&
2757                     test_bit(BTRFS_ROOT_MULTI_LOG_TASKS, &root->state)) {
2758                         mutex_unlock(&root->log_mutex);
2759                         schedule_timeout_uninterruptible(1);
2760                         mutex_lock(&root->log_mutex);
2761                 }
2762                 wait_for_writer(root);
2763                 if (batch == atomic_read(&root->log_batch))
2764                         break;
2765         }
2766
2767         /* bail out if we need to do a full commit */
2768         if (btrfs_need_log_full_commit(root->fs_info, trans)) {
2769                 ret = -EAGAIN;
2770                 btrfs_free_logged_extents(log, log_transid);
2771                 mutex_unlock(&root->log_mutex);
2772                 goto out;
2773         }
2774
2775         if (log_transid % 2 == 0)
2776                 mark = EXTENT_DIRTY;
2777         else
2778                 mark = EXTENT_NEW;
2779
2780         /* we start IO on  all the marked extents here, but we don't actually
2781          * wait for them until later.
2782          */
2783         blk_start_plug(&plug);
2784         ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark);
2785         if (ret) {
2786                 blk_finish_plug(&plug);
2787                 btrfs_abort_transaction(trans, root, ret);
2788                 btrfs_free_logged_extents(log, log_transid);
2789                 btrfs_set_log_full_commit(root->fs_info, trans);
2790                 mutex_unlock(&root->log_mutex);
2791                 goto out;
2792         }
2793
2794         btrfs_set_root_node(&log->root_item, log->node);
2795
2796         root->log_transid++;
2797         log->log_transid = root->log_transid;
2798         root->log_start_pid = 0;
2799         /*
2800          * IO has been started, blocks of the log tree have WRITTEN flag set
2801          * in their headers. new modifications of the log will be written to
2802          * new positions. so it's safe to allow log writers to go in.
2803          */
2804         mutex_unlock(&root->log_mutex);
2805
2806         btrfs_init_log_ctx(&root_log_ctx);
2807
2808         mutex_lock(&log_root_tree->log_mutex);
2809         atomic_inc(&log_root_tree->log_batch);
2810         atomic_inc(&log_root_tree->log_writers);
2811
2812         index2 = log_root_tree->log_transid % 2;
2813         list_add_tail(&root_log_ctx.list, &log_root_tree->log_ctxs[index2]);
2814         root_log_ctx.log_transid = log_root_tree->log_transid;
2815
2816         mutex_unlock(&log_root_tree->log_mutex);
2817
2818         ret = update_log_root(trans, log);
2819
2820         mutex_lock(&log_root_tree->log_mutex);
2821         if (atomic_dec_and_test(&log_root_tree->log_writers)) {
2822                 /*
2823                  * Implicit memory barrier after atomic_dec_and_test
2824                  */
2825                 if (waitqueue_active(&log_root_tree->log_writer_wait))
2826                         wake_up(&log_root_tree->log_writer_wait);
2827         }
2828
2829         if (ret) {
2830                 if (!list_empty(&root_log_ctx.list))
2831                         list_del_init(&root_log_ctx.list);
2832
2833                 blk_finish_plug(&plug);
2834                 btrfs_set_log_full_commit(root->fs_info, trans);
2835
2836                 if (ret != -ENOSPC) {
2837                         btrfs_abort_transaction(trans, root, ret);
2838                         mutex_unlock(&log_root_tree->log_mutex);
2839                         goto out;
2840                 }
2841                 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2842                 btrfs_free_logged_extents(log, log_transid);
2843                 mutex_unlock(&log_root_tree->log_mutex);
2844                 ret = -EAGAIN;
2845                 goto out;
2846         }
2847
2848         if (log_root_tree->log_transid_committed >= root_log_ctx.log_transid) {
2849                 blk_finish_plug(&plug);
2850                 list_del_init(&root_log_ctx.list);
2851                 mutex_unlock(&log_root_tree->log_mutex);
2852                 ret = root_log_ctx.log_ret;
2853                 goto out;
2854         }
2855
2856         index2 = root_log_ctx.log_transid % 2;
2857         if (atomic_read(&log_root_tree->log_commit[index2])) {
2858                 blk_finish_plug(&plug);
2859                 ret = btrfs_wait_marked_extents(log, &log->dirty_log_pages,
2860                                                 mark);
2861                 btrfs_wait_logged_extents(trans, log, log_transid);
2862                 wait_log_commit(log_root_tree,
2863                                 root_log_ctx.log_transid);
2864                 mutex_unlock(&log_root_tree->log_mutex);
2865                 if (!ret)
2866                         ret = root_log_ctx.log_ret;
2867                 goto out;
2868         }
2869         ASSERT(root_log_ctx.log_transid == log_root_tree->log_transid);
2870         atomic_set(&log_root_tree->log_commit[index2], 1);
2871
2872         if (atomic_read(&log_root_tree->log_commit[(index2 + 1) % 2])) {
2873                 wait_log_commit(log_root_tree,
2874                                 root_log_ctx.log_transid - 1);
2875         }
2876
2877         wait_for_writer(log_root_tree);
2878
2879         /*
2880          * now that we've moved on to the tree of log tree roots,
2881          * check the full commit flag again
2882          */
2883         if (btrfs_need_log_full_commit(root->fs_info, trans)) {
2884                 blk_finish_plug(&plug);
2885                 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2886                 btrfs_free_logged_extents(log, log_transid);
2887                 mutex_unlock(&log_root_tree->log_mutex);
2888                 ret = -EAGAIN;
2889                 goto out_wake_log_root;
2890         }
2891
2892         ret = btrfs_write_marked_extents(log_root_tree,
2893                                          &log_root_tree->dirty_log_pages,
2894                                          EXTENT_DIRTY | EXTENT_NEW);
2895         blk_finish_plug(&plug);
2896         if (ret) {
2897                 btrfs_set_log_full_commit(root->fs_info, trans);
2898                 btrfs_abort_transaction(trans, root, ret);
2899                 btrfs_free_logged_extents(log, log_transid);
2900                 mutex_unlock(&log_root_tree->log_mutex);
2901                 goto out_wake_log_root;
2902         }
2903         ret = btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2904         if (!ret)
2905                 ret = btrfs_wait_marked_extents(log_root_tree,
2906                                                 &log_root_tree->dirty_log_pages,
2907                                                 EXTENT_NEW | EXTENT_DIRTY);
2908         if (ret) {
2909                 btrfs_set_log_full_commit(root->fs_info, trans);
2910                 btrfs_free_logged_extents(log, log_transid);
2911                 mutex_unlock(&log_root_tree->log_mutex);
2912                 goto out_wake_log_root;
2913         }
2914         btrfs_wait_logged_extents(trans, log, log_transid);
2915
2916         btrfs_set_super_log_root(root->fs_info->super_for_commit,
2917                                 log_root_tree->node->start);
2918         btrfs_set_super_log_root_level(root->fs_info->super_for_commit,
2919                                 btrfs_header_level(log_root_tree->node));
2920
2921         log_root_tree->log_transid++;
2922         mutex_unlock(&log_root_tree->log_mutex);
2923
2924         /*
2925          * nobody else is going to jump in and write the the ctree
2926          * super here because the log_commit atomic below is protecting
2927          * us.  We must be called with a transaction handle pinning
2928          * the running transaction open, so a full commit can't hop
2929          * in and cause problems either.
2930          */
2931         ret = write_ctree_super(trans, root->fs_info->tree_root, 1);
2932         if (ret) {
2933                 btrfs_set_log_full_commit(root->fs_info, trans);
2934                 btrfs_abort_transaction(trans, root, ret);
2935                 goto out_wake_log_root;
2936         }
2937
2938         mutex_lock(&root->log_mutex);
2939         if (root->last_log_commit < log_transid)
2940                 root->last_log_commit = log_transid;
2941         mutex_unlock(&root->log_mutex);
2942
2943 out_wake_log_root:
2944         mutex_lock(&log_root_tree->log_mutex);
2945         btrfs_remove_all_log_ctxs(log_root_tree, index2, ret);
2946
2947         log_root_tree->log_transid_committed++;
2948         atomic_set(&log_root_tree->log_commit[index2], 0);
2949         mutex_unlock(&log_root_tree->log_mutex);
2950
2951         /*
2952          * The barrier before waitqueue_active is implied by mutex_unlock
2953          */
2954         if (waitqueue_active(&log_root_tree->log_commit_wait[index2]))
2955                 wake_up(&log_root_tree->log_commit_wait[index2]);
2956 out:
2957         mutex_lock(&root->log_mutex);
2958         btrfs_remove_all_log_ctxs(root, index1, ret);
2959         root->log_transid_committed++;
2960         atomic_set(&root->log_commit[index1], 0);
2961         mutex_unlock(&root->log_mutex);
2962
2963         /*
2964          * The barrier before waitqueue_active is implied by mutex_unlock
2965          */
2966         if (waitqueue_active(&root->log_commit_wait[index1]))
2967                 wake_up(&root->log_commit_wait[index1]);
2968         return ret;
2969 }
2970
2971 static void free_log_tree(struct btrfs_trans_handle *trans,
2972                           struct btrfs_root *log)
2973 {
2974         int ret;
2975         u64 start;
2976         u64 end;
2977         struct walk_control wc = {
2978                 .free = 1,
2979                 .process_func = process_one_buffer
2980         };
2981
2982         ret = walk_log_tree(trans, log, &wc);
2983         /* I don't think this can happen but just in case */
2984         if (ret)
2985                 btrfs_abort_transaction(trans, log, ret);
2986
2987         while (1) {
2988                 ret = find_first_extent_bit(&log->dirty_log_pages,
2989                                 0, &start, &end, EXTENT_DIRTY | EXTENT_NEW,
2990                                 NULL);
2991                 if (ret)
2992                         break;
2993
2994                 clear_extent_bits(&log->dirty_log_pages, start, end,
2995                                   EXTENT_DIRTY | EXTENT_NEW, GFP_NOFS);
2996         }
2997
2998         /*
2999          * We may have short-circuited the log tree with the full commit logic
3000          * and left ordered extents on our list, so clear these out to keep us
3001          * from leaking inodes and memory.
3002          */
3003         btrfs_free_logged_extents(log, 0);
3004         btrfs_free_logged_extents(log, 1);
3005
3006         free_extent_buffer(log->node);
3007         kfree(log);
3008 }
3009
3010 /*
3011  * free all the extents used by the tree log.  This should be called
3012  * at commit time of the full transaction
3013  */
3014 int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
3015 {
3016         if (root->log_root) {
3017                 free_log_tree(trans, root->log_root);
3018                 root->log_root = NULL;
3019         }
3020         return 0;
3021 }
3022
3023 int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
3024                              struct btrfs_fs_info *fs_info)
3025 {
3026         if (fs_info->log_root_tree) {
3027                 free_log_tree(trans, fs_info->log_root_tree);
3028                 fs_info->log_root_tree = NULL;
3029         }
3030         return 0;
3031 }
3032
3033 /*
3034  * If both a file and directory are logged, and unlinks or renames are
3035  * mixed in, we have a few interesting corners:
3036  *
3037  * create file X in dir Y
3038  * link file X to X.link in dir Y
3039  * fsync file X
3040  * unlink file X but leave X.link
3041  * fsync dir Y
3042  *
3043  * After a crash we would expect only X.link to exist.  But file X
3044  * didn't get fsync'd again so the log has back refs for X and X.link.
3045  *
3046  * We solve this by removing directory entries and inode backrefs from the
3047  * log when a file that was logged in the current transaction is
3048  * unlinked.  Any later fsync will include the updated log entries, and
3049  * we'll be able to reconstruct the proper directory items from backrefs.
3050  *
3051  * This optimizations allows us to avoid relogging the entire inode
3052  * or the entire directory.
3053  */
3054 int btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans,
3055                                  struct btrfs_root *root,
3056                                  const char *name, int name_len,
3057                                  struct inode *dir, u64 index)
3058 {
3059         struct btrfs_root *log;
3060         struct btrfs_dir_item *di;
3061         struct btrfs_path *path;
3062         int ret;
3063         int err = 0;
3064         int bytes_del = 0;
3065         u64 dir_ino = btrfs_ino(dir);
3066
3067         if (BTRFS_I(dir)->logged_trans < trans->transid)
3068                 return 0;
3069
3070         ret = join_running_log_trans(root);
3071         if (ret)
3072                 return 0;
3073
3074         mutex_lock(&BTRFS_I(dir)->log_mutex);
3075
3076         log = root->log_root;
3077         path = btrfs_alloc_path();
3078         if (!path) {
3079                 err = -ENOMEM;
3080                 goto out_unlock;
3081         }
3082
3083         di = btrfs_lookup_dir_item(trans, log, path, dir_ino,
3084                                    name, name_len, -1);
3085         if (IS_ERR(di)) {
3086                 err = PTR_ERR(di);
3087                 goto fail;
3088         }
3089         if (di) {
3090                 ret = btrfs_delete_one_dir_name(trans, log, path, di);
3091                 bytes_del += name_len;
3092                 if (ret) {
3093                         err = ret;
3094                         goto fail;
3095                 }
3096         }
3097         btrfs_release_path(path);
3098         di = btrfs_lookup_dir_index_item(trans, log, path, dir_ino,
3099                                          index, name, name_len, -1);
3100         if (IS_ERR(di)) {
3101                 err = PTR_ERR(di);
3102                 goto fail;
3103         }
3104         if (di) {
3105                 ret = btrfs_delete_one_dir_name(trans, log, path, di);
3106                 bytes_del += name_len;
3107                 if (ret) {
3108                         err = ret;
3109                         goto fail;
3110                 }
3111         }
3112
3113         /* update the directory size in the log to reflect the names
3114          * we have removed
3115          */
3116         if (bytes_del) {
3117                 struct btrfs_key key;
3118
3119                 key.objectid = dir_ino;
3120                 key.offset = 0;
3121                 key.type = BTRFS_INODE_ITEM_KEY;
3122                 btrfs_release_path(path);
3123
3124                 ret = btrfs_search_slot(trans, log, &key, path, 0, 1);
3125                 if (ret < 0) {
3126                         err = ret;
3127                         goto fail;
3128                 }
3129                 if (ret == 0) {
3130                         struct btrfs_inode_item *item;
3131                         u64 i_size;
3132
3133                         item = btrfs_item_ptr(path->nodes[0], path->slots[0],
3134                                               struct btrfs_inode_item);
3135                         i_size = btrfs_inode_size(path->nodes[0], item);
3136                         if (i_size > bytes_del)
3137                                 i_size -= bytes_del;
3138                         else
3139                                 i_size = 0;
3140                         btrfs_set_inode_size(path->nodes[0], item, i_size);
3141                         btrfs_mark_buffer_dirty(path->nodes[0]);
3142                 } else
3143                         ret = 0;
3144                 btrfs_release_path(path);
3145         }
3146 fail:
3147         btrfs_free_path(path);
3148 out_unlock:
3149         mutex_unlock(&BTRFS_I(dir)->log_mutex);
3150         if (ret == -ENOSPC) {
3151                 btrfs_set_log_full_commit(root->fs_info, trans);
3152                 ret = 0;
3153         } else if (ret < 0)
3154                 btrfs_abort_transaction(trans, root, ret);
3155
3156         btrfs_end_log_trans(root);
3157
3158         return err;
3159 }
3160
3161 /* see comments for btrfs_del_dir_entries_in_log */
3162 int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans,
3163                                struct btrfs_root *root,
3164                                const char *name, int name_len,
3165                                struct inode *inode, u64 dirid)
3166 {
3167         struct btrfs_root *log;
3168         u64 index;
3169         int ret;
3170
3171         if (BTRFS_I(inode)->logged_trans < trans->transid)
3172                 return 0;
3173
3174         ret = join_running_log_trans(root);
3175         if (ret)
3176                 return 0;
3177         log = root->log_root;
3178         mutex_lock(&BTRFS_I(inode)->log_mutex);
3179
3180         ret = btrfs_del_inode_ref(trans, log, name, name_len, btrfs_ino(inode),
3181                                   dirid, &index);
3182         mutex_unlock(&BTRFS_I(inode)->log_mutex);
3183         if (ret == -ENOSPC) {
3184                 btrfs_set_log_full_commit(root->fs_info, trans);
3185                 ret = 0;
3186         } else if (ret < 0 && ret != -ENOENT)
3187                 btrfs_abort_transaction(trans, root, ret);
3188         btrfs_end_log_trans(root);
3189
3190         return ret;
3191 }
3192
3193 /*
3194  * creates a range item in the log for 'dirid'.  first_offset and
3195  * last_offset tell us which parts of the key space the log should
3196  * be considered authoritative for.
3197  */
3198 static noinline int insert_dir_log_key(struct btrfs_trans_handle *trans,
3199                                        struct btrfs_root *log,
3200                                        struct btrfs_path *path,
3201                                        int key_type, u64 dirid,
3202                                        u64 first_offset, u64 last_offset)
3203 {
3204         int ret;
3205         struct btrfs_key key;
3206         struct btrfs_dir_log_item *item;
3207
3208         key.objectid = dirid;
3209         key.offset = first_offset;
3210         if (key_type == BTRFS_DIR_ITEM_KEY)
3211                 key.type = BTRFS_DIR_LOG_ITEM_KEY;
3212         else
3213                 key.type = BTRFS_DIR_LOG_INDEX_KEY;
3214         ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
3215         if (ret)
3216                 return ret;
3217
3218         item = btrfs_item_ptr(path->nodes[0], path->slots[0],
3219                               struct btrfs_dir_log_item);
3220         btrfs_set_dir_log_end(path->nodes[0], item, last_offset);
3221         btrfs_mark_buffer_dirty(path->nodes[0]);
3222         btrfs_release_path(path);
3223         return 0;
3224 }
3225
3226 /*
3227  * log all the items included in the current transaction for a given
3228  * directory.  This also creates the range items in the log tree required
3229  * to replay anything deleted before the fsync
3230  */
3231 static noinline int log_dir_items(struct btrfs_trans_handle *trans,
3232                           struct btrfs_root *root, struct inode *inode,
3233                           struct btrfs_path *path,
3234                           struct btrfs_path *dst_path, int key_type,
3235                           struct btrfs_log_ctx *ctx,
3236                           u64 min_offset, u64 *last_offset_ret)
3237 {
3238         struct btrfs_key min_key;
3239         struct btrfs_root *log = root->log_root;
3240         struct extent_buffer *src;
3241         int err = 0;
3242         int ret;
3243         int i;
3244         int nritems;
3245         u64 first_offset = min_offset;
3246         u64 last_offset = (u64)-1;
3247         u64 ino = btrfs_ino(inode);
3248
3249         log = root->log_root;
3250
3251         min_key.objectid = ino;
3252         min_key.type = key_type;
3253         min_key.offset = min_offset;
3254
3255         ret = btrfs_search_forward(root, &min_key, path, trans->transid);
3256
3257         /*
3258          * we didn't find anything from this transaction, see if there
3259          * is anything at all
3260          */
3261         if (ret != 0 || min_key.objectid != ino || min_key.type != key_type) {
3262                 min_key.objectid = ino;
3263                 min_key.type = key_type;
3264                 min_key.offset = (u64)-1;
3265                 btrfs_release_path(path);
3266                 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3267                 if (ret < 0) {
3268                         btrfs_release_path(path);
3269                         return ret;
3270                 }
3271                 ret = btrfs_previous_item(root, path, ino, key_type);
3272
3273                 /* if ret == 0 there are items for this type,
3274                  * create a range to tell us the last key of this type.
3275                  * otherwise, there are no items in this directory after
3276                  * *min_offset, and we create a range to indicate that.
3277                  */
3278                 if (ret == 0) {
3279                         struct btrfs_key tmp;
3280                         btrfs_item_key_to_cpu(path->nodes[0], &tmp,
3281                                               path->slots[0]);
3282                         if (key_type == tmp.type)
3283                                 first_offset = max(min_offset, tmp.offset) + 1;
3284                 }
3285                 goto done;
3286         }
3287
3288         /* go backward to find any previous key */
3289         ret = btrfs_previous_item(root, path, ino, key_type);
3290         if (ret == 0) {
3291                 struct btrfs_key tmp;
3292                 btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
3293                 if (key_type == tmp.type) {
3294                         first_offset = tmp.offset;
3295                         ret = overwrite_item(trans, log, dst_path,
3296                                              path->nodes[0], path->slots[0],
3297                                              &tmp);
3298                         if (ret) {
3299                                 err = ret;
3300                                 goto done;
3301                         }
3302                 }
3303         }
3304         btrfs_release_path(path);
3305
3306         /* find the first key from this transaction again */
3307         ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
3308         if (WARN_ON(ret != 0))
3309                 goto done;
3310
3311         /*
3312          * we have a block from this transaction, log every item in it
3313          * from our directory
3314          */
3315         while (1) {
3316                 struct btrfs_key tmp;
3317                 src = path->nodes[0];
3318                 nritems = btrfs_header_nritems(src);
3319                 for (i = path->slots[0]; i < nritems; i++) {
3320                         struct btrfs_dir_item *di;
3321
3322                         btrfs_item_key_to_cpu(src, &min_key, i);
3323
3324                         if (min_key.objectid != ino || min_key.type != key_type)
3325                                 goto done;
3326                         ret = overwrite_item(trans, log, dst_path, src, i,
3327                                              &min_key);
3328                         if (ret) {
3329                                 err = ret;
3330                                 goto done;
3331                         }
3332
3333                         /*
3334                          * We must make sure that when we log a directory entry,
3335                          * the corresponding inode, after log replay, has a
3336                          * matching link count. For example:
3337                          *
3338                          * touch foo
3339                          * mkdir mydir
3340                          * sync
3341                          * ln foo mydir/bar
3342                          * xfs_io -c "fsync" mydir
3343                          * <crash>
3344                          * <mount fs and log replay>
3345                          *
3346                          * Would result in a fsync log that when replayed, our
3347                          * file inode would have a link count of 1, but we get
3348                          * two directory entries pointing to the same inode.
3349                          * After removing one of the names, it would not be
3350                          * possible to remove the other name, which resulted
3351                          * always in stale file handle errors, and would not
3352                          * be possible to rmdir the parent directory, since
3353                          * its i_size could never decrement to the value
3354                          * BTRFS_EMPTY_DIR_SIZE, resulting in -ENOTEMPTY errors.
3355                          */
3356                         di = btrfs_item_ptr(src, i, struct btrfs_dir_item);
3357                         btrfs_dir_item_key_to_cpu(src, di, &tmp);
3358                         if (ctx &&
3359                             (btrfs_dir_transid(src, di) == trans->transid ||
3360                              btrfs_dir_type(src, di) == BTRFS_FT_DIR) &&
3361                             tmp.type != BTRFS_ROOT_ITEM_KEY)
3362                                 ctx->log_new_dentries = true;
3363                 }
3364                 path->slots[0] = nritems;
3365
3366                 /*
3367                  * look ahead to the next item and see if it is also
3368                  * from this directory and from this transaction
3369                  */
3370                 ret = btrfs_next_leaf(root, path);
3371                 if (ret == 1) {
3372                         last_offset = (u64)-1;
3373                         goto done;
3374                 }
3375                 btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
3376                 if (tmp.objectid != ino || tmp.type != key_type) {
3377                         last_offset = (u64)-1;
3378                         goto done;
3379                 }
3380                 if (btrfs_header_generation(path->nodes[0]) != trans->transid) {
3381                         ret = overwrite_item(trans, log, dst_path,
3382                                              path->nodes[0], path->slots[0],
3383                                              &tmp);
3384                         if (ret)
3385                                 err = ret;
3386                         else
3387                                 last_offset = tmp.offset;
3388                         goto done;
3389                 }
3390         }
3391 done:
3392         btrfs_release_path(path);
3393         btrfs_release_path(dst_path);
3394
3395         if (err == 0) {
3396                 *last_offset_ret = last_offset;
3397                 /*
3398                  * insert the log range keys to indicate where the log
3399                  * is valid
3400                  */
3401                 ret = insert_dir_log_key(trans, log, path, key_type,
3402                                          ino, first_offset, last_offset);
3403                 if (ret)
3404                         err = ret;
3405         }
3406         return err;
3407 }
3408
3409 /*
3410  * logging directories is very similar to logging inodes, We find all the items
3411  * from the current transaction and write them to the log.
3412  *
3413  * The recovery code scans the directory in the subvolume, and if it finds a
3414  * key in the range logged that is not present in the log tree, then it means
3415  * that dir entry was unlinked during the transaction.
3416  *
3417  * In order for that scan to work, we must include one key smaller than
3418  * the smallest logged by this transaction and one key larger than the largest
3419  * key logged by this transaction.
3420  */
3421 static noinline int log_directory_changes(struct btrfs_trans_handle *trans,
3422                           struct btrfs_root *root, struct inode *inode,
3423                           struct btrfs_path *path,
3424                           struct btrfs_path *dst_path,
3425                           struct btrfs_log_ctx *ctx)
3426 {
3427         u64 min_key;
3428         u64 max_key;
3429         int ret;
3430         int key_type = BTRFS_DIR_ITEM_KEY;
3431
3432 again:
3433         min_key = 0;
3434         max_key = 0;
3435         while (1) {
3436                 ret = log_dir_items(trans, root, inode, path,
3437                                     dst_path, key_type, ctx, min_key,
3438                                     &max_key);
3439                 if (ret)
3440                         return ret;
3441                 if (max_key == (u64)-1)
3442                         break;
3443                 min_key = max_key + 1;
3444         }
3445
3446         if (key_type == BTRFS_DIR_ITEM_KEY) {
3447                 key_type = BTRFS_DIR_INDEX_KEY;
3448                 goto again;
3449         }
3450         return 0;
3451 }
3452
3453 /*
3454  * a helper function to drop items from the log before we relog an
3455  * inode.  max_key_type indicates the highest item type to remove.
3456  * This cannot be run for file data extents because it does not
3457  * free the extents they point to.
3458  */
3459 static int drop_objectid_items(struct btrfs_trans_handle *trans,
3460                                   struct btrfs_root *log,
3461                                   struct btrfs_path *path,
3462                                   u64 objectid, int max_key_type)
3463 {
3464         int ret;
3465         struct btrfs_key key;
3466         struct btrfs_key found_key;
3467         int start_slot;
3468
3469         key.objectid = objectid;
3470         key.type = max_key_type;
3471         key.offset = (u64)-1;
3472
3473         while (1) {
3474                 ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
3475                 BUG_ON(ret == 0); /* Logic error */
3476                 if (ret < 0)
3477                         break;
3478
3479                 if (path->slots[0] == 0)
3480                         break;
3481
3482                 path->slots[0]--;
3483                 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
3484                                       path->slots[0]);
3485
3486                 if (found_key.objectid != objectid)
3487                         break;
3488
3489                 found_key.offset = 0;
3490                 found_key.type = 0;
3491                 ret = btrfs_bin_search(path->nodes[0], &found_key, 0,
3492                                        &start_slot);
3493
3494                 ret = btrfs_del_items(trans, log, path, start_slot,
3495                                       path->slots[0] - start_slot + 1);
3496                 /*
3497                  * If start slot isn't 0 then we don't need to re-search, we've
3498                  * found the last guy with the objectid in this tree.
3499                  */
3500                 if (ret || start_slot != 0)
3501                         break;
3502                 btrfs_release_path(path);
3503         }
3504         btrfs_release_path(path);
3505         if (ret > 0)
3506                 ret = 0;
3507         return ret;
3508 }
3509
3510 static void fill_inode_item(struct btrfs_trans_handle *trans,
3511                             struct extent_buffer *leaf,
3512                             struct btrfs_inode_item *item,
3513                             struct inode *inode, int log_inode_only,
3514                             u64 logged_isize)
3515 {
3516         struct btrfs_map_token token;
3517
3518         btrfs_init_map_token(&token);
3519
3520         if (log_inode_only) {
3521                 /* set the generation to zero so the recover code
3522                  * can tell the difference between an logging
3523                  * just to say 'this inode exists' and a logging
3524                  * to say 'update this inode with these values'
3525                  */
3526                 btrfs_set_token_inode_generation(leaf, item, 0, &token);
3527                 btrfs_set_token_inode_size(leaf, item, logged_isize, &token);
3528         } else {
3529                 btrfs_set_token_inode_generation(leaf, item,
3530                                                  BTRFS_I(inode)->generation,
3531                                                  &token);
3532                 btrfs_set_token_inode_size(leaf, item, inode->i_size, &token);
3533         }
3534
3535         btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);
3536         btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);
3537         btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);
3538         btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);
3539
3540         btrfs_set_token_timespec_sec(leaf, &item->atime,
3541                                      inode->i_atime.tv_sec, &token);
3542         btrfs_set_token_timespec_nsec(leaf, &item->atime,
3543                                       inode->i_atime.tv_nsec, &token);
3544
3545         btrfs_set_token_timespec_sec(leaf, &item->mtime,
3546                                      inode->i_mtime.tv_sec, &token);
3547         btrfs_set_token_timespec_nsec(leaf, &item->mtime,
3548                                       inode->i_mtime.tv_nsec, &token);
3549
3550         btrfs_set_token_timespec_sec(leaf, &item->ctime,
3551                                      inode->i_ctime.tv_sec, &token);
3552         btrfs_set_token_timespec_nsec(leaf, &item->ctime,
3553                                       inode->i_ctime.tv_nsec, &token);
3554
3555         btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),
3556                                      &token);
3557
3558         btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token);
3559         btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);
3560         btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
3561         btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
3562         btrfs_set_token_inode_block_group(leaf, item, 0, &token);
3563 }
3564
3565 static int log_inode_item(struct btrfs_trans_handle *trans,
3566                           struct btrfs_root *log, struct btrfs_path *path,
3567                           struct inode *inode)
3568 {
3569         struct btrfs_inode_item *inode_item;
3570         int ret;
3571
3572         ret = btrfs_insert_empty_item(trans, log, path,
3573                                       &BTRFS_I(inode)->location,
3574                                       sizeof(*inode_item));
3575         if (ret && ret != -EEXIST)
3576                 return ret;
3577         inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
3578                                     struct btrfs_inode_item);
3579         fill_inode_item(trans, path->nodes[0], inode_item, inode, 0, 0);
3580         btrfs_release_path(path);
3581         return 0;
3582 }
3583
3584 static noinline int copy_items(struct btrfs_trans_handle *trans,
3585                                struct inode *inode,
3586                                struct btrfs_path *dst_path,
3587                                struct btrfs_path *src_path, u64 *last_extent,
3588                                int start_slot, int nr, int inode_only,
3589                                u64 logged_isize)
3590 {
3591         unsigned long src_offset;
3592         unsigned long dst_offset;
3593         struct btrfs_root *log = BTRFS_I(inode)->root->log_root;
3594         struct btrfs_file_extent_item *extent;
3595         struct btrfs_inode_item *inode_item;
3596         struct extent_buffer *src = src_path->nodes[0];
3597         struct btrfs_key first_key, last_key, key;
3598         int ret;
3599         struct btrfs_key *ins_keys;
3600         u32 *ins_sizes;
3601         char *ins_data;
3602         int i;
3603         struct list_head ordered_sums;
3604         int skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
3605         bool has_extents = false;
3606         bool need_find_last_extent = true;
3607         bool done = false;
3608
3609         INIT_LIST_HEAD(&ordered_sums);
3610
3611         ins_data = kmalloc(nr * sizeof(struct btrfs_key) +
3612                            nr * sizeof(u32), GFP_NOFS);
3613         if (!ins_data)
3614                 return -ENOMEM;
3615
3616         first_key.objectid = (u64)-1;
3617
3618         ins_sizes = (u32 *)ins_data;
3619         ins_keys = (struct btrfs_key *)(ins_data + nr * sizeof(u32));
3620
3621         for (i = 0; i < nr; i++) {
3622                 ins_sizes[i] = btrfs_item_size_nr(src, i + start_slot);
3623                 btrfs_item_key_to_cpu(src, ins_keys + i, i + start_slot);
3624         }
3625         ret = btrfs_insert_empty_items(trans, log, dst_path,
3626                                        ins_keys, ins_sizes, nr);
3627         if (ret) {
3628                 kfree(ins_data);
3629                 return ret;
3630         }
3631
3632         for (i = 0; i < nr; i++, dst_path->slots[0]++) {
3633                 dst_offset = btrfs_item_ptr_offset(dst_path->nodes[0],
3634                                                    dst_path->slots[0]);
3635
3636                 src_offset = btrfs_item_ptr_offset(src, start_slot + i);
3637
3638                 if ((i == (nr - 1)))
3639                         last_key = ins_keys[i];
3640
3641                 if (ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
3642                         inode_item = btrfs_item_ptr(dst_path->nodes[0],
3643                                                     dst_path->slots[0],
3644                                                     struct btrfs_inode_item);
3645                         fill_inode_item(trans, dst_path->nodes[0], inode_item,
3646                                         inode, inode_only == LOG_INODE_EXISTS,
3647                                         logged_isize);
3648                 } else {
3649                         copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
3650                                            src_offset, ins_sizes[i]);
3651                 }
3652
3653                 /*
3654                  * We set need_find_last_extent here in case we know we were
3655                  * processing other items and then walk into the first extent in
3656                  * the inode.  If we don't hit an extent then nothing changes,
3657                  * we'll do the last search the next time around.
3658                  */
3659                 if (ins_keys[i].type == BTRFS_EXTENT_DATA_KEY) {
3660                         has_extents = true;
3661                         if (first_key.objectid == (u64)-1)
3662                                 first_key = ins_keys[i];
3663                 } else {
3664                         need_find_last_extent = false;
3665                 }
3666
3667                 /* take a reference on file data extents so that truncates
3668                  * or deletes of this inode don't have to relog the inode
3669                  * again
3670                  */
3671                 if (ins_keys[i].type == BTRFS_EXTENT_DATA_KEY &&
3672                     !skip_csum) {
3673                         int found_type;
3674                         extent = btrfs_item_ptr(src, start_slot + i,
3675                                                 struct btrfs_file_extent_item);
3676
3677                         if (btrfs_file_extent_generation(src, extent) < trans->transid)
3678                                 continue;
3679
3680                         found_type = btrfs_file_extent_type(src, extent);
3681                         if (found_type == BTRFS_FILE_EXTENT_REG) {
3682                                 u64 ds, dl, cs, cl;
3683                                 ds = btrfs_file_extent_disk_bytenr(src,
3684                                                                 extent);
3685                                 /* ds == 0 is a hole */
3686                                 if (ds == 0)
3687                                         continue;
3688
3689                                 dl = btrfs_file_extent_disk_num_bytes(src,
3690                                                                 extent);
3691                                 cs = btrfs_file_extent_offset(src, extent);
3692                                 cl = btrfs_file_extent_num_bytes(src,
3693                                                                 extent);
3694                                 if (btrfs_file_extent_compression(src,
3695                                                                   extent)) {
3696                                         cs = 0;
3697                                         cl = dl;
3698                                 }
3699
3700                                 ret = btrfs_lookup_csums_range(
3701                                                 log->fs_info->csum_root,
3702                                                 ds + cs, ds + cs + cl - 1,
3703                                                 &ordered_sums, 0);
3704                                 if (ret) {
3705                                         btrfs_release_path(dst_path);
3706                                         kfree(ins_data);
3707                                         return ret;
3708                                 }
3709                         }
3710                 }
3711         }
3712
3713         btrfs_mark_buffer_dirty(dst_path->nodes[0]);
3714         btrfs_release_path(dst_path);
3715         kfree(ins_data);
3716
3717         /*
3718          * we have to do this after the loop above to avoid changing the
3719          * log tree while trying to change the log tree.
3720          */
3721         ret = 0;
3722         while (!list_empty(&ordered_sums)) {
3723                 struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
3724                                                    struct btrfs_ordered_sum,
3725                                                    list);
3726                 if (!ret)
3727                         ret = btrfs_csum_file_blocks(trans, log, sums);
3728                 list_del(&sums->list);
3729                 kfree(sums);
3730         }
3731
3732         if (!has_extents)
3733                 return ret;
3734
3735         if (need_find_last_extent && *last_extent == first_key.offset) {
3736                 /*
3737                  * We don't have any leafs between our current one and the one
3738                  * we processed before that can have file extent items for our
3739                  * inode (and have a generation number smaller than our current
3740                  * transaction id).
3741                  */
3742                 need_find_last_extent = false;
3743         }
3744
3745         /*
3746          * Because we use btrfs_search_forward we could skip leaves that were
3747          * not modified and then assume *last_extent is valid when it really
3748          * isn't.  So back up to the previous leaf and read the end of the last
3749          * extent before we go and fill in holes.
3750          */
3751         if (need_find_last_extent) {
3752                 u64 len;
3753
3754                 ret = btrfs_prev_leaf(BTRFS_I(inode)->root, src_path);
3755                 if (ret < 0)
3756                         return ret;
3757                 if (ret)
3758                         goto fill_holes;
3759                 if (src_path->slots[0])
3760                         src_path->slots[0]--;
3761                 src = src_path->nodes[0];
3762                 btrfs_item_key_to_cpu(src, &key, src_path->slots[0]);
3763                 if (key.objectid != btrfs_ino(inode) ||
3764                     key.type != BTRFS_EXTENT_DATA_KEY)
3765                         goto fill_holes;
3766                 extent = btrfs_item_ptr(src, src_path->slots[0],
3767                                         struct btrfs_file_extent_item);
3768                 if (btrfs_file_extent_type(src, extent) ==
3769                     BTRFS_FILE_EXTENT_INLINE) {
3770                         len = btrfs_file_extent_inline_len(src,
3771                                                            src_path->slots[0],
3772                                                            extent);
3773                         *last_extent = ALIGN(key.offset + len,
3774                                              log->sectorsize);
3775                 } else {
3776                         len = btrfs_file_extent_num_bytes(src, extent);
3777                         *last_extent = key.offset + len;
3778                 }
3779         }
3780 fill_holes:
3781         /* So we did prev_leaf, now we need to move to the next leaf, but a few
3782          * things could have happened
3783          *
3784          * 1) A merge could have happened, so we could currently be on a leaf
3785          * that holds what we were copying in the first place.
3786          * 2) A split could have happened, and now not all of the items we want
3787          * are on the same leaf.
3788          *
3789          * So we need to adjust how we search for holes, we need to drop the
3790          * path and re-search for the first extent key we found, and then walk
3791          * forward until we hit the last one we copied.
3792          */
3793         if (need_find_last_extent) {
3794                 /* btrfs_prev_leaf could return 1 without releasing the path */
3795                 btrfs_release_path(src_path);
3796                 ret = btrfs_search_slot(NULL, BTRFS_I(inode)->root, &first_key,
3797                                         src_path, 0, 0);
3798                 if (ret < 0)
3799                         return ret;
3800                 ASSERT(ret == 0);
3801                 src = src_path->nodes[0];
3802                 i = src_path->slots[0];
3803         } else {
3804                 i = start_slot;
3805         }
3806
3807         /*
3808          * Ok so here we need to go through and fill in any holes we may have
3809          * to make sure that holes are punched for those areas in case they had
3810          * extents previously.
3811          */
3812         while (!done) {
3813                 u64 offset, len;
3814                 u64 extent_end;
3815
3816                 if (i >= btrfs_header_nritems(src_path->nodes[0])) {
3817                         ret = btrfs_next_leaf(BTRFS_I(inode)->root, src_path);
3818                         if (ret < 0)
3819                                 return ret;
3820                         ASSERT(ret == 0);
3821                         src = src_path->nodes[0];
3822                         i = 0;
3823                 }
3824
3825                 btrfs_item_key_to_cpu(src, &key, i);
3826                 if (!btrfs_comp_cpu_keys(&key, &last_key))
3827                         done = true;
3828                 if (key.objectid != btrfs_ino(inode) ||
3829                     key.type != BTRFS_EXTENT_DATA_KEY) {
3830                         i++;
3831                         continue;
3832                 }
3833                 extent = btrfs_item_ptr(src, i, struct btrfs_file_extent_item);
3834                 if (btrfs_file_extent_type(src, extent) ==
3835                     BTRFS_FILE_EXTENT_INLINE) {
3836                         len = btrfs_file_extent_inline_len(src, i, extent);
3837                         extent_end = ALIGN(key.offset + len, log->sectorsize);
3838                 } else {
3839                         len = btrfs_file_extent_num_bytes(src, extent);
3840                         extent_end = key.offset + len;
3841                 }
3842                 i++;
3843
3844                 if (*last_extent == key.offset) {
3845                         *last_extent = extent_end;
3846                         continue;
3847                 }
3848                 offset = *last_extent;
3849                 len = key.offset - *last_extent;
3850                 ret = btrfs_insert_file_extent(trans, log, btrfs_ino(inode),
3851                                                offset, 0, 0, len, 0, len, 0,
3852                                                0, 0);
3853                 if (ret)
3854                         break;
3855                 *last_extent = extent_end;
3856         }
3857         /*
3858          * Need to let the callers know we dropped the path so they should
3859          * re-search.
3860          */
3861         if (!ret && need_find_last_extent)
3862                 ret = 1;
3863         return ret;
3864 }
3865
3866 static int extent_cmp(void *priv, struct list_head *a, struct list_head *b)
3867 {
3868         struct extent_map *em1, *em2;
3869
3870         em1 = list_entry(a, struct extent_map, list);
3871         em2 = list_entry(b, struct extent_map, list);
3872
3873         if (em1->start < em2->start)
3874                 return -1;
3875         else if (em1->start > em2->start)
3876                 return 1;
3877         return 0;
3878 }
3879
3880 static int wait_ordered_extents(struct btrfs_trans_handle *trans,
3881                                 struct inode *inode,
3882                                 struct btrfs_root *root,
3883                                 const struct extent_map *em,
3884                                 const struct list_head *logged_list,
3885                                 bool *ordered_io_error)
3886 {
3887         struct btrfs_ordered_extent *ordered;
3888         struct btrfs_root *log = root->log_root;
3889         u64 mod_start = em->mod_start;
3890         u64 mod_len = em->mod_len;
3891         const bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
3892         u64 csum_offset;
3893         u64 csum_len;
3894         LIST_HEAD(ordered_sums);
3895         int ret = 0;
3896
3897         *ordered_io_error = false;
3898
3899         if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) ||
3900             em->block_start == EXTENT_MAP_HOLE)
3901                 return 0;
3902
3903         /*
3904          * Wait far any ordered extent that covers our extent map. If it
3905          * finishes without an error, first check and see if our csums are on
3906          * our outstanding ordered extents.
3907          */
3908         list_for_each_entry(ordered, logged_list, log_list) {
3909                 struct btrfs_ordered_sum *sum;
3910
3911                 if (!mod_len)
3912                         break;
3913
3914                 if (ordered->file_offset + ordered->len <= mod_start ||
3915                     mod_start + mod_len <= ordered->file_offset)
3916                         continue;
3917
3918                 if (!test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags) &&
3919                     !test_bit(BTRFS_ORDERED_IOERR, &ordered->flags) &&
3920                     !test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags)) {
3921                         const u64 start = ordered->file_offset;
3922                         const u64 end = ordered->file_offset + ordered->len - 1;
3923
3924                         WARN_ON(ordered->inode != inode);
3925                         filemap_fdatawrite_range(inode->i_mapping, start, end);
3926                 }
3927
3928                 wait_event(ordered->wait,
3929                            (test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags) ||
3930                             test_bit(BTRFS_ORDERED_IOERR, &ordered->flags)));
3931
3932                 if (test_bit(BTRFS_ORDERED_IOERR, &ordered->flags)) {
3933                         /*
3934                          * Clear the AS_EIO/AS_ENOSPC flags from the inode's
3935                          * i_mapping flags, so that the next fsync won't get
3936                          * an outdated io error too.
3937                          */
3938                         btrfs_inode_check_errors(inode);
3939                         *ordered_io_error = true;
3940                         break;
3941                 }
3942                 /*
3943                  * We are going to copy all the csums on this ordered extent, so
3944                  * go ahead and adjust mod_start and mod_len in case this
3945                  * ordered extent has already been logged.
3946                  */
3947                 if (ordered->file_offset > mod_start) {
3948                         if (ordered->file_offset + ordered->len >=
3949                             mod_start + mod_len)
3950                                 mod_len = ordered->file_offset - mod_start;
3951                         /*
3952                          * If we have this case
3953                          *
3954                          * |--------- logged extent ---------|
3955                          *       |----- ordered extent ----|
3956                          *
3957                          * Just don't mess with mod_start and mod_len, we'll
3958                          * just end up logging more csums than we need and it
3959                          * will be ok.
3960                          */
3961                 } else {
3962                         if (ordered->file_offset + ordered->len <
3963                             mod_start + mod_len) {
3964                                 mod_len = (mod_start + mod_len) -
3965                                         (ordered->file_offset + ordered->len);
3966                                 mod_start = ordered->file_offset +
3967                                         ordered->len;
3968                         } else {
3969                                 mod_len = 0;
3970                         }
3971                 }
3972
3973                 if (skip_csum)
3974                         continue;
3975
3976                 /*
3977                  * To keep us from looping for the above case of an ordered
3978                  * extent that falls inside of the logged extent.
3979                  */
3980                 if (test_and_set_bit(BTRFS_ORDERED_LOGGED_CSUM,
3981                                      &ordered->flags))
3982                         continue;
3983
3984                 list_for_each_entry(sum, &ordered->list, list) {
3985                         ret = btrfs_csum_file_blocks(trans, log, sum);
3986                         if (ret)
3987                                 break;
3988                 }
3989         }
3990
3991         if (*ordered_io_error || !mod_len || ret || skip_csum)
3992                 return ret;
3993
3994         if (em->compress_type) {
3995                 csum_offset = 0;
3996                 csum_len = max(em->block_len, em->orig_block_len);
3997         } else {
3998                 csum_offset = mod_start - em->start;
3999                 csum_len = mod_len;
4000         }
4001
4002         /* block start is already adjusted for the file extent offset. */
4003         ret = btrfs_lookup_csums_range(log->fs_info->csum_root,
4004                                        em->block_start + csum_offset,
4005                                        em->block_start + csum_offset +
4006                                        csum_len - 1, &ordered_sums, 0);
4007         if (ret)
4008                 return ret;
4009
4010         while (!list_empty(&ordered_sums)) {
4011                 struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
4012                                                    struct btrfs_ordered_sum,
4013                                                    list);
4014                 if (!ret)
4015                         ret = btrfs_csum_file_blocks(trans, log, sums);
4016                 list_del(&sums->list);
4017                 kfree(sums);
4018         }
4019
4020         return ret;
4021 }
4022
4023 static int log_one_extent(struct btrfs_trans_handle *trans,
4024                           struct inode *inode, struct btrfs_root *root,
4025                           const struct extent_map *em,
4026                           struct btrfs_path *path,
4027                           const struct list_head *logged_list,
4028                           struct btrfs_log_ctx *ctx)
4029 {
4030         struct btrfs_root *log = root->log_root;
4031         struct btrfs_file_extent_item *fi;
4032         struct extent_buffer *leaf;
4033         struct btrfs_map_token token;
4034         struct btrfs_key key;
4035         u64 extent_offset = em->start - em->orig_start;
4036         u64 block_len;
4037         int ret;
4038         int extent_inserted = 0;
4039         bool ordered_io_err = false;
4040
4041         ret = wait_ordered_extents(trans, inode, root, em, logged_list,
4042                                    &ordered_io_err);
4043         if (ret)
4044                 return ret;
4045
4046         if (ordered_io_err) {
4047                 ctx->io_err = -EIO;
4048                 return 0;
4049         }
4050
4051         btrfs_init_map_token(&token);
4052
4053         ret = __btrfs_drop_extents(trans, log, inode, path, em->start,
4054                                    em->start + em->len, NULL, 0, 1,
4055                                    sizeof(*fi), &extent_inserted);
4056         if (ret)
4057                 return ret;
4058
4059         if (!extent_inserted) {
4060                 key.objectid = btrfs_ino(inode);
4061                 key.type = BTRFS_EXTENT_DATA_KEY;
4062                 key.offset = em->start;
4063
4064                 ret = btrfs_insert_empty_item(trans, log, path, &key,
4065                                               sizeof(*fi));
4066                 if (ret)
4067                         return ret;
4068         }
4069         leaf = path->nodes[0];
4070         fi = btrfs_item_ptr(leaf, path->slots[0],
4071                             struct btrfs_file_extent_item);
4072
4073         btrfs_set_token_file_extent_generation(leaf, fi, trans->transid,
4074                                                &token);
4075         if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
4076                 btrfs_set_token_file_extent_type(leaf, fi,
4077                                                  BTRFS_FILE_EXTENT_PREALLOC,
4078                                                  &token);
4079         else
4080                 btrfs_set_token_file_extent_type(leaf, fi,
4081                                                  BTRFS_FILE_EXTENT_REG,
4082                                                  &token);
4083
4084         block_len = max(em->block_len, em->orig_block_len);
4085         if (em->compress_type != BTRFS_COMPRESS_NONE) {
4086                 btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
4087                                                         em->block_start,
4088                                                         &token);
4089                 btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
4090                                                            &token);
4091         } else if (em->block_start < EXTENT_MAP_LAST_BYTE) {
4092                 btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
4093                                                         em->block_start -
4094                                                         extent_offset, &token);
4095                 btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
4096                                                            &token);
4097         } else {
4098                 btrfs_set_token_file_extent_disk_bytenr(leaf, fi, 0, &token);
4099                 btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, 0,
4100                                                            &token);
4101         }
4102
4103         btrfs_set_token_file_extent_offset(leaf, fi, extent_offset, &token);
4104         btrfs_set_token_file_extent_num_bytes(leaf, fi, em->len, &token);
4105         btrfs_set_token_file_extent_ram_bytes(leaf, fi, em->ram_bytes, &token);
4106         btrfs_set_token_file_extent_compression(leaf, fi, em->compress_type,
4107                                                 &token);
4108         btrfs_set_token_file_extent_encryption(leaf, fi, 0, &token);
4109         btrfs_set_token_file_extent_other_encoding(leaf, fi, 0, &token);
4110         btrfs_mark_buffer_dirty(leaf);
4111
4112         btrfs_release_path(path);
4113
4114         return ret;
4115 }
4116
4117 static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
4118                                      struct btrfs_root *root,
4119                                      struct inode *inode,
4120                                      struct btrfs_path *path,
4121                                      struct list_head *logged_list,
4122                                      struct btrfs_log_ctx *ctx)
4123 {
4124         struct extent_map *em, *n;
4125         struct list_head extents;
4126         struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
4127         u64 test_gen;
4128         int ret = 0;
4129         int num = 0;
4130
4131         INIT_LIST_HEAD(&extents);
4132
4133         write_lock(&tree->lock);
4134         test_gen = root->fs_info->last_trans_committed;
4135
4136         list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
4137                 list_del_init(&em->list);
4138
4139                 /*
4140                  * Just an arbitrary number, this can be really CPU intensive
4141                  * once we start getting a lot of extents, and really once we
4142                  * have a bunch of extents we just want to commit since it will
4143                  * be faster.
4144                  */
4145                 if (++num > 32768) {
4146                         list_del_init(&tree->modified_extents);
4147                         ret = -EFBIG;
4148                         goto process;
4149                 }
4150
4151                 if (em->generation <= test_gen)
4152                         continue;
4153                 /* Need a ref to keep it from getting evicted from cache */
4154                 atomic_inc(&em->refs);
4155                 set_bit(EXTENT_FLAG_LOGGING, &em->flags);
4156                 list_add_tail(&em->list, &extents);
4157                 num++;
4158         }
4159
4160         list_sort(NULL, &extents, extent_cmp);
4161
4162 process:
4163         while (!list_empty(&extents)) {
4164                 em = list_entry(extents.next, struct extent_map, list);
4165
4166                 list_del_init(&em->list);
4167
4168                 /*
4169                  * If we had an error we just need to delete everybody from our
4170                  * private list.
4171                  */
4172                 if (ret) {
4173                         clear_em_logging(tree, em);
4174                         free_extent_map(em);
4175                         continue;
4176                 }
4177
4178                 write_unlock(&tree->lock);
4179
4180                 ret = log_one_extent(trans, inode, root, em, path, logged_list,
4181                                      ctx);
4182                 write_lock(&tree->lock);
4183                 clear_em_logging(tree, em);
4184                 free_extent_map(em);
4185         }
4186         WARN_ON(!list_empty(&extents));
4187         write_unlock(&tree->lock);
4188
4189         btrfs_release_path(path);
4190         return ret;
4191 }
4192
4193 static int logged_inode_size(struct btrfs_root *log, struct inode *inode,
4194                              struct btrfs_path *path, u64 *size_ret)
4195 {
4196         struct btrfs_key key;
4197         int ret;
4198
4199         key.objectid = btrfs_ino(inode);
4200         key.type = BTRFS_INODE_ITEM_KEY;
4201         key.offset = 0;
4202
4203         ret = btrfs_search_slot(NULL, log, &key, path, 0, 0);
4204         if (ret < 0) {
4205                 return ret;
4206         } else if (ret > 0) {
4207                 *size_ret = 0;
4208         } else {
4209                 struct btrfs_inode_item *item;
4210
4211                 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
4212                                       struct btrfs_inode_item);
4213                 *size_ret = btrfs_inode_size(path->nodes[0], item);
4214         }
4215
4216         btrfs_release_path(path);
4217         return 0;
4218 }
4219
4220 /*
4221  * At the moment we always log all xattrs. This is to figure out at log replay
4222  * time which xattrs must have their deletion replayed. If a xattr is missing
4223  * in the log tree and exists in the fs/subvol tree, we delete it. This is
4224  * because if a xattr is deleted, the inode is fsynced and a power failure
4225  * happens, causing the log to be replayed the next time the fs is mounted,
4226  * we want the xattr to not exist anymore (same behaviour as other filesystems
4227  * with a journal, ext3/4, xfs, f2fs, etc).
4228  */
4229 static int btrfs_log_all_xattrs(struct btrfs_trans_handle *trans,
4230                                 struct btrfs_root *root,
4231                                 struct inode *inode,
4232                                 struct btrfs_path *path,
4233                                 struct btrfs_path *dst_path)
4234 {
4235         int ret;
4236         struct btrfs_key key;
4237         const u64 ino = btrfs_ino(inode);
4238         int ins_nr = 0;
4239         int start_slot = 0;
4240
4241         key.objectid = ino;
4242         key.type = BTRFS_XATTR_ITEM_KEY;
4243         key.offset = 0;
4244
4245         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4246         if (ret < 0)
4247                 return ret;
4248
4249         while (true) {
4250                 int slot = path->slots[0];
4251                 struct extent_buffer *leaf = path->nodes[0];
4252                 int nritems = btrfs_header_nritems(leaf);
4253
4254                 if (slot >= nritems) {
4255                         if (ins_nr > 0) {
4256                                 u64 last_extent = 0;
4257
4258                                 ret = copy_items(trans, inode, dst_path, path,
4259                                                  &last_extent, start_slot,
4260                                                  ins_nr, 1, 0);
4261                                 /* can't be 1, extent items aren't processed */
4262                                 ASSERT(ret <= 0);
4263                                 if (ret < 0)
4264                                         return ret;
4265                                 ins_nr = 0;
4266                         }
4267                         ret = btrfs_next_leaf(root, path);
4268                         if (ret < 0)
4269                                 return ret;
4270                         else if (ret > 0)
4271                                 break;
4272                         continue;
4273                 }
4274
4275                 btrfs_item_key_to_cpu(leaf, &key, slot);
4276                 if (key.objectid != ino || key.type != BTRFS_XATTR_ITEM_KEY)
4277                         break;
4278
4279                 if (ins_nr == 0)
4280                         start_slot = slot;
4281                 ins_nr++;
4282                 path->slots[0]++;
4283                 cond_resched();
4284         }
4285         if (ins_nr > 0) {
4286                 u64 last_extent = 0;
4287
4288                 ret = copy_items(trans, inode, dst_path, path,
4289                                  &last_extent, start_slot,
4290                                  ins_nr, 1, 0);
4291                 /* can't be 1, extent items aren't processed */
4292                 ASSERT(ret <= 0);
4293                 if (ret < 0)
4294                         return ret;
4295         }
4296
4297         return 0;
4298 }
4299
4300 /*
4301  * If the no holes feature is enabled we need to make sure any hole between the
4302  * last extent and the i_size of our inode is explicitly marked in the log. This
4303  * is to make sure that doing something like:
4304  *
4305  *      1) create file with 128Kb of data
4306  *      2) truncate file to 64Kb
4307  *      3) truncate file to 256Kb
4308  *      4) fsync file
4309  *      5) <crash/power failure>
4310  *      6) mount fs and trigger log replay
4311  *
4312  * Will give us a file with a size of 256Kb, the first 64Kb of data match what
4313  * the file had in its first 64Kb of data at step 1 and the last 192Kb of the
4314  * file correspond to a hole. The presence of explicit holes in a log tree is
4315  * what guarantees that log replay will remove/adjust file extent items in the
4316  * fs/subvol tree.
4317  *
4318  * Here we do not need to care about holes between extents, that is already done
4319  * by copy_items(). We also only need to do this in the full sync path, where we
4320  * lookup for extents from the fs/subvol tree only. In the fast path case, we
4321  * lookup the list of modified extent maps and if any represents a hole, we
4322  * insert a corresponding extent representing a hole in the log tree.
4323  */
4324 static int btrfs_log_trailing_hole(struct btrfs_trans_handle *trans,
4325                                    struct btrfs_root *root,
4326                                    struct inode *inode,
4327                                    struct btrfs_path *path)
4328 {
4329         int ret;
4330         struct btrfs_key key;
4331         u64 hole_start;
4332         u64 hole_size;
4333         struct extent_buffer *leaf;
4334         struct btrfs_root *log = root->log_root;
4335         const u64 ino = btrfs_ino(inode);
4336         const u64 i_size = i_size_read(inode);
4337
4338         if (!btrfs_fs_incompat(root->fs_info, NO_HOLES))
4339                 return 0;
4340
4341         key.objectid = ino;
4342         key.type = BTRFS_EXTENT_DATA_KEY;
4343         key.offset = (u64)-1;
4344
4345         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
4346         ASSERT(ret != 0);
4347         if (ret < 0)
4348                 return ret;
4349
4350         ASSERT(path->slots[0] > 0);
4351         path->slots[0]--;
4352         leaf = path->nodes[0];
4353         btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
4354
4355         if (key.objectid != ino || key.type != BTRFS_EXTENT_DATA_KEY) {
4356                 /* inode does not have any extents */
4357                 hole_start = 0;
4358                 hole_size = i_size;
4359         } else {
4360                 struct btrfs_file_extent_item *extent;
4361                 u64 len;
4362
4363                 /*
4364                  * If there's an extent beyond i_size, an explicit hole was
4365                  * already inserted by copy_items().
4366                  */
4367                 if (key.offset >= i_size)
4368                         return 0;
4369
4370                 extent = btrfs_item_ptr(leaf, path->slots[0],
4371                                         struct btrfs_file_extent_item);
4372
4373                 if (btrfs_file_extent_type(leaf, extent) ==
4374                     BTRFS_FILE_EXTENT_INLINE) {
4375                         len = btrfs_file_extent_inline_len(leaf,
4376                                                            path->slots[0],
4377                                                            extent);
4378                         ASSERT(len == i_size);
4379                         return 0;
4380                 }
4381
4382                 len = btrfs_file_extent_num_bytes(leaf, extent);
4383                 /* Last extent goes beyond i_size, no need to log a hole. */
4384                 if (key.offset + len > i_size)
4385                         return 0;
4386                 hole_start = key.offset + len;
4387                 hole_size = i_size - hole_start;
4388         }
4389         btrfs_release_path(path);
4390
4391         /* Last extent ends at i_size. */
4392         if (hole_size == 0)
4393                 return 0;
4394
4395         hole_size = ALIGN(hole_size, root->sectorsize);
4396         ret = btrfs_insert_file_extent(trans, log, ino, hole_start, 0, 0,
4397                                        hole_size, 0, hole_size, 0, 0, 0);
4398         return ret;
4399 }
4400
4401 /*
4402  * When we are logging a new inode X, check if it doesn't have a reference that
4403  * matches the reference from some other inode Y created in a past transaction
4404  * and that was renamed in the current transaction. If we don't do this, then at
4405  * log replay time we can lose inode Y (and all its files if it's a directory):
4406  *
4407  * mkdir /mnt/x
4408  * echo "hello world" > /mnt/x/foobar
4409  * sync
4410  * mv /mnt/x /mnt/y
4411  * mkdir /mnt/x                 # or touch /mnt/x
4412  * xfs_io -c fsync /mnt/x
4413  * <power fail>
4414  * mount fs, trigger log replay
4415  *
4416  * After the log replay procedure, we would lose the first directory and all its
4417  * files (file foobar).
4418  * For the case where inode Y is not a directory we simply end up losing it:
4419  *
4420  * echo "123" > /mnt/foo
4421  * sync
4422  * mv /mnt/foo /mnt/bar
4423  * echo "abc" > /mnt/foo
4424  * xfs_io -c fsync /mnt/foo
4425  * <power fail>
4426  *
4427  * We also need this for cases where a snapshot entry is replaced by some other
4428  * entry (file or directory) otherwise we end up with an unreplayable log due to
4429  * attempts to delete the snapshot entry (entry of type BTRFS_ROOT_ITEM_KEY) as
4430  * if it were a regular entry:
4431  *
4432  * mkdir /mnt/x
4433  * btrfs subvolume snapshot /mnt /mnt/x/snap
4434  * btrfs subvolume delete /mnt/x/snap
4435  * rmdir /mnt/x
4436  * mkdir /mnt/x
4437  * fsync /mnt/x or fsync some new file inside it
4438  * <power fail>
4439  *
4440  * The snapshot delete, rmdir of x, mkdir of a new x and the fsync all happen in
4441  * the same transaction.
4442  */
4443 static int btrfs_check_ref_name_override(struct extent_buffer *eb,
4444                                          const int slot,
4445                                          const struct btrfs_key *key,
4446                                          struct inode *inode)
4447 {
4448         int ret;
4449         struct btrfs_path *search_path;
4450         char *name = NULL;
4451         u32 name_len = 0;
4452         u32 item_size = btrfs_item_size_nr(eb, slot);
4453         u32 cur_offset = 0;
4454         unsigned long ptr = btrfs_item_ptr_offset(eb, slot);
4455
4456         search_path = btrfs_alloc_path();
4457         if (!search_path)
4458                 return -ENOMEM;
4459         search_path->search_commit_root = 1;
4460         search_path->skip_locking = 1;
4461
4462         while (cur_offset < item_size) {
4463                 u64 parent;
4464                 u32 this_name_len;
4465                 u32 this_len;
4466                 unsigned long name_ptr;
4467                 struct btrfs_dir_item *di;
4468
4469                 if (key->type == BTRFS_INODE_REF_KEY) {
4470                         struct btrfs_inode_ref *iref;
4471
4472                         iref = (struct btrfs_inode_ref *)(ptr + cur_offset);
4473                         parent = key->offset;
4474                         this_name_len = btrfs_inode_ref_name_len(eb, iref);
4475                         name_ptr = (unsigned long)(iref + 1);
4476                         this_len = sizeof(*iref) + this_name_len;
4477                 } else {
4478                         struct btrfs_inode_extref *extref;
4479
4480                         extref = (struct btrfs_inode_extref *)(ptr +
4481                                                                cur_offset);
4482                         parent = btrfs_inode_extref_parent(eb, extref);
4483                         this_name_len = btrfs_inode_extref_name_len(eb, extref);
4484                         name_ptr = (unsigned long)&extref->name;
4485                         this_len = sizeof(*extref) + this_name_len;
4486                 }
4487
4488                 if (this_name_len > name_len) {
4489                         char *new_name;
4490
4491                         new_name = krealloc(name, this_name_len, GFP_NOFS);
4492                         if (!new_name) {
4493                                 ret = -ENOMEM;
4494                                 goto out;
4495                         }
4496                         name_len = this_name_len;
4497                         name = new_name;
4498                 }
4499
4500                 read_extent_buffer(eb, name, name_ptr, this_name_len);
4501                 di = btrfs_lookup_dir_item(NULL, BTRFS_I(inode)->root,
4502                                            search_path, parent,
4503                                            name, this_name_len, 0);
4504                 if (di && !IS_ERR(di)) {
4505                         ret = 1;
4506                         goto out;
4507                 } else if (IS_ERR(di)) {
4508                         ret = PTR_ERR(di);
4509                         goto out;
4510                 }
4511                 btrfs_release_path(search_path);
4512
4513                 cur_offset += this_len;
4514         }
4515         ret = 0;
4516 out:
4517         btrfs_free_path(search_path);
4518         kfree(name);
4519         return ret;
4520 }
4521
4522 /* log a single inode in the tree log.
4523  * At least one parent directory for this inode must exist in the tree
4524  * or be logged already.
4525  *
4526  * Any items from this inode changed by the current transaction are copied
4527  * to the log tree.  An extra reference is taken on any extents in this
4528  * file, allowing us to avoid a whole pile of corner cases around logging
4529  * blocks that have been removed from the tree.
4530  *
4531  * See LOG_INODE_ALL and related defines for a description of what inode_only
4532  * does.
4533  *
4534  * This handles both files and directories.
4535  */
4536 static int btrfs_log_inode(struct btrfs_trans_handle *trans,
4537                            struct btrfs_root *root, struct inode *inode,
4538                            int inode_only,
4539                            const loff_t start,
4540                            const loff_t end,
4541                            struct btrfs_log_ctx *ctx)
4542 {
4543         struct btrfs_path *path;
4544         struct btrfs_path *dst_path;
4545         struct btrfs_key min_key;
4546         struct btrfs_key max_key;
4547         struct btrfs_root *log = root->log_root;
4548         struct extent_buffer *src = NULL;
4549         LIST_HEAD(logged_list);
4550         u64 last_extent = 0;
4551         int err = 0;
4552         int ret;
4553         int nritems;
4554         int ins_start_slot = 0;
4555         int ins_nr;
4556         bool fast_search = false;
4557         u64 ino = btrfs_ino(inode);
4558         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
4559         u64 logged_isize = 0;
4560         bool need_log_inode_item = true;
4561
4562         path = btrfs_alloc_path();
4563         if (!path)
4564                 return -ENOMEM;
4565         dst_path = btrfs_alloc_path();
4566         if (!dst_path) {
4567                 btrfs_free_path(path);
4568                 return -ENOMEM;
4569         }
4570
4571         min_key.objectid = ino;
4572         min_key.type = BTRFS_INODE_ITEM_KEY;
4573         min_key.offset = 0;
4574
4575         max_key.objectid = ino;
4576
4577
4578         /* today the code can only do partial logging of directories */
4579         if (S_ISDIR(inode->i_mode) ||
4580             (!test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
4581                        &BTRFS_I(inode)->runtime_flags) &&
4582              inode_only == LOG_INODE_EXISTS))
4583                 max_key.type = BTRFS_XATTR_ITEM_KEY;
4584         else
4585                 max_key.type = (u8)-1;
4586         max_key.offset = (u64)-1;
4587
4588         /*
4589          * Only run delayed items if we are a dir or a new file.
4590          * Otherwise commit the delayed inode only, which is needed in
4591          * order for the log replay code to mark inodes for link count
4592          * fixup (create temporary BTRFS_TREE_LOG_FIXUP_OBJECTID items).
4593          */
4594         if (S_ISDIR(inode->i_mode) ||
4595             BTRFS_I(inode)->generation > root->fs_info->last_trans_committed)
4596                 ret = btrfs_commit_inode_delayed_items(trans, inode);
4597         else
4598                 ret = btrfs_commit_inode_delayed_inode(inode);
4599
4600         if (ret) {
4601                 btrfs_free_path(path);
4602                 btrfs_free_path(dst_path);
4603                 return ret;
4604         }
4605
4606         mutex_lock(&BTRFS_I(inode)->log_mutex);
4607
4608         btrfs_get_logged_extents(inode, &logged_list, start, end);
4609
4610         /*
4611          * a brute force approach to making sure we get the most uptodate
4612          * copies of everything.
4613          */
4614         if (S_ISDIR(inode->i_mode)) {
4615                 int max_key_type = BTRFS_DIR_LOG_INDEX_KEY;
4616
4617                 if (inode_only == LOG_INODE_EXISTS)
4618                         max_key_type = BTRFS_XATTR_ITEM_KEY;
4619                 ret = drop_objectid_items(trans, log, path, ino, max_key_type);
4620         } else {
4621                 if (inode_only == LOG_INODE_EXISTS) {
4622                         /*
4623                          * Make sure the new inode item we write to the log has
4624                          * the same isize as the current one (if it exists).
4625                          * This is necessary to prevent data loss after log
4626                          * replay, and also to prevent doing a wrong expanding
4627                          * truncate - for e.g. create file, write 4K into offset
4628                          * 0, fsync, write 4K into offset 4096, add hard link,
4629                          * fsync some other file (to sync log), power fail - if
4630                          * we use the inode's current i_size, after log replay
4631                          * we get a 8Kb file, with the last 4Kb extent as a hole
4632                          * (zeroes), as if an expanding truncate happened,
4633                          * instead of getting a file of 4Kb only.
4634                          */
4635                         err = logged_inode_size(log, inode, path,
4636                                                 &logged_isize);
4637                         if (err)
4638                                 goto out_unlock;
4639                 }
4640                 if (test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
4641                              &BTRFS_I(inode)->runtime_flags)) {
4642                         if (inode_only == LOG_INODE_EXISTS) {
4643                                 max_key.type = BTRFS_XATTR_ITEM_KEY;
4644                                 ret = drop_objectid_items(trans, log, path, ino,
4645                                                           max_key.type);
4646                         } else {
4647                                 clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
4648                                           &BTRFS_I(inode)->runtime_flags);
4649                                 clear_bit(BTRFS_INODE_COPY_EVERYTHING,
4650                                           &BTRFS_I(inode)->runtime_flags);
4651                                 while(1) {
4652                                         ret = btrfs_truncate_inode_items(trans,
4653                                                          log, inode, 0, 0);
4654                                         if (ret != -EAGAIN)
4655                                                 break;
4656                                 }
4657                         }
4658                 } else if (test_and_clear_bit(BTRFS_INODE_COPY_EVERYTHING,
4659                                               &BTRFS_I(inode)->runtime_flags) ||
4660                            inode_only == LOG_INODE_EXISTS) {
4661                         if (inode_only == LOG_INODE_ALL)
4662                                 fast_search = true;
4663                         max_key.type = BTRFS_XATTR_ITEM_KEY;
4664                         ret = drop_objectid_items(trans, log, path, ino,
4665                                                   max_key.type);
4666                 } else {
4667                         if (inode_only == LOG_INODE_ALL)
4668                                 fast_search = true;
4669                         goto log_extents;
4670                 }
4671
4672         }
4673         if (ret) {
4674                 err = ret;
4675                 goto out_unlock;
4676         }
4677
4678         while (1) {
4679                 ins_nr = 0;
4680                 ret = btrfs_search_forward(root, &min_key,
4681                                            path, trans->transid);
4682                 if (ret != 0)
4683                         break;
4684 again:
4685                 /* note, ins_nr might be > 0 here, cleanup outside the loop */
4686                 if (min_key.objectid != ino)
4687                         break;
4688                 if (min_key.type > max_key.type)
4689                         break;
4690
4691                 if (min_key.type == BTRFS_INODE_ITEM_KEY)
4692                         need_log_inode_item = false;
4693
4694                 if ((min_key.type == BTRFS_INODE_REF_KEY ||
4695                      min_key.type == BTRFS_INODE_EXTREF_KEY) &&
4696                     BTRFS_I(inode)->generation == trans->transid) {
4697                         ret = btrfs_check_ref_name_override(path->nodes[0],
4698                                                             path->slots[0],
4699                                                             &min_key, inode);
4700                         if (ret < 0) {
4701                                 err = ret;
4702                                 goto out_unlock;
4703                         } else if (ret > 0) {
4704                                 err = 1;
4705                                 btrfs_set_log_full_commit(root->fs_info, trans);
4706                                 goto out_unlock;
4707                         }
4708                 }
4709
4710                 /* Skip xattrs, we log them later with btrfs_log_all_xattrs() */
4711                 if (min_key.type == BTRFS_XATTR_ITEM_KEY) {
4712                         if (ins_nr == 0)
4713                                 goto next_slot;
4714                         ret = copy_items(trans, inode, dst_path, path,
4715                                          &last_extent, ins_start_slot,
4716                                          ins_nr, inode_only, logged_isize);
4717                         if (ret < 0) {
4718                                 err = ret;
4719                                 goto out_unlock;
4720                         }
4721                         ins_nr = 0;
4722                         if (ret) {
4723                                 btrfs_release_path(path);
4724                                 continue;
4725                         }
4726                         goto next_slot;
4727                 }
4728
4729                 src = path->nodes[0];
4730                 if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) {
4731                         ins_nr++;
4732                         goto next_slot;
4733                 } else if (!ins_nr) {
4734                         ins_start_slot = path->slots[0];
4735                         ins_nr = 1;
4736                         goto next_slot;
4737                 }
4738
4739                 ret = copy_items(trans, inode, dst_path, path, &last_extent,
4740                                  ins_start_slot, ins_nr, inode_only,
4741                                  logged_isize);
4742                 if (ret < 0) {
4743                         err = ret;
4744                         goto out_unlock;
4745                 }
4746                 if (ret) {
4747                         ins_nr = 0;
4748                         btrfs_release_path(path);
4749                         continue;
4750                 }
4751                 ins_nr = 1;
4752                 ins_start_slot = path->slots[0];
4753 next_slot:
4754
4755                 nritems = btrfs_header_nritems(path->nodes[0]);
4756                 path->slots[0]++;
4757                 if (path->slots[0] < nritems) {
4758                         btrfs_item_key_to_cpu(path->nodes[0], &min_key,
4759                                               path->slots[0]);
4760                         goto again;
4761                 }
4762                 if (ins_nr) {
4763                         ret = copy_items(trans, inode, dst_path, path,
4764                                          &last_extent, ins_start_slot,
4765                                          ins_nr, inode_only, logged_isize);
4766                         if (ret < 0) {
4767                                 err = ret;
4768                                 goto out_unlock;
4769                         }
4770                         ret = 0;
4771                         ins_nr = 0;
4772                 }
4773                 btrfs_release_path(path);
4774
4775                 if (min_key.offset < (u64)-1) {
4776                         min_key.offset++;
4777                 } else if (min_key.type < max_key.type) {
4778                         min_key.type++;
4779                         min_key.offset = 0;
4780                 } else {
4781                         break;
4782                 }
4783         }
4784         if (ins_nr) {
4785                 ret = copy_items(trans, inode, dst_path, path, &last_extent,
4786                                  ins_start_slot, ins_nr, inode_only,
4787                                  logged_isize);
4788                 if (ret < 0) {
4789                         err = ret;
4790                         goto out_unlock;
4791                 }
4792                 ret = 0;
4793                 ins_nr = 0;
4794         }
4795
4796         btrfs_release_path(path);
4797         btrfs_release_path(dst_path);
4798         err = btrfs_log_all_xattrs(trans, root, inode, path, dst_path);
4799         if (err)
4800                 goto out_unlock;
4801         if (max_key.type >= BTRFS_EXTENT_DATA_KEY && !fast_search) {
4802                 btrfs_release_path(path);
4803                 btrfs_release_path(dst_path);
4804                 err = btrfs_log_trailing_hole(trans, root, inode, path);
4805                 if (err)
4806                         goto out_unlock;
4807         }
4808 log_extents:
4809         btrfs_release_path(path);
4810         btrfs_release_path(dst_path);
4811         if (need_log_inode_item) {
4812                 err = log_inode_item(trans, log, dst_path, inode);
4813                 if (err)
4814                         goto out_unlock;
4815         }
4816         if (fast_search) {
4817                 /*
4818                  * Some ordered extents started by fsync might have completed
4819                  * before we collected the ordered extents in logged_list, which
4820                  * means they're gone, not in our logged_list nor in the inode's
4821                  * ordered tree. We want the application/user space to know an
4822                  * error happened while attempting to persist file data so that
4823                  * it can take proper action. If such error happened, we leave
4824                  * without writing to the log tree and the fsync must report the
4825                  * file data write error and not commit the current transaction.
4826                  */
4827                 err = btrfs_inode_check_errors(inode);
4828                 if (err) {
4829                         ctx->io_err = err;
4830                         goto out_unlock;
4831                 }
4832                 ret = btrfs_log_changed_extents(trans, root, inode, dst_path,
4833                                                 &logged_list, ctx);
4834                 if (ret) {
4835                         err = ret;
4836                         goto out_unlock;
4837                 }
4838         } else if (inode_only == LOG_INODE_ALL) {
4839                 struct extent_map *em, *n;
4840
4841                 write_lock(&em_tree->lock);
4842                 /*
4843                  * We can't just remove every em if we're called for a ranged
4844                  * fsync - that is, one that doesn't cover the whole possible
4845                  * file range (0 to LLONG_MAX). This is because we can have
4846                  * em's that fall outside the range we're logging and therefore
4847                  * their ordered operations haven't completed yet
4848                  * (btrfs_finish_ordered_io() not invoked yet). This means we
4849                  * didn't get their respective file extent item in the fs/subvol
4850                  * tree yet, and need to let the next fast fsync (one which
4851                  * consults the list of modified extent maps) find the em so
4852                  * that it logs a matching file extent item and waits for the
4853                  * respective ordered operation to complete (if it's still
4854                  * running).
4855                  *
4856                  * Removing every em outside the range we're logging would make
4857                  * the next fast fsync not log their matching file extent items,
4858                  * therefore making us lose data after a log replay.
4859                  */
4860                 list_for_each_entry_safe(em, n, &em_tree->modified_extents,
4861                                          list) {
4862                         const u64 mod_end = em->mod_start + em->mod_len - 1;
4863
4864                         if (em->mod_start >= start && mod_end <= end)
4865                                 list_del_init(&em->list);
4866                 }
4867                 write_unlock(&em_tree->lock);
4868         }
4869
4870         if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
4871                 ret = log_directory_changes(trans, root, inode, path, dst_path,
4872                                             ctx);
4873                 if (ret) {
4874                         err = ret;
4875                         goto out_unlock;
4876                 }
4877         }
4878
4879         spin_lock(&BTRFS_I(inode)->lock);
4880         BTRFS_I(inode)->logged_trans = trans->transid;
4881         BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->last_sub_trans;
4882         spin_unlock(&BTRFS_I(inode)->lock);
4883 out_unlock:
4884         if (unlikely(err))
4885                 btrfs_put_logged_extents(&logged_list);
4886         else
4887                 btrfs_submit_logged_extents(&logged_list, log);
4888         mutex_unlock(&BTRFS_I(inode)->log_mutex);
4889
4890         btrfs_free_path(path);
4891         btrfs_free_path(dst_path);
4892         return err;
4893 }
4894
4895 /*
4896  * follow the dentry parent pointers up the chain and see if any
4897  * of the directories in it require a full commit before they can
4898  * be logged.  Returns zero if nothing special needs to be done or 1 if
4899  * a full commit is required.
4900  */
4901 static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
4902                                                struct inode *inode,
4903                                                struct dentry *parent,
4904                                                struct super_block *sb,
4905                                                u64 last_committed)
4906 {
4907         int ret = 0;
4908         struct btrfs_root *root;
4909         struct dentry *old_parent = NULL;
4910         struct inode *orig_inode = inode;
4911
4912         /*
4913          * for regular files, if its inode is already on disk, we don't
4914          * have to worry about the parents at all.  This is because
4915          * we can use the last_unlink_trans field to record renames
4916          * and other fun in this file.
4917          */
4918         if (S_ISREG(inode->i_mode) &&
4919             BTRFS_I(inode)->generation <= last_committed &&
4920             BTRFS_I(inode)->last_unlink_trans <= last_committed)
4921                         goto out;
4922
4923         if (!S_ISDIR(inode->i_mode)) {
4924                 if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
4925                         goto out;
4926                 inode = d_inode(parent);
4927         }
4928
4929         while (1) {
4930                 /*
4931                  * If we are logging a directory then we start with our inode,
4932                  * not our parents inode, so we need to skipp setting the
4933                  * logged_trans so that further down in the log code we don't
4934                  * think this inode has already been logged.
4935                  */
4936                 if (inode != orig_inode)
4937                         BTRFS_I(inode)->logged_trans = trans->transid;
4938                 smp_mb();
4939
4940                 if (BTRFS_I(inode)->last_unlink_trans > last_committed) {
4941                         root = BTRFS_I(inode)->root;
4942
4943                         /*
4944                          * make sure any commits to the log are forced
4945                          * to be full commits
4946                          */
4947                         btrfs_set_log_full_commit(root->fs_info, trans);
4948                         ret = 1;
4949                         break;
4950                 }
4951
4952                 if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
4953                         break;
4954
4955                 if (IS_ROOT(parent))
4956                         break;
4957
4958                 parent = dget_parent(parent);
4959                 dput(old_parent);
4960                 old_parent = parent;
4961                 inode = d_inode(parent);
4962
4963         }
4964         dput(old_parent);
4965 out:
4966         return ret;
4967 }
4968
4969 struct btrfs_dir_list {
4970         u64 ino;
4971         struct list_head list;
4972 };
4973
4974 /*
4975  * Log the inodes of the new dentries of a directory. See log_dir_items() for
4976  * details about the why it is needed.
4977  * This is a recursive operation - if an existing dentry corresponds to a
4978  * directory, that directory's new entries are logged too (same behaviour as
4979  * ext3/4, xfs, f2fs, reiserfs, nilfs2). Note that when logging the inodes
4980  * the dentries point to we do not lock their i_mutex, otherwise lockdep
4981  * complains about the following circular lock dependency / possible deadlock:
4982  *
4983  *        CPU0                                        CPU1
4984  *        ----                                        ----
4985  * lock(&type->i_mutex_dir_key#3/2);
4986  *                                            lock(sb_internal#2);
4987  *                                            lock(&type->i_mutex_dir_key#3/2);
4988  * lock(&sb->s_type->i_mutex_key#14);
4989  *
4990  * Where sb_internal is the lock (a counter that works as a lock) acquired by
4991  * sb_start_intwrite() in btrfs_start_transaction().
4992  * Not locking i_mutex of the inodes is still safe because:
4993  *
4994  * 1) For regular files we log with a mode of LOG_INODE_EXISTS. It's possible
4995  *    that while logging the inode new references (names) are added or removed
4996  *    from the inode, leaving the logged inode item with a link count that does
4997  *    not match the number of logged inode reference items. This is fine because
4998  *    at log replay time we compute the real number of links and correct the
4999  *    link count in the inode item (see replay_one_buffer() and
5000  *    link_to_fixup_dir());
5001  *
5002  * 2) For directories we log with a mode of LOG_INODE_ALL. It's possible that
5003  *    while logging the inode's items new items with keys BTRFS_DIR_ITEM_KEY and
5004  *    BTRFS_DIR_INDEX_KEY are added to fs/subvol tree and the logged inode item
5005  *    has a size that doesn't match the sum of the lengths of all the logged
5006  *    names. This does not result in a problem because if a dir_item key is
5007  *    logged but its matching dir_index key is not logged, at log replay time we
5008  *    don't use it to replay the respective name (see replay_one_name()). On the
5009  *    other hand if only the dir_index key ends up being logged, the respective
5010  *    name is added to the fs/subvol tree with both the dir_item and dir_index
5011  *    keys created (see replay_one_name()).
5012  *    The directory's inode item with a wrong i_size is not a problem as well,
5013  *    since we don't use it at log replay time to set the i_size in the inode
5014  *    item of the fs/subvol tree (see overwrite_item()).
5015  */
5016 static int log_new_dir_dentries(struct btrfs_trans_handle *trans,
5017                                 struct btrfs_root *root,
5018                                 struct inode *start_inode,
5019                                 struct btrfs_log_ctx *ctx)
5020 {
5021         struct btrfs_root *log = root->log_root;
5022         struct btrfs_path *path;
5023         LIST_HEAD(dir_list);
5024         struct btrfs_dir_list *dir_elem;
5025         int ret = 0;
5026
5027         path = btrfs_alloc_path();
5028         if (!path)
5029                 return -ENOMEM;
5030
5031         dir_elem = kmalloc(sizeof(*dir_elem), GFP_NOFS);
5032         if (!dir_elem) {
5033                 btrfs_free_path(path);
5034                 return -ENOMEM;
5035         }
5036         dir_elem->ino = btrfs_ino(start_inode);
5037         list_add_tail(&dir_elem->list, &dir_list);
5038
5039         while (!list_empty(&dir_list)) {
5040                 struct extent_buffer *leaf;
5041                 struct btrfs_key min_key;
5042                 int nritems;
5043                 int i;
5044
5045                 dir_elem = list_first_entry(&dir_list, struct btrfs_dir_list,
5046                                             list);
5047                 if (ret)
5048                         goto next_dir_inode;
5049
5050                 min_key.objectid = dir_elem->ino;
5051                 min_key.type = BTRFS_DIR_ITEM_KEY;
5052                 min_key.offset = 0;
5053 again:
5054                 btrfs_release_path(path);
5055                 ret = btrfs_search_forward(log, &min_key, path, trans->transid);
5056                 if (ret < 0) {
5057                         goto next_dir_inode;
5058                 } else if (ret > 0) {
5059                         ret = 0;
5060                         goto next_dir_inode;
5061                 }
5062
5063 process_leaf:
5064                 leaf = path->nodes[0];
5065                 nritems = btrfs_header_nritems(leaf);
5066                 for (i = path->slots[0]; i < nritems; i++) {
5067                         struct btrfs_dir_item *di;
5068                         struct btrfs_key di_key;
5069                         struct inode *di_inode;
5070                         struct btrfs_dir_list *new_dir_elem;
5071                         int log_mode = LOG_INODE_EXISTS;
5072                         int type;
5073
5074                         btrfs_item_key_to_cpu(leaf, &min_key, i);
5075                         if (min_key.objectid != dir_elem->ino ||
5076                             min_key.type != BTRFS_DIR_ITEM_KEY)
5077                                 goto next_dir_inode;
5078
5079                         di = btrfs_item_ptr(leaf, i, struct btrfs_dir_item);
5080                         type = btrfs_dir_type(leaf, di);
5081                         if (btrfs_dir_transid(leaf, di) < trans->transid &&
5082                             type != BTRFS_FT_DIR)
5083                                 continue;
5084                         btrfs_dir_item_key_to_cpu(leaf, di, &di_key);
5085                         if (di_key.type == BTRFS_ROOT_ITEM_KEY)
5086                                 continue;
5087
5088                         di_inode = btrfs_iget(root->fs_info->sb, &di_key,
5089                                               root, NULL);
5090                         if (IS_ERR(di_inode)) {
5091                                 ret = PTR_ERR(di_inode);
5092                                 goto next_dir_inode;
5093                         }
5094
5095                         if (btrfs_inode_in_log(di_inode, trans->transid)) {
5096                                 iput(di_inode);
5097                                 continue;
5098                         }
5099
5100                         ctx->log_new_dentries = false;
5101                         if (type == BTRFS_FT_DIR)
5102                                 log_mode = LOG_INODE_ALL;
5103                         btrfs_release_path(path);
5104                         ret = btrfs_log_inode(trans, root, di_inode,
5105                                               log_mode, 0, LLONG_MAX, ctx);
5106                         iput(di_inode);
5107                         if (ret)
5108                                 goto next_dir_inode;
5109                         if (ctx->log_new_dentries) {
5110                                 new_dir_elem = kmalloc(sizeof(*new_dir_elem),
5111                                                        GFP_NOFS);
5112                                 if (!new_dir_elem) {
5113                                         ret = -ENOMEM;
5114                                         goto next_dir_inode;
5115                                 }
5116                                 new_dir_elem->ino = di_key.objectid;
5117                                 list_add_tail(&new_dir_elem->list, &dir_list);
5118                         }
5119                         break;
5120                 }
5121                 if (i == nritems) {
5122                         ret = btrfs_next_leaf(log, path);
5123                         if (ret < 0) {
5124                                 goto next_dir_inode;
5125                         } else if (ret > 0) {
5126                                 ret = 0;
5127                                 goto next_dir_inode;
5128                         }
5129                         goto process_leaf;
5130                 }
5131                 if (min_key.offset < (u64)-1) {
5132                         min_key.offset++;
5133                         goto again;
5134                 }
5135 next_dir_inode:
5136                 list_del(&dir_elem->list);
5137                 kfree(dir_elem);
5138         }
5139
5140         btrfs_free_path(path);
5141         return ret;
5142 }
5143
5144 static int btrfs_log_all_parents(struct btrfs_trans_handle *trans,
5145                                  struct inode *inode,
5146                                  struct btrfs_log_ctx *ctx)
5147 {
5148         int ret;
5149         struct btrfs_path *path;
5150         struct btrfs_key key;
5151         struct btrfs_root *root = BTRFS_I(inode)->root;
5152         const u64 ino = btrfs_ino(inode);
5153
5154         path = btrfs_alloc_path();
5155         if (!path)
5156                 return -ENOMEM;
5157         path->skip_locking = 1;
5158         path->search_commit_root = 1;
5159
5160         key.objectid = ino;
5161         key.type = BTRFS_INODE_REF_KEY;
5162         key.offset = 0;
5163         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5164         if (ret < 0)
5165                 goto out;
5166
5167         while (true) {
5168                 struct extent_buffer *leaf = path->nodes[0];
5169                 int slot = path->slots[0];
5170                 u32 cur_offset = 0;
5171                 u32 item_size;
5172                 unsigned long ptr;
5173
5174                 if (slot >= btrfs_header_nritems(leaf)) {
5175                         ret = btrfs_next_leaf(root, path);
5176                         if (ret < 0)
5177                                 goto out;
5178                         else if (ret > 0)
5179                                 break;
5180                         continue;
5181                 }
5182
5183                 btrfs_item_key_to_cpu(leaf, &key, slot);
5184                 /* BTRFS_INODE_EXTREF_KEY is BTRFS_INODE_REF_KEY + 1 */
5185                 if (key.objectid != ino || key.type > BTRFS_INODE_EXTREF_KEY)
5186                         break;
5187
5188                 item_size = btrfs_item_size_nr(leaf, slot);
5189                 ptr = btrfs_item_ptr_offset(leaf, slot);
5190                 while (cur_offset < item_size) {
5191                         struct btrfs_key inode_key;
5192                         struct inode *dir_inode;
5193
5194                         inode_key.type = BTRFS_INODE_ITEM_KEY;
5195                         inode_key.offset = 0;
5196
5197                         if (key.type == BTRFS_INODE_EXTREF_KEY) {
5198                                 struct btrfs_inode_extref *extref;
5199
5200                                 extref = (struct btrfs_inode_extref *)
5201                                         (ptr + cur_offset);
5202                                 inode_key.objectid = btrfs_inode_extref_parent(
5203                                         leaf, extref);
5204                                 cur_offset += sizeof(*extref);
5205                                 cur_offset += btrfs_inode_extref_name_len(leaf,
5206                                         extref);
5207                         } else {
5208                                 inode_key.objectid = key.offset;
5209                                 cur_offset = item_size;
5210                         }
5211
5212                         dir_inode = btrfs_iget(root->fs_info->sb, &inode_key,
5213                                                root, NULL);
5214                         /* If parent inode was deleted, skip it. */
5215                         if (IS_ERR(dir_inode))
5216                                 continue;
5217
5218                         ret = btrfs_log_inode(trans, root, dir_inode,
5219                                               LOG_INODE_ALL, 0, LLONG_MAX, ctx);
5220                         iput(dir_inode);
5221                         if (ret)
5222                                 goto out;
5223                 }
5224                 path->slots[0]++;
5225         }
5226         ret = 0;
5227 out:
5228         btrfs_free_path(path);
5229         return ret;
5230 }
5231
5232 /*
5233  * helper function around btrfs_log_inode to make sure newly created
5234  * parent directories also end up in the log.  A minimal inode and backref
5235  * only logging is done of any parent directories that are older than
5236  * the last committed transaction
5237  */
5238 static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
5239                                   struct btrfs_root *root, struct inode *inode,
5240                                   struct dentry *parent,
5241                                   const loff_t start,
5242                                   const loff_t end,
5243                                   int exists_only,
5244                                   struct btrfs_log_ctx *ctx)
5245 {
5246         int inode_only = exists_only ? LOG_INODE_EXISTS : LOG_INODE_ALL;
5247         struct super_block *sb;
5248         struct dentry *old_parent = NULL;
5249         int ret = 0;
5250         u64 last_committed = root->fs_info->last_trans_committed;
5251         bool log_dentries = false;
5252         struct inode *orig_inode = inode;
5253
5254         sb = inode->i_sb;
5255
5256         if (btrfs_test_opt(root, NOTREELOG)) {
5257                 ret = 1;
5258                 goto end_no_trans;
5259         }
5260
5261         /*
5262          * The prev transaction commit doesn't complete, we need do
5263          * full commit by ourselves.
5264          */
5265         if (root->fs_info->last_trans_log_full_commit >
5266             root->fs_info->last_trans_committed) {
5267                 ret = 1;
5268                 goto end_no_trans;
5269         }
5270
5271         if (root != BTRFS_I(inode)->root ||
5272             btrfs_root_refs(&root->root_item) == 0) {
5273                 ret = 1;
5274                 goto end_no_trans;
5275         }
5276
5277         ret = check_parent_dirs_for_sync(trans, inode, parent,
5278                                          sb, last_committed);
5279         if (ret)
5280                 goto end_no_trans;
5281
5282         if (btrfs_inode_in_log(inode, trans->transid)) {
5283                 ret = BTRFS_NO_LOG_SYNC;
5284                 goto end_no_trans;
5285         }
5286
5287         ret = start_log_trans(trans, root, ctx);
5288         if (ret)
5289                 goto end_no_trans;
5290
5291         ret = btrfs_log_inode(trans, root, inode, inode_only, start, end, ctx);
5292         if (ret)
5293                 goto end_trans;
5294
5295         /*
5296          * for regular files, if its inode is already on disk, we don't
5297          * have to worry about the parents at all.  This is because
5298          * we can use the last_unlink_trans field to record renames
5299          * and other fun in this file.
5300          */
5301         if (S_ISREG(inode->i_mode) &&
5302             BTRFS_I(inode)->generation <= last_committed &&
5303             BTRFS_I(inode)->last_unlink_trans <= last_committed) {
5304                 ret = 0;
5305                 goto end_trans;
5306         }
5307
5308         if (S_ISDIR(inode->i_mode) && ctx && ctx->log_new_dentries)
5309                 log_dentries = true;
5310
5311         /*
5312          * On unlink we must make sure all our current and old parent directores
5313          * inodes are fully logged. This is to prevent leaving dangling
5314          * directory index entries in directories that were our parents but are
5315          * not anymore. Not doing this results in old parent directory being
5316          * impossible to delete after log replay (rmdir will always fail with
5317          * error -ENOTEMPTY).
5318          *
5319          * Example 1:
5320          *
5321          * mkdir testdir
5322          * touch testdir/foo
5323          * ln testdir/foo testdir/bar
5324          * sync
5325          * unlink testdir/bar
5326          * xfs_io -c fsync testdir/foo
5327          * <power failure>
5328          * mount fs, triggers log replay
5329          *
5330          * If we don't log the parent directory (testdir), after log replay the
5331          * directory still has an entry pointing to the file inode using the bar
5332          * name, but a matching BTRFS_INODE_[REF|EXTREF]_KEY does not exist and
5333          * the file inode has a link count of 1.
5334          *
5335          * Example 2:
5336          *
5337          * mkdir testdir
5338          * touch foo
5339          * ln foo testdir/foo2
5340          * ln foo testdir/foo3
5341          * sync
5342          * unlink testdir/foo3
5343          * xfs_io -c fsync foo
5344          * <power failure>
5345          * mount fs, triggers log replay
5346          *
5347          * Similar as the first example, after log replay the parent directory
5348          * testdir still has an entry pointing to the inode file with name foo3
5349          * but the file inode does not have a matching BTRFS_INODE_REF_KEY item
5350          * and has a link count of 2.
5351          */
5352         if (BTRFS_I(inode)->last_unlink_trans > last_committed) {
5353                 ret = btrfs_log_all_parents(trans, orig_inode, ctx);
5354                 if (ret)
5355                         goto end_trans;
5356         }
5357
5358         while (1) {
5359                 if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb)
5360                         break;
5361
5362                 inode = d_inode(parent);
5363                 if (root != BTRFS_I(inode)->root)
5364                         break;
5365
5366                 if (BTRFS_I(inode)->generation > last_committed) {
5367                         ret = btrfs_log_inode(trans, root, inode,
5368                                               LOG_INODE_EXISTS,
5369                                               0, LLONG_MAX, ctx);
5370                         if (ret)
5371                                 goto end_trans;
5372                 }
5373                 if (IS_ROOT(parent))
5374                         break;
5375
5376                 parent = dget_parent(parent);
5377                 dput(old_parent);
5378                 old_parent = parent;
5379         }
5380         if (log_dentries)
5381                 ret = log_new_dir_dentries(trans, root, orig_inode, ctx);
5382         else
5383                 ret = 0;
5384 end_trans:
5385         dput(old_parent);
5386         if (ret < 0) {
5387                 btrfs_set_log_full_commit(root->fs_info, trans);
5388                 ret = 1;
5389         }
5390
5391         if (ret)
5392                 btrfs_remove_log_ctx(root, ctx);
5393         btrfs_end_log_trans(root);
5394 end_no_trans:
5395         return ret;
5396 }
5397
5398 /*
5399  * it is not safe to log dentry if the chunk root has added new
5400  * chunks.  This returns 0 if the dentry was logged, and 1 otherwise.
5401  * If this returns 1, you must commit the transaction to safely get your
5402  * data on disk.
5403  */
5404 int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
5405                           struct btrfs_root *root, struct dentry *dentry,
5406                           const loff_t start,
5407                           const loff_t end,
5408                           struct btrfs_log_ctx *ctx)
5409 {
5410         struct dentry *parent = dget_parent(dentry);
5411         int ret;
5412
5413         ret = btrfs_log_inode_parent(trans, root, d_inode(dentry), parent,
5414                                      start, end, 0, ctx);
5415         dput(parent);
5416
5417         return ret;
5418 }
5419
5420 /*
5421  * should be called during mount to recover any replay any log trees
5422  * from the FS
5423  */
5424 int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
5425 {
5426         int ret;
5427         struct btrfs_path *path;
5428         struct btrfs_trans_handle *trans;
5429         struct btrfs_key key;
5430         struct btrfs_key found_key;
5431         struct btrfs_key tmp_key;
5432         struct btrfs_root *log;
5433         struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
5434         struct walk_control wc = {
5435                 .process_func = process_one_buffer,
5436                 .stage = 0,
5437         };
5438
5439         path = btrfs_alloc_path();
5440         if (!path)
5441                 return -ENOMEM;
5442
5443         fs_info->log_root_recovering = 1;
5444
5445         trans = btrfs_start_transaction(fs_info->tree_root, 0);
5446         if (IS_ERR(trans)) {
5447                 ret = PTR_ERR(trans);
5448                 goto error;
5449         }
5450
5451         wc.trans = trans;
5452         wc.pin = 1;
5453
5454         ret = walk_log_tree(trans, log_root_tree, &wc);
5455         if (ret) {
5456                 btrfs_std_error(fs_info, ret, "Failed to pin buffers while "
5457                             "recovering log root tree.");
5458                 goto error;
5459         }
5460
5461 again:
5462         key.objectid = BTRFS_TREE_LOG_OBJECTID;
5463         key.offset = (u64)-1;
5464         key.type = BTRFS_ROOT_ITEM_KEY;
5465
5466         while (1) {
5467                 ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
5468
5469                 if (ret < 0) {
5470                         btrfs_std_error(fs_info, ret,
5471                                     "Couldn't find tree log root.");
5472                         goto error;
5473                 }
5474                 if (ret > 0) {
5475                         if (path->slots[0] == 0)
5476                                 break;
5477                         path->slots[0]--;
5478                 }
5479                 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
5480                                       path->slots[0]);
5481                 btrfs_release_path(path);
5482                 if (found_key.objectid != BTRFS_TREE_LOG_OBJECTID)
5483                         break;
5484
5485                 log = btrfs_read_fs_root(log_root_tree, &found_key);
5486                 if (IS_ERR(log)) {
5487                         ret = PTR_ERR(log);
5488                         btrfs_std_error(fs_info, ret,
5489                                     "Couldn't read tree log root.");
5490                         goto error;
5491                 }
5492
5493                 tmp_key.objectid = found_key.offset;
5494                 tmp_key.type = BTRFS_ROOT_ITEM_KEY;
5495                 tmp_key.offset = (u64)-1;
5496
5497                 wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key);
5498                 if (IS_ERR(wc.replay_dest)) {
5499                         ret = PTR_ERR(wc.replay_dest);
5500                         free_extent_buffer(log->node);
5501                         free_extent_buffer(log->commit_root);
5502                         kfree(log);
5503                         btrfs_std_error(fs_info, ret, "Couldn't read target root "
5504                                     "for tree log recovery.");
5505                         goto error;
5506                 }
5507
5508                 wc.replay_dest->log_root = log;
5509                 btrfs_record_root_in_trans(trans, wc.replay_dest);
5510                 ret = walk_log_tree(trans, log, &wc);
5511
5512                 if (!ret && wc.stage == LOG_WALK_REPLAY_ALL) {
5513                         ret = fixup_inode_link_counts(trans, wc.replay_dest,
5514                                                       path);
5515                 }
5516
5517                 key.offset = found_key.offset - 1;
5518                 wc.replay_dest->log_root = NULL;
5519                 free_extent_buffer(log->node);
5520                 free_extent_buffer(log->commit_root);
5521                 kfree(log);
5522
5523                 if (ret)
5524                         goto error;
5525
5526                 if (found_key.offset == 0)
5527                         break;
5528         }
5529         btrfs_release_path(path);
5530
5531         /* step one is to pin it all, step two is to replay just inodes */
5532         if (wc.pin) {
5533                 wc.pin = 0;
5534                 wc.process_func = replay_one_buffer;
5535                 wc.stage = LOG_WALK_REPLAY_INODES;
5536                 goto again;
5537         }
5538         /* step three is to replay everything */
5539         if (wc.stage < LOG_WALK_REPLAY_ALL) {
5540                 wc.stage++;
5541                 goto again;
5542         }
5543
5544         btrfs_free_path(path);
5545
5546         /* step 4: commit the transaction, which also unpins the blocks */
5547         ret = btrfs_commit_transaction(trans, fs_info->tree_root);
5548         if (ret)
5549                 return ret;
5550
5551         free_extent_buffer(log_root_tree->node);
5552         log_root_tree->log_root = NULL;
5553         fs_info->log_root_recovering = 0;
5554         kfree(log_root_tree);
5555
5556         return 0;
5557 error:
5558         if (wc.trans)
5559                 btrfs_end_transaction(wc.trans, fs_info->tree_root);
5560         btrfs_free_path(path);
5561         return ret;
5562 }
5563
5564 /*
5565  * there are some corner cases where we want to force a full
5566  * commit instead of allowing a directory to be logged.
5567  *
5568  * They revolve around files there were unlinked from the directory, and
5569  * this function updates the parent directory so that a full commit is
5570  * properly done if it is fsync'd later after the unlinks are done.
5571  */
5572 void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans,
5573                              struct inode *dir, struct inode *inode,
5574                              int for_rename)
5575 {
5576         /*
5577          * when we're logging a file, if it hasn't been renamed
5578          * or unlinked, and its inode is fully committed on disk,
5579          * we don't have to worry about walking up the directory chain
5580          * to log its parents.
5581          *
5582          * So, we use the last_unlink_trans field to put this transid
5583          * into the file.  When the file is logged we check it and
5584          * don't log the parents if the file is fully on disk.
5585          */
5586         if (S_ISREG(inode->i_mode))
5587                 BTRFS_I(inode)->last_unlink_trans = trans->transid;
5588
5589         /*
5590          * if this directory was already logged any new
5591          * names for this file/dir will get recorded
5592          */
5593         smp_mb();
5594         if (BTRFS_I(dir)->logged_trans == trans->transid)
5595                 return;
5596
5597         /*
5598          * if the inode we're about to unlink was logged,
5599          * the log will be properly updated for any new names
5600          */
5601         if (BTRFS_I(inode)->logged_trans == trans->transid)
5602                 return;
5603
5604         /*
5605          * when renaming files across directories, if the directory
5606          * there we're unlinking from gets fsync'd later on, there's
5607          * no way to find the destination directory later and fsync it
5608          * properly.  So, we have to be conservative and force commits
5609          * so the new name gets discovered.
5610          */
5611         if (for_rename)
5612                 goto record;
5613
5614         /* we can safely do the unlink without any special recording */
5615         return;
5616
5617 record:
5618         BTRFS_I(dir)->last_unlink_trans = trans->transid;
5619 }
5620
5621 /*
5622  * Call this after adding a new name for a file and it will properly
5623  * update the log to reflect the new name.
5624  *
5625  * It will return zero if all goes well, and it will return 1 if a
5626  * full transaction commit is required.
5627  */
5628 int btrfs_log_new_name(struct btrfs_trans_handle *trans,
5629                         struct inode *inode, struct inode *old_dir,
5630                         struct dentry *parent)
5631 {
5632         struct btrfs_root * root = BTRFS_I(inode)->root;
5633
5634         /*
5635          * this will force the logging code to walk the dentry chain
5636          * up for the file
5637          */
5638         if (S_ISREG(inode->i_mode))
5639                 BTRFS_I(inode)->last_unlink_trans = trans->transid;
5640
5641         /*
5642          * if this inode hasn't been logged and directory we're renaming it
5643          * from hasn't been logged, we don't need to log it
5644          */
5645         if (BTRFS_I(inode)->logged_trans <=
5646             root->fs_info->last_trans_committed &&
5647             (!old_dir || BTRFS_I(old_dir)->logged_trans <=
5648                     root->fs_info->last_trans_committed))
5649                 return 0;
5650
5651         return btrfs_log_inode_parent(trans, root, inode, parent, 0,
5652                                       LLONG_MAX, 1, NULL);
5653 }
5654