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