1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/sched.h>
20#include <linux/slab.h>
21#include <linux/blkdev.h>
22#include <linux/list_sort.h>
23#include "ctree.h"
24#include "transaction.h"
25#include "disk-io.h"
26#include "locking.h"
27#include "print-tree.h"
28#include "backref.h"
29#include "compat.h"
30#include "tree-log.h"
31#include "hash.h"
32
33
34
35
36
37
38
39#define LOG_INODE_ALL 0
40#define LOG_INODE_EXISTS 1
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94#define LOG_WALK_PIN_ONLY 0
95#define LOG_WALK_REPLAY_INODES 1
96#define LOG_WALK_REPLAY_ALL 2
97
98static int btrfs_log_inode(struct btrfs_trans_handle *trans,
99 struct btrfs_root *root, struct inode *inode,
100 int inode_only);
101static int link_to_fixup_dir(struct btrfs_trans_handle *trans,
102 struct btrfs_root *root,
103 struct btrfs_path *path, u64 objectid);
104static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
105 struct btrfs_root *root,
106 struct btrfs_root *log,
107 struct btrfs_path *path,
108 u64 dirid, int del_all);
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138static int start_log_trans(struct btrfs_trans_handle *trans,
139 struct btrfs_root *root)
140{
141 int ret;
142 int err = 0;
143
144 mutex_lock(&root->log_mutex);
145 if (root->log_root) {
146 if (!root->log_start_pid) {
147 root->log_start_pid = current->pid;
148 root->log_multiple_pids = false;
149 } else if (root->log_start_pid != current->pid) {
150 root->log_multiple_pids = true;
151 }
152
153 atomic_inc(&root->log_batch);
154 atomic_inc(&root->log_writers);
155 mutex_unlock(&root->log_mutex);
156 return 0;
157 }
158 root->log_multiple_pids = false;
159 root->log_start_pid = current->pid;
160 mutex_lock(&root->fs_info->tree_log_mutex);
161 if (!root->fs_info->log_root_tree) {
162 ret = btrfs_init_log_root_tree(trans, root->fs_info);
163 if (ret)
164 err = ret;
165 }
166 if (err == 0 && !root->log_root) {
167 ret = btrfs_add_log_tree(trans, root);
168 if (ret)
169 err = ret;
170 }
171 mutex_unlock(&root->fs_info->tree_log_mutex);
172 atomic_inc(&root->log_batch);
173 atomic_inc(&root->log_writers);
174 mutex_unlock(&root->log_mutex);
175 return err;
176}
177
178
179
180
181
182
183static int join_running_log_trans(struct btrfs_root *root)
184{
185 int ret = -ENOENT;
186
187 smp_mb();
188 if (!root->log_root)
189 return -ENOENT;
190
191 mutex_lock(&root->log_mutex);
192 if (root->log_root) {
193 ret = 0;
194 atomic_inc(&root->log_writers);
195 }
196 mutex_unlock(&root->log_mutex);
197 return ret;
198}
199
200
201
202
203
204
205int btrfs_pin_log_trans(struct btrfs_root *root)
206{
207 int ret = -ENOENT;
208
209 mutex_lock(&root->log_mutex);
210 atomic_inc(&root->log_writers);
211 mutex_unlock(&root->log_mutex);
212 return ret;
213}
214
215
216
217
218
219void btrfs_end_log_trans(struct btrfs_root *root)
220{
221 if (atomic_dec_and_test(&root->log_writers)) {
222 smp_mb();
223 if (waitqueue_active(&root->log_writer_wait))
224 wake_up(&root->log_writer_wait);
225 }
226}
227
228
229
230
231
232
233
234
235struct walk_control {
236
237
238
239 int free;
240
241
242
243
244 int write;
245
246
247
248
249 int wait;
250
251
252
253
254 int pin;
255
256
257 int stage;
258
259
260 struct btrfs_root *replay_dest;
261
262
263 struct btrfs_trans_handle *trans;
264
265
266
267
268
269
270 int (*process_func)(struct btrfs_root *log, struct extent_buffer *eb,
271 struct walk_control *wc, u64 gen);
272};
273
274
275
276
277static int process_one_buffer(struct btrfs_root *log,
278 struct extent_buffer *eb,
279 struct walk_control *wc, u64 gen)
280{
281 int ret = 0;
282
283
284
285
286
287 if (btrfs_fs_incompat(log->fs_info, MIXED_GROUPS)) {
288 ret = btrfs_read_buffer(eb, gen);
289 if (ret)
290 return ret;
291 }
292
293 if (wc->pin)
294 ret = btrfs_pin_extent_for_log_replay(log->fs_info->extent_root,
295 eb->start, eb->len);
296
297 if (!ret && btrfs_buffer_uptodate(eb, gen, 0)) {
298 if (wc->pin && btrfs_header_level(eb) == 0)
299 ret = btrfs_exclude_logged_extents(log, eb);
300 if (wc->write)
301 btrfs_write_tree_block(eb);
302 if (wc->wait)
303 btrfs_wait_tree_block_writeback(eb);
304 }
305 return ret;
306}
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322static noinline int overwrite_item(struct btrfs_trans_handle *trans,
323 struct btrfs_root *root,
324 struct btrfs_path *path,
325 struct extent_buffer *eb, int slot,
326 struct btrfs_key *key)
327{
328 int ret;
329 u32 item_size;
330 u64 saved_i_size = 0;
331 int save_old_i_size = 0;
332 unsigned long src_ptr;
333 unsigned long dst_ptr;
334 int overwrite_root = 0;
335 bool inode_item = key->type == BTRFS_INODE_ITEM_KEY;
336
337 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
338 overwrite_root = 1;
339
340 item_size = btrfs_item_size_nr(eb, slot);
341 src_ptr = btrfs_item_ptr_offset(eb, slot);
342
343
344 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
345 if (ret < 0)
346 return ret;
347
348 if (ret == 0) {
349 char *src_copy;
350 char *dst_copy;
351 u32 dst_size = btrfs_item_size_nr(path->nodes[0],
352 path->slots[0]);
353 if (dst_size != item_size)
354 goto insert;
355
356 if (item_size == 0) {
357 btrfs_release_path(path);
358 return 0;
359 }
360 dst_copy = kmalloc(item_size, GFP_NOFS);
361 src_copy = kmalloc(item_size, GFP_NOFS);
362 if (!dst_copy || !src_copy) {
363 btrfs_release_path(path);
364 kfree(dst_copy);
365 kfree(src_copy);
366 return -ENOMEM;
367 }
368
369 read_extent_buffer(eb, src_copy, src_ptr, item_size);
370
371 dst_ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
372 read_extent_buffer(path->nodes[0], dst_copy, dst_ptr,
373 item_size);
374 ret = memcmp(dst_copy, src_copy, item_size);
375
376 kfree(dst_copy);
377 kfree(src_copy);
378
379
380
381
382
383
384 if (ret == 0) {
385 btrfs_release_path(path);
386 return 0;
387 }
388
389
390
391
392
393 if (inode_item) {
394 struct btrfs_inode_item *item;
395 u64 nbytes;
396
397 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
398 struct btrfs_inode_item);
399 nbytes = btrfs_inode_nbytes(path->nodes[0], item);
400 item = btrfs_item_ptr(eb, slot,
401 struct btrfs_inode_item);
402 btrfs_set_inode_nbytes(eb, item, nbytes);
403 }
404 } else if (inode_item) {
405 struct btrfs_inode_item *item;
406
407
408
409
410
411 item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
412 btrfs_set_inode_nbytes(eb, item, 0);
413 }
414insert:
415 btrfs_release_path(path);
416
417 ret = btrfs_insert_empty_item(trans, root, path,
418 key, item_size);
419
420
421 if (ret == -EEXIST) {
422 u32 found_size;
423 found_size = btrfs_item_size_nr(path->nodes[0],
424 path->slots[0]);
425 if (found_size > item_size)
426 btrfs_truncate_item(root, path, item_size, 1);
427 else if (found_size < item_size)
428 btrfs_extend_item(root, path,
429 item_size - found_size);
430 } else if (ret) {
431 return ret;
432 }
433 dst_ptr = btrfs_item_ptr_offset(path->nodes[0],
434 path->slots[0]);
435
436
437
438
439
440
441
442
443
444
445 if (key->type == BTRFS_INODE_ITEM_KEY && ret == -EEXIST) {
446 struct btrfs_inode_item *src_item;
447 struct btrfs_inode_item *dst_item;
448
449 src_item = (struct btrfs_inode_item *)src_ptr;
450 dst_item = (struct btrfs_inode_item *)dst_ptr;
451
452 if (btrfs_inode_generation(eb, src_item) == 0)
453 goto no_copy;
454
455 if (overwrite_root &&
456 S_ISDIR(btrfs_inode_mode(eb, src_item)) &&
457 S_ISDIR(btrfs_inode_mode(path->nodes[0], dst_item))) {
458 save_old_i_size = 1;
459 saved_i_size = btrfs_inode_size(path->nodes[0],
460 dst_item);
461 }
462 }
463
464 copy_extent_buffer(path->nodes[0], eb, dst_ptr,
465 src_ptr, item_size);
466
467 if (save_old_i_size) {
468 struct btrfs_inode_item *dst_item;
469 dst_item = (struct btrfs_inode_item *)dst_ptr;
470 btrfs_set_inode_size(path->nodes[0], dst_item, saved_i_size);
471 }
472
473
474 if (key->type == BTRFS_INODE_ITEM_KEY) {
475 struct btrfs_inode_item *dst_item;
476 dst_item = (struct btrfs_inode_item *)dst_ptr;
477 if (btrfs_inode_generation(path->nodes[0], dst_item) == 0) {
478 btrfs_set_inode_generation(path->nodes[0], dst_item,
479 trans->transid);
480 }
481 }
482no_copy:
483 btrfs_mark_buffer_dirty(path->nodes[0]);
484 btrfs_release_path(path);
485 return 0;
486}
487
488
489
490
491
492static noinline struct inode *read_one_inode(struct btrfs_root *root,
493 u64 objectid)
494{
495 struct btrfs_key key;
496 struct inode *inode;
497
498 key.objectid = objectid;
499 key.type = BTRFS_INODE_ITEM_KEY;
500 key.offset = 0;
501 inode = btrfs_iget(root->fs_info->sb, &key, root, NULL);
502 if (IS_ERR(inode)) {
503 inode = NULL;
504 } else if (is_bad_inode(inode)) {
505 iput(inode);
506 inode = NULL;
507 }
508 return inode;
509}
510
511
512
513
514
515
516
517
518
519
520
521
522
523static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
524 struct btrfs_root *root,
525 struct btrfs_path *path,
526 struct extent_buffer *eb, int slot,
527 struct btrfs_key *key)
528{
529 int found_type;
530 u64 extent_end;
531 u64 start = key->offset;
532 u64 nbytes = 0;
533 struct btrfs_file_extent_item *item;
534 struct inode *inode = NULL;
535 unsigned long size;
536 int ret = 0;
537
538 item = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
539 found_type = btrfs_file_extent_type(eb, item);
540
541 if (found_type == BTRFS_FILE_EXTENT_REG ||
542 found_type == BTRFS_FILE_EXTENT_PREALLOC) {
543 nbytes = btrfs_file_extent_num_bytes(eb, item);
544 extent_end = start + nbytes;
545
546
547
548
549
550 if (btrfs_file_extent_disk_bytenr(eb, item) == 0)
551 nbytes = 0;
552 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
553 size = btrfs_file_extent_inline_len(eb, item);
554 nbytes = btrfs_file_extent_ram_bytes(eb, item);
555 extent_end = ALIGN(start + size, root->sectorsize);
556 } else {
557 ret = 0;
558 goto out;
559 }
560
561 inode = read_one_inode(root, key->objectid);
562 if (!inode) {
563 ret = -EIO;
564 goto out;
565 }
566
567
568
569
570
571
572 ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
573 start, 0);
574
575 if (ret == 0 &&
576 (found_type == BTRFS_FILE_EXTENT_REG ||
577 found_type == BTRFS_FILE_EXTENT_PREALLOC)) {
578 struct btrfs_file_extent_item cmp1;
579 struct btrfs_file_extent_item cmp2;
580 struct btrfs_file_extent_item *existing;
581 struct extent_buffer *leaf;
582
583 leaf = path->nodes[0];
584 existing = btrfs_item_ptr(leaf, path->slots[0],
585 struct btrfs_file_extent_item);
586
587 read_extent_buffer(eb, &cmp1, (unsigned long)item,
588 sizeof(cmp1));
589 read_extent_buffer(leaf, &cmp2, (unsigned long)existing,
590 sizeof(cmp2));
591
592
593
594
595
596 if (memcmp(&cmp1, &cmp2, sizeof(cmp1)) == 0) {
597 btrfs_release_path(path);
598 goto out;
599 }
600 }
601 btrfs_release_path(path);
602
603
604 ret = btrfs_drop_extents(trans, root, inode, start, extent_end, 1);
605 if (ret)
606 goto out;
607
608 if (found_type == BTRFS_FILE_EXTENT_REG ||
609 found_type == BTRFS_FILE_EXTENT_PREALLOC) {
610 u64 offset;
611 unsigned long dest_offset;
612 struct btrfs_key ins;
613
614 ret = btrfs_insert_empty_item(trans, root, path, key,
615 sizeof(*item));
616 if (ret)
617 goto out;
618 dest_offset = btrfs_item_ptr_offset(path->nodes[0],
619 path->slots[0]);
620 copy_extent_buffer(path->nodes[0], eb, dest_offset,
621 (unsigned long)item, sizeof(*item));
622
623 ins.objectid = btrfs_file_extent_disk_bytenr(eb, item);
624 ins.offset = btrfs_file_extent_disk_num_bytes(eb, item);
625 ins.type = BTRFS_EXTENT_ITEM_KEY;
626 offset = key->offset - btrfs_file_extent_offset(eb, item);
627
628 if (ins.objectid > 0) {
629 u64 csum_start;
630 u64 csum_end;
631 LIST_HEAD(ordered_sums);
632
633
634
635
636 ret = btrfs_lookup_extent(root, ins.objectid,
637 ins.offset);
638 if (ret == 0) {
639 ret = btrfs_inc_extent_ref(trans, root,
640 ins.objectid, ins.offset,
641 0, root->root_key.objectid,
642 key->objectid, offset, 0);
643 if (ret)
644 goto out;
645 } else {
646
647
648
649
650 ret = btrfs_alloc_logged_file_extent(trans,
651 root, root->root_key.objectid,
652 key->objectid, offset, &ins);
653 if (ret)
654 goto out;
655 }
656 btrfs_release_path(path);
657
658 if (btrfs_file_extent_compression(eb, item)) {
659 csum_start = ins.objectid;
660 csum_end = csum_start + ins.offset;
661 } else {
662 csum_start = ins.objectid +
663 btrfs_file_extent_offset(eb, item);
664 csum_end = csum_start +
665 btrfs_file_extent_num_bytes(eb, item);
666 }
667
668 ret = btrfs_lookup_csums_range(root->log_root,
669 csum_start, csum_end - 1,
670 &ordered_sums, 0);
671 if (ret)
672 goto out;
673 while (!list_empty(&ordered_sums)) {
674 struct btrfs_ordered_sum *sums;
675 sums = list_entry(ordered_sums.next,
676 struct btrfs_ordered_sum,
677 list);
678 if (!ret)
679 ret = btrfs_csum_file_blocks(trans,
680 root->fs_info->csum_root,
681 sums);
682 list_del(&sums->list);
683 kfree(sums);
684 }
685 if (ret)
686 goto out;
687 } else {
688 btrfs_release_path(path);
689 }
690 } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
691
692 ret = overwrite_item(trans, root, path, eb, slot, key);
693 if (ret)
694 goto out;
695 }
696
697 inode_add_bytes(inode, nbytes);
698 ret = btrfs_update_inode(trans, root, inode);
699out:
700 if (inode)
701 iput(inode);
702 return ret;
703}
704
705
706
707
708
709
710
711
712
713static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
714 struct btrfs_root *root,
715 struct btrfs_path *path,
716 struct inode *dir,
717 struct btrfs_dir_item *di)
718{
719 struct inode *inode;
720 char *name;
721 int name_len;
722 struct extent_buffer *leaf;
723 struct btrfs_key location;
724 int ret;
725
726 leaf = path->nodes[0];
727
728 btrfs_dir_item_key_to_cpu(leaf, di, &location);
729 name_len = btrfs_dir_name_len(leaf, di);
730 name = kmalloc(name_len, GFP_NOFS);
731 if (!name)
732 return -ENOMEM;
733
734 read_extent_buffer(leaf, name, (unsigned long)(di + 1), name_len);
735 btrfs_release_path(path);
736
737 inode = read_one_inode(root, location.objectid);
738 if (!inode) {
739 ret = -EIO;
740 goto out;
741 }
742
743 ret = link_to_fixup_dir(trans, root, path, location.objectid);
744 if (ret)
745 goto out;
746
747 ret = btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
748 if (ret)
749 goto out;
750 btrfs_run_delayed_items(trans, root);
751out:
752 kfree(name);
753 iput(inode);
754 return ret;
755}
756
757
758
759
760
761
762static noinline int inode_in_dir(struct btrfs_root *root,
763 struct btrfs_path *path,
764 u64 dirid, u64 objectid, u64 index,
765 const char *name, int name_len)
766{
767 struct btrfs_dir_item *di;
768 struct btrfs_key location;
769 int match = 0;
770
771 di = btrfs_lookup_dir_index_item(NULL, root, path, dirid,
772 index, name, name_len, 0);
773 if (di && !IS_ERR(di)) {
774 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
775 if (location.objectid != objectid)
776 goto out;
777 } else
778 goto out;
779 btrfs_release_path(path);
780
781 di = btrfs_lookup_dir_item(NULL, root, path, dirid, name, name_len, 0);
782 if (di && !IS_ERR(di)) {
783 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
784 if (location.objectid != objectid)
785 goto out;
786 } else
787 goto out;
788 match = 1;
789out:
790 btrfs_release_path(path);
791 return match;
792}
793
794
795
796
797
798
799
800
801
802
803
804static noinline int backref_in_log(struct btrfs_root *log,
805 struct btrfs_key *key,
806 u64 ref_objectid,
807 char *name, int namelen)
808{
809 struct btrfs_path *path;
810 struct btrfs_inode_ref *ref;
811 unsigned long ptr;
812 unsigned long ptr_end;
813 unsigned long name_ptr;
814 int found_name_len;
815 int item_size;
816 int ret;
817 int match = 0;
818
819 path = btrfs_alloc_path();
820 if (!path)
821 return -ENOMEM;
822
823 ret = btrfs_search_slot(NULL, log, key, path, 0, 0);
824 if (ret != 0)
825 goto out;
826
827 ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
828
829 if (key->type == BTRFS_INODE_EXTREF_KEY) {
830 if (btrfs_find_name_in_ext_backref(path, ref_objectid,
831 name, namelen, NULL))
832 match = 1;
833
834 goto out;
835 }
836
837 item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
838 ptr_end = ptr + item_size;
839 while (ptr < ptr_end) {
840 ref = (struct btrfs_inode_ref *)ptr;
841 found_name_len = btrfs_inode_ref_name_len(path->nodes[0], ref);
842 if (found_name_len == namelen) {
843 name_ptr = (unsigned long)(ref + 1);
844 ret = memcmp_extent_buffer(path->nodes[0], name,
845 name_ptr, namelen);
846 if (ret == 0) {
847 match = 1;
848 goto out;
849 }
850 }
851 ptr = (unsigned long)(ref + 1) + found_name_len;
852 }
853out:
854 btrfs_free_path(path);
855 return match;
856}
857
858static inline int __add_inode_ref(struct btrfs_trans_handle *trans,
859 struct btrfs_root *root,
860 struct btrfs_path *path,
861 struct btrfs_root *log_root,
862 struct inode *dir, struct inode *inode,
863 struct extent_buffer *eb,
864 u64 inode_objectid, u64 parent_objectid,
865 u64 ref_index, char *name, int namelen,
866 int *search_done)
867{
868 int ret;
869 char *victim_name;
870 int victim_name_len;
871 struct extent_buffer *leaf;
872 struct btrfs_dir_item *di;
873 struct btrfs_key search_key;
874 struct btrfs_inode_extref *extref;
875
876again:
877
878 search_key.objectid = inode_objectid;
879 search_key.type = BTRFS_INODE_REF_KEY;
880 search_key.offset = parent_objectid;
881 ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
882 if (ret == 0) {
883 struct btrfs_inode_ref *victim_ref;
884 unsigned long ptr;
885 unsigned long ptr_end;
886
887 leaf = path->nodes[0];
888
889
890
891
892 if (search_key.objectid == search_key.offset)
893 return 1;
894
895
896
897
898
899 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
900 ptr_end = ptr + btrfs_item_size_nr(leaf, path->slots[0]);
901 while (ptr < ptr_end) {
902 victim_ref = (struct btrfs_inode_ref *)ptr;
903 victim_name_len = btrfs_inode_ref_name_len(leaf,
904 victim_ref);
905 victim_name = kmalloc(victim_name_len, GFP_NOFS);
906 if (!victim_name)
907 return -ENOMEM;
908
909 read_extent_buffer(leaf, victim_name,
910 (unsigned long)(victim_ref + 1),
911 victim_name_len);
912
913 if (!backref_in_log(log_root, &search_key,
914 parent_objectid,
915 victim_name,
916 victim_name_len)) {
917 btrfs_inc_nlink(inode);
918 btrfs_release_path(path);
919
920 ret = btrfs_unlink_inode(trans, root, dir,
921 inode, victim_name,
922 victim_name_len);
923 kfree(victim_name);
924 if (ret)
925 return ret;
926 btrfs_run_delayed_items(trans, root);
927 *search_done = 1;
928 goto again;
929 }
930 kfree(victim_name);
931
932 ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
933 }
934
935
936
937
938
939 *search_done = 1;
940 }
941 btrfs_release_path(path);
942
943
944 extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen,
945 inode_objectid, parent_objectid, 0,
946 0);
947 if (!IS_ERR_OR_NULL(extref)) {
948 u32 item_size;
949 u32 cur_offset = 0;
950 unsigned long base;
951 struct inode *victim_parent;
952
953 leaf = path->nodes[0];
954
955 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
956 base = btrfs_item_ptr_offset(leaf, path->slots[0]);
957
958 while (cur_offset < item_size) {
959 extref = (struct btrfs_inode_extref *)base + cur_offset;
960
961 victim_name_len = btrfs_inode_extref_name_len(leaf, extref);
962
963 if (btrfs_inode_extref_parent(leaf, extref) != parent_objectid)
964 goto next;
965
966 victim_name = kmalloc(victim_name_len, GFP_NOFS);
967 if (!victim_name)
968 return -ENOMEM;
969 read_extent_buffer(leaf, victim_name, (unsigned long)&extref->name,
970 victim_name_len);
971
972 search_key.objectid = inode_objectid;
973 search_key.type = BTRFS_INODE_EXTREF_KEY;
974 search_key.offset = btrfs_extref_hash(parent_objectid,
975 victim_name,
976 victim_name_len);
977 ret = 0;
978 if (!backref_in_log(log_root, &search_key,
979 parent_objectid, victim_name,
980 victim_name_len)) {
981 ret = -ENOENT;
982 victim_parent = read_one_inode(root,
983 parent_objectid);
984 if (victim_parent) {
985 btrfs_inc_nlink(inode);
986 btrfs_release_path(path);
987
988 ret = btrfs_unlink_inode(trans, root,
989 victim_parent,
990 inode,
991 victim_name,
992 victim_name_len);
993 btrfs_run_delayed_items(trans, root);
994 }
995 iput(victim_parent);
996 kfree(victim_name);
997 if (ret)
998 return ret;
999 *search_done = 1;
1000 goto again;
1001 }
1002 kfree(victim_name);
1003 if (ret)
1004 return ret;
1005next:
1006 cur_offset += victim_name_len + sizeof(*extref);
1007 }
1008 *search_done = 1;
1009 }
1010 btrfs_release_path(path);
1011
1012
1013 di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
1014 ref_index, name, namelen, 0);
1015 if (di && !IS_ERR(di)) {
1016 ret = drop_one_dir_item(trans, root, path, dir, di);
1017 if (ret)
1018 return ret;
1019 }
1020 btrfs_release_path(path);
1021
1022
1023 di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir),
1024 name, namelen, 0);
1025 if (di && !IS_ERR(di)) {
1026 ret = drop_one_dir_item(trans, root, path, dir, di);
1027 if (ret)
1028 return ret;
1029 }
1030 btrfs_release_path(path);
1031
1032 return 0;
1033}
1034
1035static int extref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
1036 u32 *namelen, char **name, u64 *index,
1037 u64 *parent_objectid)
1038{
1039 struct btrfs_inode_extref *extref;
1040
1041 extref = (struct btrfs_inode_extref *)ref_ptr;
1042
1043 *namelen = btrfs_inode_extref_name_len(eb, extref);
1044 *name = kmalloc(*namelen, GFP_NOFS);
1045 if (*name == NULL)
1046 return -ENOMEM;
1047
1048 read_extent_buffer(eb, *name, (unsigned long)&extref->name,
1049 *namelen);
1050
1051 *index = btrfs_inode_extref_index(eb, extref);
1052 if (parent_objectid)
1053 *parent_objectid = btrfs_inode_extref_parent(eb, extref);
1054
1055 return 0;
1056}
1057
1058static int ref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
1059 u32 *namelen, char **name, u64 *index)
1060{
1061 struct btrfs_inode_ref *ref;
1062
1063 ref = (struct btrfs_inode_ref *)ref_ptr;
1064
1065 *namelen = btrfs_inode_ref_name_len(eb, ref);
1066 *name = kmalloc(*namelen, GFP_NOFS);
1067 if (*name == NULL)
1068 return -ENOMEM;
1069
1070 read_extent_buffer(eb, *name, (unsigned long)(ref + 1), *namelen);
1071
1072 *index = btrfs_inode_ref_index(eb, ref);
1073
1074 return 0;
1075}
1076
1077
1078
1079
1080
1081
1082
1083static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
1084 struct btrfs_root *root,
1085 struct btrfs_root *log,
1086 struct btrfs_path *path,
1087 struct extent_buffer *eb, int slot,
1088 struct btrfs_key *key)
1089{
1090 struct inode *dir;
1091 struct inode *inode;
1092 unsigned long ref_ptr;
1093 unsigned long ref_end;
1094 char *name;
1095 int namelen;
1096 int ret;
1097 int search_done = 0;
1098 int log_ref_ver = 0;
1099 u64 parent_objectid;
1100 u64 inode_objectid;
1101 u64 ref_index = 0;
1102 int ref_struct_size;
1103
1104 ref_ptr = btrfs_item_ptr_offset(eb, slot);
1105 ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
1106
1107 if (key->type == BTRFS_INODE_EXTREF_KEY) {
1108 struct btrfs_inode_extref *r;
1109
1110 ref_struct_size = sizeof(struct btrfs_inode_extref);
1111 log_ref_ver = 1;
1112 r = (struct btrfs_inode_extref *)ref_ptr;
1113 parent_objectid = btrfs_inode_extref_parent(eb, r);
1114 } else {
1115 ref_struct_size = sizeof(struct btrfs_inode_ref);
1116 parent_objectid = key->offset;
1117 }
1118 inode_objectid = key->objectid;
1119
1120
1121
1122
1123
1124
1125
1126 dir = read_one_inode(root, parent_objectid);
1127 if (!dir)
1128 return -ENOENT;
1129
1130 inode = read_one_inode(root, inode_objectid);
1131 if (!inode) {
1132 iput(dir);
1133 return -EIO;
1134 }
1135
1136 while (ref_ptr < ref_end) {
1137 if (log_ref_ver) {
1138 ret = extref_get_fields(eb, ref_ptr, &namelen, &name,
1139 &ref_index, &parent_objectid);
1140
1141
1142
1143
1144 if (!dir)
1145 dir = read_one_inode(root, parent_objectid);
1146 if (!dir)
1147 return -ENOENT;
1148 } else {
1149 ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
1150 &ref_index);
1151 }
1152 if (ret)
1153 return ret;
1154
1155
1156 if (!inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
1157 ref_index, name, namelen)) {
1158
1159
1160
1161
1162
1163
1164
1165
1166 if (!search_done) {
1167 ret = __add_inode_ref(trans, root, path, log,
1168 dir, inode, eb,
1169 inode_objectid,
1170 parent_objectid,
1171 ref_index, name, namelen,
1172 &search_done);
1173 if (ret == 1) {
1174 ret = 0;
1175 goto out;
1176 }
1177 if (ret)
1178 goto out;
1179 }
1180
1181
1182 ret = btrfs_add_link(trans, dir, inode, name, namelen,
1183 0, ref_index);
1184 if (ret)
1185 goto out;
1186
1187 btrfs_update_inode(trans, root, inode);
1188 }
1189
1190 ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
1191 kfree(name);
1192 if (log_ref_ver) {
1193 iput(dir);
1194 dir = NULL;
1195 }
1196 }
1197
1198
1199 ret = overwrite_item(trans, root, path, eb, slot, key);
1200out:
1201 btrfs_release_path(path);
1202 iput(dir);
1203 iput(inode);
1204 return ret;
1205}
1206
1207static int insert_orphan_item(struct btrfs_trans_handle *trans,
1208 struct btrfs_root *root, u64 offset)
1209{
1210 int ret;
1211 ret = btrfs_find_orphan_item(root, offset);
1212 if (ret > 0)
1213 ret = btrfs_insert_orphan_item(trans, root, offset);
1214 return ret;
1215}
1216
1217static int count_inode_extrefs(struct btrfs_root *root,
1218 struct inode *inode, struct btrfs_path *path)
1219{
1220 int ret = 0;
1221 int name_len;
1222 unsigned int nlink = 0;
1223 u32 item_size;
1224 u32 cur_offset = 0;
1225 u64 inode_objectid = btrfs_ino(inode);
1226 u64 offset = 0;
1227 unsigned long ptr;
1228 struct btrfs_inode_extref *extref;
1229 struct extent_buffer *leaf;
1230
1231 while (1) {
1232 ret = btrfs_find_one_extref(root, inode_objectid, offset, path,
1233 &extref, &offset);
1234 if (ret)
1235 break;
1236
1237 leaf = path->nodes[0];
1238 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1239 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
1240
1241 while (cur_offset < item_size) {
1242 extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
1243 name_len = btrfs_inode_extref_name_len(leaf, extref);
1244
1245 nlink++;
1246
1247 cur_offset += name_len + sizeof(*extref);
1248 }
1249
1250 offset++;
1251 btrfs_release_path(path);
1252 }
1253 btrfs_release_path(path);
1254
1255 if (ret < 0)
1256 return ret;
1257 return nlink;
1258}
1259
1260static int count_inode_refs(struct btrfs_root *root,
1261 struct inode *inode, struct btrfs_path *path)
1262{
1263 int ret;
1264 struct btrfs_key key;
1265 unsigned int nlink = 0;
1266 unsigned long ptr;
1267 unsigned long ptr_end;
1268 int name_len;
1269 u64 ino = btrfs_ino(inode);
1270
1271 key.objectid = ino;
1272 key.type = BTRFS_INODE_REF_KEY;
1273 key.offset = (u64)-1;
1274
1275 while (1) {
1276 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1277 if (ret < 0)
1278 break;
1279 if (ret > 0) {
1280 if (path->slots[0] == 0)
1281 break;
1282 path->slots[0]--;
1283 }
1284 btrfs_item_key_to_cpu(path->nodes[0], &key,
1285 path->slots[0]);
1286 if (key.objectid != ino ||
1287 key.type != BTRFS_INODE_REF_KEY)
1288 break;
1289 ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
1290 ptr_end = ptr + btrfs_item_size_nr(path->nodes[0],
1291 path->slots[0]);
1292 while (ptr < ptr_end) {
1293 struct btrfs_inode_ref *ref;
1294
1295 ref = (struct btrfs_inode_ref *)ptr;
1296 name_len = btrfs_inode_ref_name_len(path->nodes[0],
1297 ref);
1298 ptr = (unsigned long)(ref + 1) + name_len;
1299 nlink++;
1300 }
1301
1302 if (key.offset == 0)
1303 break;
1304 key.offset--;
1305 btrfs_release_path(path);
1306 }
1307 btrfs_release_path(path);
1308
1309 return nlink;
1310}
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
1323 struct btrfs_root *root,
1324 struct inode *inode)
1325{
1326 struct btrfs_path *path;
1327 int ret;
1328 u64 nlink = 0;
1329 u64 ino = btrfs_ino(inode);
1330
1331 path = btrfs_alloc_path();
1332 if (!path)
1333 return -ENOMEM;
1334
1335 ret = count_inode_refs(root, inode, path);
1336 if (ret < 0)
1337 goto out;
1338
1339 nlink = ret;
1340
1341 ret = count_inode_extrefs(root, inode, path);
1342 if (ret == -ENOENT)
1343 ret = 0;
1344
1345 if (ret < 0)
1346 goto out;
1347
1348 nlink += ret;
1349
1350 ret = 0;
1351
1352 if (nlink != inode->i_nlink) {
1353 set_nlink(inode, nlink);
1354 btrfs_update_inode(trans, root, inode);
1355 }
1356 BTRFS_I(inode)->index_cnt = (u64)-1;
1357
1358 if (inode->i_nlink == 0) {
1359 if (S_ISDIR(inode->i_mode)) {
1360 ret = replay_dir_deletes(trans, root, NULL, path,
1361 ino, 1);
1362 if (ret)
1363 goto out;
1364 }
1365 ret = insert_orphan_item(trans, root, ino);
1366 }
1367
1368out:
1369 btrfs_free_path(path);
1370 return ret;
1371}
1372
1373static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
1374 struct btrfs_root *root,
1375 struct btrfs_path *path)
1376{
1377 int ret;
1378 struct btrfs_key key;
1379 struct inode *inode;
1380
1381 key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1382 key.type = BTRFS_ORPHAN_ITEM_KEY;
1383 key.offset = (u64)-1;
1384 while (1) {
1385 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1386 if (ret < 0)
1387 break;
1388
1389 if (ret == 1) {
1390 if (path->slots[0] == 0)
1391 break;
1392 path->slots[0]--;
1393 }
1394
1395 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1396 if (key.objectid != BTRFS_TREE_LOG_FIXUP_OBJECTID ||
1397 key.type != BTRFS_ORPHAN_ITEM_KEY)
1398 break;
1399
1400 ret = btrfs_del_item(trans, root, path);
1401 if (ret)
1402 goto out;
1403
1404 btrfs_release_path(path);
1405 inode = read_one_inode(root, key.offset);
1406 if (!inode)
1407 return -EIO;
1408
1409 ret = fixup_inode_link_count(trans, root, inode);
1410 iput(inode);
1411 if (ret)
1412 goto out;
1413
1414
1415
1416
1417
1418
1419 key.offset = (u64)-1;
1420 }
1421 ret = 0;
1422out:
1423 btrfs_release_path(path);
1424 return ret;
1425}
1426
1427
1428
1429
1430
1431
1432
1433static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
1434 struct btrfs_root *root,
1435 struct btrfs_path *path,
1436 u64 objectid)
1437{
1438 struct btrfs_key key;
1439 int ret = 0;
1440 struct inode *inode;
1441
1442 inode = read_one_inode(root, objectid);
1443 if (!inode)
1444 return -EIO;
1445
1446 key.objectid = BTRFS_TREE_LOG_FIXUP_OBJECTID;
1447 btrfs_set_key_type(&key, BTRFS_ORPHAN_ITEM_KEY);
1448 key.offset = objectid;
1449
1450 ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
1451
1452 btrfs_release_path(path);
1453 if (ret == 0) {
1454 if (!inode->i_nlink)
1455 set_nlink(inode, 1);
1456 else
1457 btrfs_inc_nlink(inode);
1458 ret = btrfs_update_inode(trans, root, inode);
1459 } else if (ret == -EEXIST) {
1460 ret = 0;
1461 } else {
1462 BUG();
1463 }
1464 iput(inode);
1465
1466 return ret;
1467}
1468
1469
1470
1471
1472
1473
1474static noinline int insert_one_name(struct btrfs_trans_handle *trans,
1475 struct btrfs_root *root,
1476 struct btrfs_path *path,
1477 u64 dirid, u64 index,
1478 char *name, int name_len, u8 type,
1479 struct btrfs_key *location)
1480{
1481 struct inode *inode;
1482 struct inode *dir;
1483 int ret;
1484
1485 inode = read_one_inode(root, location->objectid);
1486 if (!inode)
1487 return -ENOENT;
1488
1489 dir = read_one_inode(root, dirid);
1490 if (!dir) {
1491 iput(inode);
1492 return -EIO;
1493 }
1494 ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index);
1495
1496
1497
1498 iput(inode);
1499 iput(dir);
1500 return ret;
1501}
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516static noinline int replay_one_name(struct btrfs_trans_handle *trans,
1517 struct btrfs_root *root,
1518 struct btrfs_path *path,
1519 struct extent_buffer *eb,
1520 struct btrfs_dir_item *di,
1521 struct btrfs_key *key)
1522{
1523 char *name;
1524 int name_len;
1525 struct btrfs_dir_item *dst_di;
1526 struct btrfs_key found_key;
1527 struct btrfs_key log_key;
1528 struct inode *dir;
1529 u8 log_type;
1530 int exists;
1531 int ret = 0;
1532
1533 dir = read_one_inode(root, key->objectid);
1534 if (!dir)
1535 return -EIO;
1536
1537 name_len = btrfs_dir_name_len(eb, di);
1538 name = kmalloc(name_len, GFP_NOFS);
1539 if (!name)
1540 return -ENOMEM;
1541
1542 log_type = btrfs_dir_type(eb, di);
1543 read_extent_buffer(eb, name, (unsigned long)(di + 1),
1544 name_len);
1545
1546 btrfs_dir_item_key_to_cpu(eb, di, &log_key);
1547 exists = btrfs_lookup_inode(trans, root, path, &log_key, 0);
1548 if (exists == 0)
1549 exists = 1;
1550 else
1551 exists = 0;
1552 btrfs_release_path(path);
1553
1554 if (key->type == BTRFS_DIR_ITEM_KEY) {
1555 dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid,
1556 name, name_len, 1);
1557 } else if (key->type == BTRFS_DIR_INDEX_KEY) {
1558 dst_di = btrfs_lookup_dir_index_item(trans, root, path,
1559 key->objectid,
1560 key->offset, name,
1561 name_len, 1);
1562 } else {
1563
1564 ret = -EINVAL;
1565 goto out;
1566 }
1567 if (IS_ERR_OR_NULL(dst_di)) {
1568
1569
1570
1571 if (key->type != BTRFS_DIR_INDEX_KEY)
1572 goto out;
1573 goto insert;
1574 }
1575
1576 btrfs_dir_item_key_to_cpu(path->nodes[0], dst_di, &found_key);
1577
1578 if (found_key.objectid == log_key.objectid &&
1579 found_key.type == log_key.type &&
1580 found_key.offset == log_key.offset &&
1581 btrfs_dir_type(path->nodes[0], dst_di) == log_type) {
1582 goto out;
1583 }
1584
1585
1586
1587
1588
1589 if (!exists)
1590 goto out;
1591
1592 ret = drop_one_dir_item(trans, root, path, dir, dst_di);
1593 if (ret)
1594 goto out;
1595
1596 if (key->type == BTRFS_DIR_INDEX_KEY)
1597 goto insert;
1598out:
1599 btrfs_release_path(path);
1600 kfree(name);
1601 iput(dir);
1602 return ret;
1603
1604insert:
1605 btrfs_release_path(path);
1606 ret = insert_one_name(trans, root, path, key->objectid, key->offset,
1607 name, name_len, log_type, &log_key);
1608 if (ret && ret != -ENOENT)
1609 goto out;
1610 ret = 0;
1611 goto out;
1612}
1613
1614
1615
1616
1617
1618
1619
1620static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
1621 struct btrfs_root *root,
1622 struct btrfs_path *path,
1623 struct extent_buffer *eb, int slot,
1624 struct btrfs_key *key)
1625{
1626 int ret;
1627 u32 item_size = btrfs_item_size_nr(eb, slot);
1628 struct btrfs_dir_item *di;
1629 int name_len;
1630 unsigned long ptr;
1631 unsigned long ptr_end;
1632
1633 ptr = btrfs_item_ptr_offset(eb, slot);
1634 ptr_end = ptr + item_size;
1635 while (ptr < ptr_end) {
1636 di = (struct btrfs_dir_item *)ptr;
1637 if (verify_dir_item(root, eb, di))
1638 return -EIO;
1639 name_len = btrfs_dir_name_len(eb, di);
1640 ret = replay_one_name(trans, root, path, eb, di, key);
1641 if (ret)
1642 return ret;
1643 ptr = (unsigned long)(di + 1);
1644 ptr += name_len;
1645 }
1646 return 0;
1647}
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660static noinline int find_dir_range(struct btrfs_root *root,
1661 struct btrfs_path *path,
1662 u64 dirid, int key_type,
1663 u64 *start_ret, u64 *end_ret)
1664{
1665 struct btrfs_key key;
1666 u64 found_end;
1667 struct btrfs_dir_log_item *item;
1668 int ret;
1669 int nritems;
1670
1671 if (*start_ret == (u64)-1)
1672 return 1;
1673
1674 key.objectid = dirid;
1675 key.type = key_type;
1676 key.offset = *start_ret;
1677
1678 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1679 if (ret < 0)
1680 goto out;
1681 if (ret > 0) {
1682 if (path->slots[0] == 0)
1683 goto out;
1684 path->slots[0]--;
1685 }
1686 if (ret != 0)
1687 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1688
1689 if (key.type != key_type || key.objectid != dirid) {
1690 ret = 1;
1691 goto next;
1692 }
1693 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
1694 struct btrfs_dir_log_item);
1695 found_end = btrfs_dir_log_end(path->nodes[0], item);
1696
1697 if (*start_ret >= key.offset && *start_ret <= found_end) {
1698 ret = 0;
1699 *start_ret = key.offset;
1700 *end_ret = found_end;
1701 goto out;
1702 }
1703 ret = 1;
1704next:
1705
1706 nritems = btrfs_header_nritems(path->nodes[0]);
1707 if (path->slots[0] >= nritems) {
1708 ret = btrfs_next_leaf(root, path);
1709 if (ret)
1710 goto out;
1711 } else {
1712 path->slots[0]++;
1713 }
1714
1715 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1716
1717 if (key.type != key_type || key.objectid != dirid) {
1718 ret = 1;
1719 goto out;
1720 }
1721 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
1722 struct btrfs_dir_log_item);
1723 found_end = btrfs_dir_log_end(path->nodes[0], item);
1724 *start_ret = key.offset;
1725 *end_ret = found_end;
1726 ret = 0;
1727out:
1728 btrfs_release_path(path);
1729 return ret;
1730}
1731
1732
1733
1734
1735
1736
1737static noinline int check_item_in_log(struct btrfs_trans_handle *trans,
1738 struct btrfs_root *root,
1739 struct btrfs_root *log,
1740 struct btrfs_path *path,
1741 struct btrfs_path *log_path,
1742 struct inode *dir,
1743 struct btrfs_key *dir_key)
1744{
1745 int ret;
1746 struct extent_buffer *eb;
1747 int slot;
1748 u32 item_size;
1749 struct btrfs_dir_item *di;
1750 struct btrfs_dir_item *log_di;
1751 int name_len;
1752 unsigned long ptr;
1753 unsigned long ptr_end;
1754 char *name;
1755 struct inode *inode;
1756 struct btrfs_key location;
1757
1758again:
1759 eb = path->nodes[0];
1760 slot = path->slots[0];
1761 item_size = btrfs_item_size_nr(eb, slot);
1762 ptr = btrfs_item_ptr_offset(eb, slot);
1763 ptr_end = ptr + item_size;
1764 while (ptr < ptr_end) {
1765 di = (struct btrfs_dir_item *)ptr;
1766 if (verify_dir_item(root, eb, di)) {
1767 ret = -EIO;
1768 goto out;
1769 }
1770
1771 name_len = btrfs_dir_name_len(eb, di);
1772 name = kmalloc(name_len, GFP_NOFS);
1773 if (!name) {
1774 ret = -ENOMEM;
1775 goto out;
1776 }
1777 read_extent_buffer(eb, name, (unsigned long)(di + 1),
1778 name_len);
1779 log_di = NULL;
1780 if (log && dir_key->type == BTRFS_DIR_ITEM_KEY) {
1781 log_di = btrfs_lookup_dir_item(trans, log, log_path,
1782 dir_key->objectid,
1783 name, name_len, 0);
1784 } else if (log && dir_key->type == BTRFS_DIR_INDEX_KEY) {
1785 log_di = btrfs_lookup_dir_index_item(trans, log,
1786 log_path,
1787 dir_key->objectid,
1788 dir_key->offset,
1789 name, name_len, 0);
1790 }
1791 if (IS_ERR_OR_NULL(log_di)) {
1792 btrfs_dir_item_key_to_cpu(eb, di, &location);
1793 btrfs_release_path(path);
1794 btrfs_release_path(log_path);
1795 inode = read_one_inode(root, location.objectid);
1796 if (!inode) {
1797 kfree(name);
1798 return -EIO;
1799 }
1800
1801 ret = link_to_fixup_dir(trans, root,
1802 path, location.objectid);
1803 if (ret) {
1804 kfree(name);
1805 iput(inode);
1806 goto out;
1807 }
1808
1809 btrfs_inc_nlink(inode);
1810 ret = btrfs_unlink_inode(trans, root, dir, inode,
1811 name, name_len);
1812 if (!ret)
1813 btrfs_run_delayed_items(trans, root);
1814 kfree(name);
1815 iput(inode);
1816 if (ret)
1817 goto out;
1818
1819
1820
1821
1822 ret = btrfs_search_slot(NULL, root, dir_key, path,
1823 0, 0);
1824 if (ret == 0)
1825 goto again;
1826 ret = 0;
1827 goto out;
1828 }
1829 btrfs_release_path(log_path);
1830 kfree(name);
1831
1832 ptr = (unsigned long)(di + 1);
1833 ptr += name_len;
1834 }
1835 ret = 0;
1836out:
1837 btrfs_release_path(path);
1838 btrfs_release_path(log_path);
1839 return ret;
1840}
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852static noinline int replay_dir_deletes(struct btrfs_trans_handle *trans,
1853 struct btrfs_root *root,
1854 struct btrfs_root *log,
1855 struct btrfs_path *path,
1856 u64 dirid, int del_all)
1857{
1858 u64 range_start;
1859 u64 range_end;
1860 int key_type = BTRFS_DIR_LOG_ITEM_KEY;
1861 int ret = 0;
1862 struct btrfs_key dir_key;
1863 struct btrfs_key found_key;
1864 struct btrfs_path *log_path;
1865 struct inode *dir;
1866
1867 dir_key.objectid = dirid;
1868 dir_key.type = BTRFS_DIR_ITEM_KEY;
1869 log_path = btrfs_alloc_path();
1870 if (!log_path)
1871 return -ENOMEM;
1872
1873 dir = read_one_inode(root, dirid);
1874
1875
1876
1877
1878 if (!dir) {
1879 btrfs_free_path(log_path);
1880 return 0;
1881 }
1882again:
1883 range_start = 0;
1884 range_end = 0;
1885 while (1) {
1886 if (del_all)
1887 range_end = (u64)-1;
1888 else {
1889 ret = find_dir_range(log, path, dirid, key_type,
1890 &range_start, &range_end);
1891 if (ret != 0)
1892 break;
1893 }
1894
1895 dir_key.offset = range_start;
1896 while (1) {
1897 int nritems;
1898 ret = btrfs_search_slot(NULL, root, &dir_key, path,
1899 0, 0);
1900 if (ret < 0)
1901 goto out;
1902
1903 nritems = btrfs_header_nritems(path->nodes[0]);
1904 if (path->slots[0] >= nritems) {
1905 ret = btrfs_next_leaf(root, path);
1906 if (ret)
1907 break;
1908 }
1909 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
1910 path->slots[0]);
1911 if (found_key.objectid != dirid ||
1912 found_key.type != dir_key.type)
1913 goto next_type;
1914
1915 if (found_key.offset > range_end)
1916 break;
1917
1918 ret = check_item_in_log(trans, root, log, path,
1919 log_path, dir,
1920 &found_key);
1921 if (ret)
1922 goto out;
1923 if (found_key.offset == (u64)-1)
1924 break;
1925 dir_key.offset = found_key.offset + 1;
1926 }
1927 btrfs_release_path(path);
1928 if (range_end == (u64)-1)
1929 break;
1930 range_start = range_end + 1;
1931 }
1932
1933next_type:
1934 ret = 0;
1935 if (key_type == BTRFS_DIR_LOG_ITEM_KEY) {
1936 key_type = BTRFS_DIR_LOG_INDEX_KEY;
1937 dir_key.type = BTRFS_DIR_INDEX_KEY;
1938 btrfs_release_path(path);
1939 goto again;
1940 }
1941out:
1942 btrfs_release_path(path);
1943 btrfs_free_path(log_path);
1944 iput(dir);
1945 return ret;
1946}
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
1960 struct walk_control *wc, u64 gen)
1961{
1962 int nritems;
1963 struct btrfs_path *path;
1964 struct btrfs_root *root = wc->replay_dest;
1965 struct btrfs_key key;
1966 int level;
1967 int i;
1968 int ret;
1969
1970 ret = btrfs_read_buffer(eb, gen);
1971 if (ret)
1972 return ret;
1973
1974 level = btrfs_header_level(eb);
1975
1976 if (level != 0)
1977 return 0;
1978
1979 path = btrfs_alloc_path();
1980 if (!path)
1981 return -ENOMEM;
1982
1983 nritems = btrfs_header_nritems(eb);
1984 for (i = 0; i < nritems; i++) {
1985 btrfs_item_key_to_cpu(eb, &key, i);
1986
1987
1988 if (key.type == BTRFS_INODE_ITEM_KEY &&
1989 wc->stage == LOG_WALK_REPLAY_INODES) {
1990 struct btrfs_inode_item *inode_item;
1991 u32 mode;
1992
1993 inode_item = btrfs_item_ptr(eb, i,
1994 struct btrfs_inode_item);
1995 mode = btrfs_inode_mode(eb, inode_item);
1996 if (S_ISDIR(mode)) {
1997 ret = replay_dir_deletes(wc->trans,
1998 root, log, path, key.objectid, 0);
1999 if (ret)
2000 break;
2001 }
2002 ret = overwrite_item(wc->trans, root, path,
2003 eb, i, &key);
2004 if (ret)
2005 break;
2006
2007
2008
2009
2010
2011 if (S_ISREG(mode)) {
2012 ret = insert_orphan_item(wc->trans, root,
2013 key.objectid);
2014 if (ret)
2015 break;
2016 }
2017
2018 ret = link_to_fixup_dir(wc->trans, root,
2019 path, key.objectid);
2020 if (ret)
2021 break;
2022 }
2023 if (wc->stage < LOG_WALK_REPLAY_ALL)
2024 continue;
2025
2026
2027 if (key.type == BTRFS_XATTR_ITEM_KEY) {
2028 ret = overwrite_item(wc->trans, root, path,
2029 eb, i, &key);
2030 if (ret)
2031 break;
2032 } else if (key.type == BTRFS_INODE_REF_KEY ||
2033 key.type == BTRFS_INODE_EXTREF_KEY) {
2034 ret = add_inode_ref(wc->trans, root, log, path,
2035 eb, i, &key);
2036 if (ret && ret != -ENOENT)
2037 break;
2038 ret = 0;
2039 } else if (key.type == BTRFS_EXTENT_DATA_KEY) {
2040 ret = replay_one_extent(wc->trans, root, path,
2041 eb, i, &key);
2042 if (ret)
2043 break;
2044 } else if (key.type == BTRFS_DIR_ITEM_KEY ||
2045 key.type == BTRFS_DIR_INDEX_KEY) {
2046 ret = replay_one_dir_item(wc->trans, root, path,
2047 eb, i, &key);
2048 if (ret)
2049 break;
2050 }
2051 }
2052 btrfs_free_path(path);
2053 return ret;
2054}
2055
2056static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
2057 struct btrfs_root *root,
2058 struct btrfs_path *path, int *level,
2059 struct walk_control *wc)
2060{
2061 u64 root_owner;
2062 u64 bytenr;
2063 u64 ptr_gen;
2064 struct extent_buffer *next;
2065 struct extent_buffer *cur;
2066 struct extent_buffer *parent;
2067 u32 blocksize;
2068 int ret = 0;
2069
2070 WARN_ON(*level < 0);
2071 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2072
2073 while (*level > 0) {
2074 WARN_ON(*level < 0);
2075 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2076 cur = path->nodes[*level];
2077
2078 if (btrfs_header_level(cur) != *level)
2079 WARN_ON(1);
2080
2081 if (path->slots[*level] >=
2082 btrfs_header_nritems(cur))
2083 break;
2084
2085 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2086 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2087 blocksize = btrfs_level_size(root, *level - 1);
2088
2089 parent = path->nodes[*level];
2090 root_owner = btrfs_header_owner(parent);
2091
2092 next = btrfs_find_create_tree_block(root, bytenr, blocksize);
2093 if (!next)
2094 return -ENOMEM;
2095
2096 if (*level == 1) {
2097 ret = wc->process_func(root, next, wc, ptr_gen);
2098 if (ret) {
2099 free_extent_buffer(next);
2100 return ret;
2101 }
2102
2103 path->slots[*level]++;
2104 if (wc->free) {
2105 ret = btrfs_read_buffer(next, ptr_gen);
2106 if (ret) {
2107 free_extent_buffer(next);
2108 return ret;
2109 }
2110
2111 btrfs_tree_lock(next);
2112 btrfs_set_lock_blocking(next);
2113 clean_tree_block(trans, root, next);
2114 btrfs_wait_tree_block_writeback(next);
2115 btrfs_tree_unlock(next);
2116
2117 WARN_ON(root_owner !=
2118 BTRFS_TREE_LOG_OBJECTID);
2119 ret = btrfs_free_and_pin_reserved_extent(root,
2120 bytenr, blocksize);
2121 if (ret) {
2122 free_extent_buffer(next);
2123 return ret;
2124 }
2125 }
2126 free_extent_buffer(next);
2127 continue;
2128 }
2129 ret = btrfs_read_buffer(next, ptr_gen);
2130 if (ret) {
2131 free_extent_buffer(next);
2132 return ret;
2133 }
2134
2135 WARN_ON(*level <= 0);
2136 if (path->nodes[*level-1])
2137 free_extent_buffer(path->nodes[*level-1]);
2138 path->nodes[*level-1] = next;
2139 *level = btrfs_header_level(next);
2140 path->slots[*level] = 0;
2141 cond_resched();
2142 }
2143 WARN_ON(*level < 0);
2144 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2145
2146 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2147
2148 cond_resched();
2149 return 0;
2150}
2151
2152static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
2153 struct btrfs_root *root,
2154 struct btrfs_path *path, int *level,
2155 struct walk_control *wc)
2156{
2157 u64 root_owner;
2158 int i;
2159 int slot;
2160 int ret;
2161
2162 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2163 slot = path->slots[i];
2164 if (slot + 1 < btrfs_header_nritems(path->nodes[i])) {
2165 path->slots[i]++;
2166 *level = i;
2167 WARN_ON(*level == 0);
2168 return 0;
2169 } else {
2170 struct extent_buffer *parent;
2171 if (path->nodes[*level] == root->node)
2172 parent = path->nodes[*level];
2173 else
2174 parent = path->nodes[*level + 1];
2175
2176 root_owner = btrfs_header_owner(parent);
2177 ret = wc->process_func(root, path->nodes[*level], wc,
2178 btrfs_header_generation(path->nodes[*level]));
2179 if (ret)
2180 return ret;
2181
2182 if (wc->free) {
2183 struct extent_buffer *next;
2184
2185 next = path->nodes[*level];
2186
2187 btrfs_tree_lock(next);
2188 btrfs_set_lock_blocking(next);
2189 clean_tree_block(trans, root, next);
2190 btrfs_wait_tree_block_writeback(next);
2191 btrfs_tree_unlock(next);
2192
2193 WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID);
2194 ret = btrfs_free_and_pin_reserved_extent(root,
2195 path->nodes[*level]->start,
2196 path->nodes[*level]->len);
2197 if (ret)
2198 return ret;
2199 }
2200 free_extent_buffer(path->nodes[*level]);
2201 path->nodes[*level] = NULL;
2202 *level = i + 1;
2203 }
2204 }
2205 return 1;
2206}
2207
2208
2209
2210
2211
2212
2213static int walk_log_tree(struct btrfs_trans_handle *trans,
2214 struct btrfs_root *log, struct walk_control *wc)
2215{
2216 int ret = 0;
2217 int wret;
2218 int level;
2219 struct btrfs_path *path;
2220 int orig_level;
2221
2222 path = btrfs_alloc_path();
2223 if (!path)
2224 return -ENOMEM;
2225
2226 level = btrfs_header_level(log->node);
2227 orig_level = level;
2228 path->nodes[level] = log->node;
2229 extent_buffer_get(log->node);
2230 path->slots[level] = 0;
2231
2232 while (1) {
2233 wret = walk_down_log_tree(trans, log, path, &level, wc);
2234 if (wret > 0)
2235 break;
2236 if (wret < 0) {
2237 ret = wret;
2238 goto out;
2239 }
2240
2241 wret = walk_up_log_tree(trans, log, path, &level, wc);
2242 if (wret > 0)
2243 break;
2244 if (wret < 0) {
2245 ret = wret;
2246 goto out;
2247 }
2248 }
2249
2250
2251 if (path->nodes[orig_level]) {
2252 ret = wc->process_func(log, path->nodes[orig_level], wc,
2253 btrfs_header_generation(path->nodes[orig_level]));
2254 if (ret)
2255 goto out;
2256 if (wc->free) {
2257 struct extent_buffer *next;
2258
2259 next = path->nodes[orig_level];
2260
2261 btrfs_tree_lock(next);
2262 btrfs_set_lock_blocking(next);
2263 clean_tree_block(trans, log, next);
2264 btrfs_wait_tree_block_writeback(next);
2265 btrfs_tree_unlock(next);
2266
2267 WARN_ON(log->root_key.objectid !=
2268 BTRFS_TREE_LOG_OBJECTID);
2269 ret = btrfs_free_and_pin_reserved_extent(log, next->start,
2270 next->len);
2271 if (ret)
2272 goto out;
2273 }
2274 }
2275
2276out:
2277 btrfs_free_path(path);
2278 return ret;
2279}
2280
2281
2282
2283
2284
2285static int update_log_root(struct btrfs_trans_handle *trans,
2286 struct btrfs_root *log)
2287{
2288 int ret;
2289
2290 if (log->log_transid == 1) {
2291
2292 ret = btrfs_insert_root(trans, log->fs_info->log_root_tree,
2293 &log->root_key, &log->root_item);
2294 } else {
2295 ret = btrfs_update_root(trans, log->fs_info->log_root_tree,
2296 &log->root_key, &log->root_item);
2297 }
2298 return ret;
2299}
2300
2301static int wait_log_commit(struct btrfs_trans_handle *trans,
2302 struct btrfs_root *root, unsigned long transid)
2303{
2304 DEFINE_WAIT(wait);
2305 int index = transid % 2;
2306
2307
2308
2309
2310
2311
2312 do {
2313 prepare_to_wait(&root->log_commit_wait[index],
2314 &wait, TASK_UNINTERRUPTIBLE);
2315 mutex_unlock(&root->log_mutex);
2316
2317 if (root->fs_info->last_trans_log_full_commit !=
2318 trans->transid && root->log_transid < transid + 2 &&
2319 atomic_read(&root->log_commit[index]))
2320 schedule();
2321
2322 finish_wait(&root->log_commit_wait[index], &wait);
2323 mutex_lock(&root->log_mutex);
2324 } while (root->fs_info->last_trans_log_full_commit !=
2325 trans->transid && root->log_transid < transid + 2 &&
2326 atomic_read(&root->log_commit[index]));
2327 return 0;
2328}
2329
2330static void wait_for_writer(struct btrfs_trans_handle *trans,
2331 struct btrfs_root *root)
2332{
2333 DEFINE_WAIT(wait);
2334 while (root->fs_info->last_trans_log_full_commit !=
2335 trans->transid && atomic_read(&root->log_writers)) {
2336 prepare_to_wait(&root->log_writer_wait,
2337 &wait, TASK_UNINTERRUPTIBLE);
2338 mutex_unlock(&root->log_mutex);
2339 if (root->fs_info->last_trans_log_full_commit !=
2340 trans->transid && atomic_read(&root->log_writers))
2341 schedule();
2342 mutex_lock(&root->log_mutex);
2343 finish_wait(&root->log_writer_wait, &wait);
2344 }
2345}
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359int btrfs_sync_log(struct btrfs_trans_handle *trans,
2360 struct btrfs_root *root)
2361{
2362 int index1;
2363 int index2;
2364 int mark;
2365 int ret;
2366 struct btrfs_root *log = root->log_root;
2367 struct btrfs_root *log_root_tree = root->fs_info->log_root_tree;
2368 unsigned long log_transid = 0;
2369 struct blk_plug plug;
2370
2371 mutex_lock(&root->log_mutex);
2372 log_transid = root->log_transid;
2373 index1 = root->log_transid % 2;
2374 if (atomic_read(&root->log_commit[index1])) {
2375 wait_log_commit(trans, root, root->log_transid);
2376 mutex_unlock(&root->log_mutex);
2377 return 0;
2378 }
2379 atomic_set(&root->log_commit[index1], 1);
2380
2381
2382 if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
2383 wait_log_commit(trans, root, root->log_transid - 1);
2384 while (1) {
2385 int batch = atomic_read(&root->log_batch);
2386
2387 if (!btrfs_test_opt(root, SSD) && root->log_multiple_pids) {
2388 mutex_unlock(&root->log_mutex);
2389 schedule_timeout_uninterruptible(1);
2390 mutex_lock(&root->log_mutex);
2391 }
2392 wait_for_writer(trans, root);
2393 if (batch == atomic_read(&root->log_batch))
2394 break;
2395 }
2396
2397
2398 if (root->fs_info->last_trans_log_full_commit == trans->transid) {
2399 ret = -EAGAIN;
2400 btrfs_free_logged_extents(log, log_transid);
2401 mutex_unlock(&root->log_mutex);
2402 goto out;
2403 }
2404
2405 if (log_transid % 2 == 0)
2406 mark = EXTENT_DIRTY;
2407 else
2408 mark = EXTENT_NEW;
2409
2410
2411
2412
2413 blk_start_plug(&plug);
2414 ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark);
2415 if (ret) {
2416 blk_finish_plug(&plug);
2417 btrfs_abort_transaction(trans, root, ret);
2418 btrfs_free_logged_extents(log, log_transid);
2419 mutex_unlock(&root->log_mutex);
2420 goto out;
2421 }
2422
2423 btrfs_set_root_node(&log->root_item, log->node);
2424
2425 root->log_transid++;
2426 log->log_transid = root->log_transid;
2427 root->log_start_pid = 0;
2428 smp_mb();
2429
2430
2431
2432
2433
2434 mutex_unlock(&root->log_mutex);
2435
2436 mutex_lock(&log_root_tree->log_mutex);
2437 atomic_inc(&log_root_tree->log_batch);
2438 atomic_inc(&log_root_tree->log_writers);
2439 mutex_unlock(&log_root_tree->log_mutex);
2440
2441 ret = update_log_root(trans, log);
2442
2443 mutex_lock(&log_root_tree->log_mutex);
2444 if (atomic_dec_and_test(&log_root_tree->log_writers)) {
2445 smp_mb();
2446 if (waitqueue_active(&log_root_tree->log_writer_wait))
2447 wake_up(&log_root_tree->log_writer_wait);
2448 }
2449
2450 if (ret) {
2451 blk_finish_plug(&plug);
2452 if (ret != -ENOSPC) {
2453 btrfs_abort_transaction(trans, root, ret);
2454 mutex_unlock(&log_root_tree->log_mutex);
2455 goto out;
2456 }
2457 root->fs_info->last_trans_log_full_commit = trans->transid;
2458 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2459 btrfs_free_logged_extents(log, log_transid);
2460 mutex_unlock(&log_root_tree->log_mutex);
2461 ret = -EAGAIN;
2462 goto out;
2463 }
2464
2465 index2 = log_root_tree->log_transid % 2;
2466 if (atomic_read(&log_root_tree->log_commit[index2])) {
2467 blk_finish_plug(&plug);
2468 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2469 wait_log_commit(trans, log_root_tree,
2470 log_root_tree->log_transid);
2471 btrfs_free_logged_extents(log, log_transid);
2472 mutex_unlock(&log_root_tree->log_mutex);
2473 ret = 0;
2474 goto out;
2475 }
2476 atomic_set(&log_root_tree->log_commit[index2], 1);
2477
2478 if (atomic_read(&log_root_tree->log_commit[(index2 + 1) % 2])) {
2479 wait_log_commit(trans, log_root_tree,
2480 log_root_tree->log_transid - 1);
2481 }
2482
2483 wait_for_writer(trans, log_root_tree);
2484
2485
2486
2487
2488
2489 if (root->fs_info->last_trans_log_full_commit == trans->transid) {
2490 blk_finish_plug(&plug);
2491 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2492 btrfs_free_logged_extents(log, log_transid);
2493 mutex_unlock(&log_root_tree->log_mutex);
2494 ret = -EAGAIN;
2495 goto out_wake_log_root;
2496 }
2497
2498 ret = btrfs_write_marked_extents(log_root_tree,
2499 &log_root_tree->dirty_log_pages,
2500 EXTENT_DIRTY | EXTENT_NEW);
2501 blk_finish_plug(&plug);
2502 if (ret) {
2503 btrfs_abort_transaction(trans, root, ret);
2504 btrfs_free_logged_extents(log, log_transid);
2505 mutex_unlock(&log_root_tree->log_mutex);
2506 goto out_wake_log_root;
2507 }
2508 btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark);
2509 btrfs_wait_marked_extents(log_root_tree,
2510 &log_root_tree->dirty_log_pages,
2511 EXTENT_NEW | EXTENT_DIRTY);
2512 btrfs_wait_logged_extents(log, log_transid);
2513
2514 btrfs_set_super_log_root(root->fs_info->super_for_commit,
2515 log_root_tree->node->start);
2516 btrfs_set_super_log_root_level(root->fs_info->super_for_commit,
2517 btrfs_header_level(log_root_tree->node));
2518
2519 log_root_tree->log_transid++;
2520 smp_mb();
2521
2522 mutex_unlock(&log_root_tree->log_mutex);
2523
2524
2525
2526
2527
2528
2529
2530
2531 btrfs_scrub_pause_super(root);
2532 ret = write_ctree_super(trans, root->fs_info->tree_root, 1);
2533 btrfs_scrub_continue_super(root);
2534 if (ret) {
2535 btrfs_abort_transaction(trans, root, ret);
2536 goto out_wake_log_root;
2537 }
2538
2539 mutex_lock(&root->log_mutex);
2540 if (root->last_log_commit < log_transid)
2541 root->last_log_commit = log_transid;
2542 mutex_unlock(&root->log_mutex);
2543
2544out_wake_log_root:
2545 atomic_set(&log_root_tree->log_commit[index2], 0);
2546 smp_mb();
2547 if (waitqueue_active(&log_root_tree->log_commit_wait[index2]))
2548 wake_up(&log_root_tree->log_commit_wait[index2]);
2549out:
2550 atomic_set(&root->log_commit[index1], 0);
2551 smp_mb();
2552 if (waitqueue_active(&root->log_commit_wait[index1]))
2553 wake_up(&root->log_commit_wait[index1]);
2554 return ret;
2555}
2556
2557static void free_log_tree(struct btrfs_trans_handle *trans,
2558 struct btrfs_root *log)
2559{
2560 int ret;
2561 u64 start;
2562 u64 end;
2563 struct walk_control wc = {
2564 .free = 1,
2565 .process_func = process_one_buffer
2566 };
2567
2568 if (trans) {
2569 ret = walk_log_tree(trans, log, &wc);
2570
2571
2572 if (ret)
2573 btrfs_abort_transaction(trans, log, ret);
2574 }
2575
2576 while (1) {
2577 ret = find_first_extent_bit(&log->dirty_log_pages,
2578 0, &start, &end, EXTENT_DIRTY | EXTENT_NEW,
2579 NULL);
2580 if (ret)
2581 break;
2582
2583 clear_extent_bits(&log->dirty_log_pages, start, end,
2584 EXTENT_DIRTY | EXTENT_NEW, GFP_NOFS);
2585 }
2586
2587
2588
2589
2590
2591
2592 btrfs_free_logged_extents(log, 0);
2593 btrfs_free_logged_extents(log, 1);
2594
2595 free_extent_buffer(log->node);
2596 kfree(log);
2597}
2598
2599
2600
2601
2602
2603int btrfs_free_log(struct btrfs_trans_handle *trans, struct btrfs_root *root)
2604{
2605 if (root->log_root) {
2606 free_log_tree(trans, root->log_root);
2607 root->log_root = NULL;
2608 }
2609 return 0;
2610}
2611
2612int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
2613 struct btrfs_fs_info *fs_info)
2614{
2615 if (fs_info->log_root_tree) {
2616 free_log_tree(trans, fs_info->log_root_tree);
2617 fs_info->log_root_tree = NULL;
2618 }
2619 return 0;
2620}
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643int btrfs_del_dir_entries_in_log(struct btrfs_trans_handle *trans,
2644 struct btrfs_root *root,
2645 const char *name, int name_len,
2646 struct inode *dir, u64 index)
2647{
2648 struct btrfs_root *log;
2649 struct btrfs_dir_item *di;
2650 struct btrfs_path *path;
2651 int ret;
2652 int err = 0;
2653 int bytes_del = 0;
2654 u64 dir_ino = btrfs_ino(dir);
2655
2656 if (BTRFS_I(dir)->logged_trans < trans->transid)
2657 return 0;
2658
2659 ret = join_running_log_trans(root);
2660 if (ret)
2661 return 0;
2662
2663 mutex_lock(&BTRFS_I(dir)->log_mutex);
2664
2665 log = root->log_root;
2666 path = btrfs_alloc_path();
2667 if (!path) {
2668 err = -ENOMEM;
2669 goto out_unlock;
2670 }
2671
2672 di = btrfs_lookup_dir_item(trans, log, path, dir_ino,
2673 name, name_len, -1);
2674 if (IS_ERR(di)) {
2675 err = PTR_ERR(di);
2676 goto fail;
2677 }
2678 if (di) {
2679 ret = btrfs_delete_one_dir_name(trans, log, path, di);
2680 bytes_del += name_len;
2681 if (ret) {
2682 err = ret;
2683 goto fail;
2684 }
2685 }
2686 btrfs_release_path(path);
2687 di = btrfs_lookup_dir_index_item(trans, log, path, dir_ino,
2688 index, name, name_len, -1);
2689 if (IS_ERR(di)) {
2690 err = PTR_ERR(di);
2691 goto fail;
2692 }
2693 if (di) {
2694 ret = btrfs_delete_one_dir_name(trans, log, path, di);
2695 bytes_del += name_len;
2696 if (ret) {
2697 err = ret;
2698 goto fail;
2699 }
2700 }
2701
2702
2703
2704
2705 if (bytes_del) {
2706 struct btrfs_key key;
2707
2708 key.objectid = dir_ino;
2709 key.offset = 0;
2710 key.type = BTRFS_INODE_ITEM_KEY;
2711 btrfs_release_path(path);
2712
2713 ret = btrfs_search_slot(trans, log, &key, path, 0, 1);
2714 if (ret < 0) {
2715 err = ret;
2716 goto fail;
2717 }
2718 if (ret == 0) {
2719 struct btrfs_inode_item *item;
2720 u64 i_size;
2721
2722 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2723 struct btrfs_inode_item);
2724 i_size = btrfs_inode_size(path->nodes[0], item);
2725 if (i_size > bytes_del)
2726 i_size -= bytes_del;
2727 else
2728 i_size = 0;
2729 btrfs_set_inode_size(path->nodes[0], item, i_size);
2730 btrfs_mark_buffer_dirty(path->nodes[0]);
2731 } else
2732 ret = 0;
2733 btrfs_release_path(path);
2734 }
2735fail:
2736 btrfs_free_path(path);
2737out_unlock:
2738 mutex_unlock(&BTRFS_I(dir)->log_mutex);
2739 if (ret == -ENOSPC) {
2740 root->fs_info->last_trans_log_full_commit = trans->transid;
2741 ret = 0;
2742 } else if (ret < 0)
2743 btrfs_abort_transaction(trans, root, ret);
2744
2745 btrfs_end_log_trans(root);
2746
2747 return err;
2748}
2749
2750
2751int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans,
2752 struct btrfs_root *root,
2753 const char *name, int name_len,
2754 struct inode *inode, u64 dirid)
2755{
2756 struct btrfs_root *log;
2757 u64 index;
2758 int ret;
2759
2760 if (BTRFS_I(inode)->logged_trans < trans->transid)
2761 return 0;
2762
2763 ret = join_running_log_trans(root);
2764 if (ret)
2765 return 0;
2766 log = root->log_root;
2767 mutex_lock(&BTRFS_I(inode)->log_mutex);
2768
2769 ret = btrfs_del_inode_ref(trans, log, name, name_len, btrfs_ino(inode),
2770 dirid, &index);
2771 mutex_unlock(&BTRFS_I(inode)->log_mutex);
2772 if (ret == -ENOSPC) {
2773 root->fs_info->last_trans_log_full_commit = trans->transid;
2774 ret = 0;
2775 } else if (ret < 0 && ret != -ENOENT)
2776 btrfs_abort_transaction(trans, root, ret);
2777 btrfs_end_log_trans(root);
2778
2779 return ret;
2780}
2781
2782
2783
2784
2785
2786
2787static noinline int insert_dir_log_key(struct btrfs_trans_handle *trans,
2788 struct btrfs_root *log,
2789 struct btrfs_path *path,
2790 int key_type, u64 dirid,
2791 u64 first_offset, u64 last_offset)
2792{
2793 int ret;
2794 struct btrfs_key key;
2795 struct btrfs_dir_log_item *item;
2796
2797 key.objectid = dirid;
2798 key.offset = first_offset;
2799 if (key_type == BTRFS_DIR_ITEM_KEY)
2800 key.type = BTRFS_DIR_LOG_ITEM_KEY;
2801 else
2802 key.type = BTRFS_DIR_LOG_INDEX_KEY;
2803 ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*item));
2804 if (ret)
2805 return ret;
2806
2807 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2808 struct btrfs_dir_log_item);
2809 btrfs_set_dir_log_end(path->nodes[0], item, last_offset);
2810 btrfs_mark_buffer_dirty(path->nodes[0]);
2811 btrfs_release_path(path);
2812 return 0;
2813}
2814
2815
2816
2817
2818
2819
2820static noinline int log_dir_items(struct btrfs_trans_handle *trans,
2821 struct btrfs_root *root, struct inode *inode,
2822 struct btrfs_path *path,
2823 struct btrfs_path *dst_path, int key_type,
2824 u64 min_offset, u64 *last_offset_ret)
2825{
2826 struct btrfs_key min_key;
2827 struct btrfs_key max_key;
2828 struct btrfs_root *log = root->log_root;
2829 struct extent_buffer *src;
2830 int err = 0;
2831 int ret;
2832 int i;
2833 int nritems;
2834 u64 first_offset = min_offset;
2835 u64 last_offset = (u64)-1;
2836 u64 ino = btrfs_ino(inode);
2837
2838 log = root->log_root;
2839 max_key.objectid = ino;
2840 max_key.offset = (u64)-1;
2841 max_key.type = key_type;
2842
2843 min_key.objectid = ino;
2844 min_key.type = key_type;
2845 min_key.offset = min_offset;
2846
2847 path->keep_locks = 1;
2848
2849 ret = btrfs_search_forward(root, &min_key, &max_key,
2850 path, trans->transid);
2851
2852
2853
2854
2855
2856 if (ret != 0 || min_key.objectid != ino || min_key.type != key_type) {
2857 min_key.objectid = ino;
2858 min_key.type = key_type;
2859 min_key.offset = (u64)-1;
2860 btrfs_release_path(path);
2861 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
2862 if (ret < 0) {
2863 btrfs_release_path(path);
2864 return ret;
2865 }
2866 ret = btrfs_previous_item(root, path, ino, key_type);
2867
2868
2869
2870
2871
2872
2873 if (ret == 0) {
2874 struct btrfs_key tmp;
2875 btrfs_item_key_to_cpu(path->nodes[0], &tmp,
2876 path->slots[0]);
2877 if (key_type == tmp.type)
2878 first_offset = max(min_offset, tmp.offset) + 1;
2879 }
2880 goto done;
2881 }
2882
2883
2884 ret = btrfs_previous_item(root, path, ino, key_type);
2885 if (ret == 0) {
2886 struct btrfs_key tmp;
2887 btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
2888 if (key_type == tmp.type) {
2889 first_offset = tmp.offset;
2890 ret = overwrite_item(trans, log, dst_path,
2891 path->nodes[0], path->slots[0],
2892 &tmp);
2893 if (ret) {
2894 err = ret;
2895 goto done;
2896 }
2897 }
2898 }
2899 btrfs_release_path(path);
2900
2901
2902 ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
2903 if (ret != 0) {
2904 WARN_ON(1);
2905 goto done;
2906 }
2907
2908
2909
2910
2911
2912 while (1) {
2913 struct btrfs_key tmp;
2914 src = path->nodes[0];
2915 nritems = btrfs_header_nritems(src);
2916 for (i = path->slots[0]; i < nritems; i++) {
2917 btrfs_item_key_to_cpu(src, &min_key, i);
2918
2919 if (min_key.objectid != ino || min_key.type != key_type)
2920 goto done;
2921 ret = overwrite_item(trans, log, dst_path, src, i,
2922 &min_key);
2923 if (ret) {
2924 err = ret;
2925 goto done;
2926 }
2927 }
2928 path->slots[0] = nritems;
2929
2930
2931
2932
2933
2934 ret = btrfs_next_leaf(root, path);
2935 if (ret == 1) {
2936 last_offset = (u64)-1;
2937 goto done;
2938 }
2939 btrfs_item_key_to_cpu(path->nodes[0], &tmp, path->slots[0]);
2940 if (tmp.objectid != ino || tmp.type != key_type) {
2941 last_offset = (u64)-1;
2942 goto done;
2943 }
2944 if (btrfs_header_generation(path->nodes[0]) != trans->transid) {
2945 ret = overwrite_item(trans, log, dst_path,
2946 path->nodes[0], path->slots[0],
2947 &tmp);
2948 if (ret)
2949 err = ret;
2950 else
2951 last_offset = tmp.offset;
2952 goto done;
2953 }
2954 }
2955done:
2956 btrfs_release_path(path);
2957 btrfs_release_path(dst_path);
2958
2959 if (err == 0) {
2960 *last_offset_ret = last_offset;
2961
2962
2963
2964
2965 ret = insert_dir_log_key(trans, log, path, key_type,
2966 ino, first_offset, last_offset);
2967 if (ret)
2968 err = ret;
2969 }
2970 return err;
2971}
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985static noinline int log_directory_changes(struct btrfs_trans_handle *trans,
2986 struct btrfs_root *root, struct inode *inode,
2987 struct btrfs_path *path,
2988 struct btrfs_path *dst_path)
2989{
2990 u64 min_key;
2991 u64 max_key;
2992 int ret;
2993 int key_type = BTRFS_DIR_ITEM_KEY;
2994
2995again:
2996 min_key = 0;
2997 max_key = 0;
2998 while (1) {
2999 ret = log_dir_items(trans, root, inode, path,
3000 dst_path, key_type, min_key,
3001 &max_key);
3002 if (ret)
3003 return ret;
3004 if (max_key == (u64)-1)
3005 break;
3006 min_key = max_key + 1;
3007 }
3008
3009 if (key_type == BTRFS_DIR_ITEM_KEY) {
3010 key_type = BTRFS_DIR_INDEX_KEY;
3011 goto again;
3012 }
3013 return 0;
3014}
3015
3016
3017
3018
3019
3020
3021
3022static int drop_objectid_items(struct btrfs_trans_handle *trans,
3023 struct btrfs_root *log,
3024 struct btrfs_path *path,
3025 u64 objectid, int max_key_type)
3026{
3027 int ret;
3028 struct btrfs_key key;
3029 struct btrfs_key found_key;
3030 int start_slot;
3031
3032 key.objectid = objectid;
3033 key.type = max_key_type;
3034 key.offset = (u64)-1;
3035
3036 while (1) {
3037 ret = btrfs_search_slot(trans, log, &key, path, -1, 1);
3038 BUG_ON(ret == 0);
3039 if (ret < 0)
3040 break;
3041
3042 if (path->slots[0] == 0)
3043 break;
3044
3045 path->slots[0]--;
3046 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
3047 path->slots[0]);
3048
3049 if (found_key.objectid != objectid)
3050 break;
3051
3052 found_key.offset = 0;
3053 found_key.type = 0;
3054 ret = btrfs_bin_search(path->nodes[0], &found_key, 0,
3055 &start_slot);
3056
3057 ret = btrfs_del_items(trans, log, path, start_slot,
3058 path->slots[0] - start_slot + 1);
3059
3060
3061
3062
3063 if (ret || start_slot != 0)
3064 break;
3065 btrfs_release_path(path);
3066 }
3067 btrfs_release_path(path);
3068 if (ret > 0)
3069 ret = 0;
3070 return ret;
3071}
3072
3073static void fill_inode_item(struct btrfs_trans_handle *trans,
3074 struct extent_buffer *leaf,
3075 struct btrfs_inode_item *item,
3076 struct inode *inode, int log_inode_only)
3077{
3078 struct btrfs_map_token token;
3079
3080 btrfs_init_map_token(&token);
3081
3082 if (log_inode_only) {
3083
3084
3085
3086
3087
3088 btrfs_set_token_inode_generation(leaf, item, 0, &token);
3089 btrfs_set_token_inode_size(leaf, item, 0, &token);
3090 } else {
3091 btrfs_set_token_inode_generation(leaf, item,
3092 BTRFS_I(inode)->generation,
3093 &token);
3094 btrfs_set_token_inode_size(leaf, item, inode->i_size, &token);
3095 }
3096
3097 btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);
3098 btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);
3099 btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);
3100 btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);
3101
3102 btrfs_set_token_timespec_sec(leaf, btrfs_inode_atime(item),
3103 inode->i_atime.tv_sec, &token);
3104 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_atime(item),
3105 inode->i_atime.tv_nsec, &token);
3106
3107 btrfs_set_token_timespec_sec(leaf, btrfs_inode_mtime(item),
3108 inode->i_mtime.tv_sec, &token);
3109 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_mtime(item),
3110 inode->i_mtime.tv_nsec, &token);
3111
3112 btrfs_set_token_timespec_sec(leaf, btrfs_inode_ctime(item),
3113 inode->i_ctime.tv_sec, &token);
3114 btrfs_set_token_timespec_nsec(leaf, btrfs_inode_ctime(item),
3115 inode->i_ctime.tv_nsec, &token);
3116
3117 btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),
3118 &token);
3119
3120 btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token);
3121 btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);
3122 btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
3123 btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
3124 btrfs_set_token_inode_block_group(leaf, item, 0, &token);
3125}
3126
3127static int log_inode_item(struct btrfs_trans_handle *trans,
3128 struct btrfs_root *log, struct btrfs_path *path,
3129 struct inode *inode)
3130{
3131 struct btrfs_inode_item *inode_item;
3132 struct btrfs_key key;
3133 int ret;
3134
3135 memcpy(&key, &BTRFS_I(inode)->location, sizeof(key));
3136 ret = btrfs_insert_empty_item(trans, log, path, &key,
3137 sizeof(*inode_item));
3138 if (ret && ret != -EEXIST)
3139 return ret;
3140 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
3141 struct btrfs_inode_item);
3142 fill_inode_item(trans, path->nodes[0], inode_item, inode, 0);
3143 btrfs_release_path(path);
3144 return 0;
3145}
3146
3147static noinline int copy_items(struct btrfs_trans_handle *trans,
3148 struct inode *inode,
3149 struct btrfs_path *dst_path,
3150 struct extent_buffer *src,
3151 int start_slot, int nr, int inode_only)
3152{
3153 unsigned long src_offset;
3154 unsigned long dst_offset;
3155 struct btrfs_root *log = BTRFS_I(inode)->root->log_root;
3156 struct btrfs_file_extent_item *extent;
3157 struct btrfs_inode_item *inode_item;
3158 int ret;
3159 struct btrfs_key *ins_keys;
3160 u32 *ins_sizes;
3161 char *ins_data;
3162 int i;
3163 struct list_head ordered_sums;
3164 int skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
3165
3166 INIT_LIST_HEAD(&ordered_sums);
3167
3168 ins_data = kmalloc(nr * sizeof(struct btrfs_key) +
3169 nr * sizeof(u32), GFP_NOFS);
3170 if (!ins_data)
3171 return -ENOMEM;
3172
3173 ins_sizes = (u32 *)ins_data;
3174 ins_keys = (struct btrfs_key *)(ins_data + nr * sizeof(u32));
3175
3176 for (i = 0; i < nr; i++) {
3177 ins_sizes[i] = btrfs_item_size_nr(src, i + start_slot);
3178 btrfs_item_key_to_cpu(src, ins_keys + i, i + start_slot);
3179 }
3180 ret = btrfs_insert_empty_items(trans, log, dst_path,
3181 ins_keys, ins_sizes, nr);
3182 if (ret) {
3183 kfree(ins_data);
3184 return ret;
3185 }
3186
3187 for (i = 0; i < nr; i++, dst_path->slots[0]++) {
3188 dst_offset = btrfs_item_ptr_offset(dst_path->nodes[0],
3189 dst_path->slots[0]);
3190
3191 src_offset = btrfs_item_ptr_offset(src, start_slot + i);
3192
3193 if (ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
3194 inode_item = btrfs_item_ptr(dst_path->nodes[0],
3195 dst_path->slots[0],
3196 struct btrfs_inode_item);
3197 fill_inode_item(trans, dst_path->nodes[0], inode_item,
3198 inode, inode_only == LOG_INODE_EXISTS);
3199 } else {
3200 copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
3201 src_offset, ins_sizes[i]);
3202 }
3203
3204
3205
3206
3207
3208 if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY &&
3209 !skip_csum) {
3210 int found_type;
3211 extent = btrfs_item_ptr(src, start_slot + i,
3212 struct btrfs_file_extent_item);
3213
3214 if (btrfs_file_extent_generation(src, extent) < trans->transid)
3215 continue;
3216
3217 found_type = btrfs_file_extent_type(src, extent);
3218 if (found_type == BTRFS_FILE_EXTENT_REG) {
3219 u64 ds, dl, cs, cl;
3220 ds = btrfs_file_extent_disk_bytenr(src,
3221 extent);
3222
3223 if (ds == 0)
3224 continue;
3225
3226 dl = btrfs_file_extent_disk_num_bytes(src,
3227 extent);
3228 cs = btrfs_file_extent_offset(src, extent);
3229 cl = btrfs_file_extent_num_bytes(src,
3230 extent);
3231 if (btrfs_file_extent_compression(src,
3232 extent)) {
3233 cs = 0;
3234 cl = dl;
3235 }
3236
3237 ret = btrfs_lookup_csums_range(
3238 log->fs_info->csum_root,
3239 ds + cs, ds + cs + cl - 1,
3240 &ordered_sums, 0);
3241 if (ret) {
3242 btrfs_release_path(dst_path);
3243 kfree(ins_data);
3244 return ret;
3245 }
3246 }
3247 }
3248 }
3249
3250 btrfs_mark_buffer_dirty(dst_path->nodes[0]);
3251 btrfs_release_path(dst_path);
3252 kfree(ins_data);
3253
3254
3255
3256
3257
3258 ret = 0;
3259 while (!list_empty(&ordered_sums)) {
3260 struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
3261 struct btrfs_ordered_sum,
3262 list);
3263 if (!ret)
3264 ret = btrfs_csum_file_blocks(trans, log, sums);
3265 list_del(&sums->list);
3266 kfree(sums);
3267 }
3268 return ret;
3269}
3270
3271static int extent_cmp(void *priv, struct list_head *a, struct list_head *b)
3272{
3273 struct extent_map *em1, *em2;
3274
3275 em1 = list_entry(a, struct extent_map, list);
3276 em2 = list_entry(b, struct extent_map, list);
3277
3278 if (em1->start < em2->start)
3279 return -1;
3280 else if (em1->start > em2->start)
3281 return 1;
3282 return 0;
3283}
3284
3285static int log_one_extent(struct btrfs_trans_handle *trans,
3286 struct inode *inode, struct btrfs_root *root,
3287 struct extent_map *em, struct btrfs_path *path)
3288{
3289 struct btrfs_root *log = root->log_root;
3290 struct btrfs_file_extent_item *fi;
3291 struct extent_buffer *leaf;
3292 struct btrfs_ordered_extent *ordered;
3293 struct list_head ordered_sums;
3294 struct btrfs_map_token token;
3295 struct btrfs_key key;
3296 u64 mod_start = em->mod_start;
3297 u64 mod_len = em->mod_len;
3298 u64 csum_offset;
3299 u64 csum_len;
3300 u64 extent_offset = em->start - em->orig_start;
3301 u64 block_len;
3302 int ret;
3303 int index = log->log_transid % 2;
3304 bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
3305
3306 ret = __btrfs_drop_extents(trans, log, inode, path, em->start,
3307 em->start + em->len, NULL, 0);
3308 if (ret)
3309 return ret;
3310
3311 INIT_LIST_HEAD(&ordered_sums);
3312 btrfs_init_map_token(&token);
3313 key.objectid = btrfs_ino(inode);
3314 key.type = BTRFS_EXTENT_DATA_KEY;
3315 key.offset = em->start;
3316
3317 ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*fi));
3318 if (ret)
3319 return ret;
3320 leaf = path->nodes[0];
3321 fi = btrfs_item_ptr(leaf, path->slots[0],
3322 struct btrfs_file_extent_item);
3323
3324 btrfs_set_token_file_extent_generation(leaf, fi, em->generation,
3325 &token);
3326 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
3327 skip_csum = true;
3328 btrfs_set_token_file_extent_type(leaf, fi,
3329 BTRFS_FILE_EXTENT_PREALLOC,
3330 &token);
3331 } else {
3332 btrfs_set_token_file_extent_type(leaf, fi,
3333 BTRFS_FILE_EXTENT_REG,
3334 &token);
3335 if (em->block_start == 0)
3336 skip_csum = true;
3337 }
3338
3339 block_len = max(em->block_len, em->orig_block_len);
3340 if (em->compress_type != BTRFS_COMPRESS_NONE) {
3341 btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
3342 em->block_start,
3343 &token);
3344 btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
3345 &token);
3346 } else if (em->block_start < EXTENT_MAP_LAST_BYTE) {
3347 btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
3348 em->block_start -
3349 extent_offset, &token);
3350 btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
3351 &token);
3352 } else {
3353 btrfs_set_token_file_extent_disk_bytenr(leaf, fi, 0, &token);
3354 btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, 0,
3355 &token);
3356 }
3357
3358 btrfs_set_token_file_extent_offset(leaf, fi,
3359 em->start - em->orig_start,
3360 &token);
3361 btrfs_set_token_file_extent_num_bytes(leaf, fi, em->len, &token);
3362 btrfs_set_token_file_extent_ram_bytes(leaf, fi, em->ram_bytes, &token);
3363 btrfs_set_token_file_extent_compression(leaf, fi, em->compress_type,
3364 &token);
3365 btrfs_set_token_file_extent_encryption(leaf, fi, 0, &token);
3366 btrfs_set_token_file_extent_other_encoding(leaf, fi, 0, &token);
3367 btrfs_mark_buffer_dirty(leaf);
3368
3369 btrfs_release_path(path);
3370 if (ret) {
3371 return ret;
3372 }
3373
3374 if (skip_csum)
3375 return 0;
3376
3377 if (em->compress_type) {
3378 csum_offset = 0;
3379 csum_len = block_len;
3380 }
3381
3382
3383
3384
3385
3386again:
3387 spin_lock_irq(&log->log_extents_lock[index]);
3388 list_for_each_entry(ordered, &log->logged_list[index], log_list) {
3389 struct btrfs_ordered_sum *sum;
3390
3391 if (!mod_len)
3392 break;
3393
3394 if (ordered->inode != inode)
3395 continue;
3396
3397 if (ordered->file_offset + ordered->len <= mod_start ||
3398 mod_start + mod_len <= ordered->file_offset)
3399 continue;
3400
3401
3402
3403
3404
3405
3406 if (ordered->file_offset > mod_start) {
3407 if (ordered->file_offset + ordered->len >=
3408 mod_start + mod_len)
3409 mod_len = ordered->file_offset - mod_start;
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420 } else {
3421 if (ordered->file_offset + ordered->len <
3422 mod_start + mod_len) {
3423 mod_len = (mod_start + mod_len) -
3424 (ordered->file_offset + ordered->len);
3425 mod_start = ordered->file_offset +
3426 ordered->len;
3427 } else {
3428 mod_len = 0;
3429 }
3430 }
3431
3432
3433
3434
3435
3436 if (test_and_set_bit(BTRFS_ORDERED_LOGGED_CSUM,
3437 &ordered->flags))
3438 continue;
3439 atomic_inc(&ordered->refs);
3440 spin_unlock_irq(&log->log_extents_lock[index]);
3441
3442
3443
3444
3445
3446 wait_event(ordered->wait, ordered->csum_bytes_left == 0);
3447
3448 list_for_each_entry(sum, &ordered->list, list) {
3449 ret = btrfs_csum_file_blocks(trans, log, sum);
3450 if (ret) {
3451 btrfs_put_ordered_extent(ordered);
3452 goto unlocked;
3453 }
3454 }
3455 btrfs_put_ordered_extent(ordered);
3456 goto again;
3457
3458 }
3459 spin_unlock_irq(&log->log_extents_lock[index]);
3460unlocked:
3461
3462 if (!mod_len || ret)
3463 return ret;
3464
3465 csum_offset = mod_start - em->start;
3466 csum_len = mod_len;
3467
3468
3469 ret = btrfs_lookup_csums_range(log->fs_info->csum_root,
3470 em->block_start + csum_offset,
3471 em->block_start + csum_offset +
3472 csum_len - 1, &ordered_sums, 0);
3473 if (ret)
3474 return ret;
3475
3476 while (!list_empty(&ordered_sums)) {
3477 struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
3478 struct btrfs_ordered_sum,
3479 list);
3480 if (!ret)
3481 ret = btrfs_csum_file_blocks(trans, log, sums);
3482 list_del(&sums->list);
3483 kfree(sums);
3484 }
3485
3486 return ret;
3487}
3488
3489static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
3490 struct btrfs_root *root,
3491 struct inode *inode,
3492 struct btrfs_path *path)
3493{
3494 struct extent_map *em, *n;
3495 struct list_head extents;
3496 struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
3497 u64 test_gen;
3498 int ret = 0;
3499 int num = 0;
3500
3501 INIT_LIST_HEAD(&extents);
3502
3503 write_lock(&tree->lock);
3504 test_gen = root->fs_info->last_trans_committed;
3505
3506 list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
3507 list_del_init(&em->list);
3508
3509
3510
3511
3512
3513
3514
3515 if (++num > 32768) {
3516 list_del_init(&tree->modified_extents);
3517 ret = -EFBIG;
3518 goto process;
3519 }
3520
3521 if (em->generation <= test_gen)
3522 continue;
3523
3524 atomic_inc(&em->refs);
3525 set_bit(EXTENT_FLAG_LOGGING, &em->flags);
3526 list_add_tail(&em->list, &extents);
3527 num++;
3528 }
3529
3530 list_sort(NULL, &extents, extent_cmp);
3531
3532process:
3533 while (!list_empty(&extents)) {
3534 em = list_entry(extents.next, struct extent_map, list);
3535
3536 list_del_init(&em->list);
3537
3538
3539
3540
3541
3542 if (ret) {
3543 clear_em_logging(tree, em);
3544 free_extent_map(em);
3545 continue;
3546 }
3547
3548 write_unlock(&tree->lock);
3549
3550 ret = log_one_extent(trans, inode, root, em, path);
3551 write_lock(&tree->lock);
3552 clear_em_logging(tree, em);
3553 free_extent_map(em);
3554 }
3555 WARN_ON(!list_empty(&extents));
3556 write_unlock(&tree->lock);
3557
3558 btrfs_release_path(path);
3559 return ret;
3560}
3561
3562
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576static int btrfs_log_inode(struct btrfs_trans_handle *trans,
3577 struct btrfs_root *root, struct inode *inode,
3578 int inode_only)
3579{
3580 struct btrfs_path *path;
3581 struct btrfs_path *dst_path;
3582 struct btrfs_key min_key;
3583 struct btrfs_key max_key;
3584 struct btrfs_root *log = root->log_root;
3585 struct extent_buffer *src = NULL;
3586 int err = 0;
3587 int ret;
3588 int nritems;
3589 int ins_start_slot = 0;
3590 int ins_nr;
3591 bool fast_search = false;
3592 u64 ino = btrfs_ino(inode);
3593
3594 path = btrfs_alloc_path();
3595 if (!path)
3596 return -ENOMEM;
3597 dst_path = btrfs_alloc_path();
3598 if (!dst_path) {
3599 btrfs_free_path(path);
3600 return -ENOMEM;
3601 }
3602
3603 min_key.objectid = ino;
3604 min_key.type = BTRFS_INODE_ITEM_KEY;
3605 min_key.offset = 0;
3606
3607 max_key.objectid = ino;
3608
3609
3610
3611 if (S_ISDIR(inode->i_mode) ||
3612 (!test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3613 &BTRFS_I(inode)->runtime_flags) &&
3614 inode_only == LOG_INODE_EXISTS))
3615 max_key.type = BTRFS_XATTR_ITEM_KEY;
3616 else
3617 max_key.type = (u8)-1;
3618 max_key.offset = (u64)-1;
3619
3620
3621 if (S_ISDIR(inode->i_mode) ||
3622 BTRFS_I(inode)->generation > root->fs_info->last_trans_committed) {
3623 ret = btrfs_commit_inode_delayed_items(trans, inode);
3624 if (ret) {
3625 btrfs_free_path(path);
3626 btrfs_free_path(dst_path);
3627 return ret;
3628 }
3629 }
3630
3631 mutex_lock(&BTRFS_I(inode)->log_mutex);
3632
3633 btrfs_get_logged_extents(log, inode);
3634
3635
3636
3637
3638
3639 if (S_ISDIR(inode->i_mode)) {
3640 int max_key_type = BTRFS_DIR_LOG_INDEX_KEY;
3641
3642 if (inode_only == LOG_INODE_EXISTS)
3643 max_key_type = BTRFS_XATTR_ITEM_KEY;
3644 ret = drop_objectid_items(trans, log, path, ino, max_key_type);
3645 } else {
3646 if (test_and_clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
3647 &BTRFS_I(inode)->runtime_flags)) {
3648 clear_bit(BTRFS_INODE_COPY_EVERYTHING,
3649 &BTRFS_I(inode)->runtime_flags);
3650 ret = btrfs_truncate_inode_items(trans, log,
3651 inode, 0, 0);
3652 } else if (test_and_clear_bit(BTRFS_INODE_COPY_EVERYTHING,
3653 &BTRFS_I(inode)->runtime_flags)) {
3654 if (inode_only == LOG_INODE_ALL)
3655 fast_search = true;
3656 max_key.type = BTRFS_XATTR_ITEM_KEY;
3657 ret = drop_objectid_items(trans, log, path, ino,
3658 max_key.type);
3659 } else {
3660 if (inode_only == LOG_INODE_ALL)
3661 fast_search = true;
3662 ret = log_inode_item(trans, log, dst_path, inode);
3663 if (ret) {
3664 err = ret;
3665 goto out_unlock;
3666 }
3667 goto log_extents;
3668 }
3669
3670 }
3671 if (ret) {
3672 err = ret;
3673 goto out_unlock;
3674 }
3675 path->keep_locks = 1;
3676
3677 while (1) {
3678 ins_nr = 0;
3679 ret = btrfs_search_forward(root, &min_key, &max_key,
3680 path, trans->transid);
3681 if (ret != 0)
3682 break;
3683again:
3684
3685 if (min_key.objectid != ino)
3686 break;
3687 if (min_key.type > max_key.type)
3688 break;
3689
3690 src = path->nodes[0];
3691 if (ins_nr && ins_start_slot + ins_nr == path->slots[0]) {
3692 ins_nr++;
3693 goto next_slot;
3694 } else if (!ins_nr) {
3695 ins_start_slot = path->slots[0];
3696 ins_nr = 1;
3697 goto next_slot;
3698 }
3699
3700 ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
3701 ins_nr, inode_only);
3702 if (ret) {
3703 err = ret;
3704 goto out_unlock;
3705 }
3706 ins_nr = 1;
3707 ins_start_slot = path->slots[0];
3708next_slot:
3709
3710 nritems = btrfs_header_nritems(path->nodes[0]);
3711 path->slots[0]++;
3712 if (path->slots[0] < nritems) {
3713 btrfs_item_key_to_cpu(path->nodes[0], &min_key,
3714 path->slots[0]);
3715 goto again;
3716 }
3717 if (ins_nr) {
3718 ret = copy_items(trans, inode, dst_path, src,
3719 ins_start_slot,
3720 ins_nr, inode_only);
3721 if (ret) {
3722 err = ret;
3723 goto out_unlock;
3724 }
3725 ins_nr = 0;
3726 }
3727 btrfs_release_path(path);
3728
3729 if (min_key.offset < (u64)-1)
3730 min_key.offset++;
3731 else if (min_key.type < (u8)-1)
3732 min_key.type++;
3733 else if (min_key.objectid < (u64)-1)
3734 min_key.objectid++;
3735 else
3736 break;
3737 }
3738 if (ins_nr) {
3739 ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
3740 ins_nr, inode_only);
3741 if (ret) {
3742 err = ret;
3743 goto out_unlock;
3744 }
3745 ins_nr = 0;
3746 }
3747
3748log_extents:
3749 btrfs_release_path(path);
3750 btrfs_release_path(dst_path);
3751 if (fast_search) {
3752 ret = btrfs_log_changed_extents(trans, root, inode, dst_path);
3753 if (ret) {
3754 err = ret;
3755 goto out_unlock;
3756 }
3757 } else {
3758 struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
3759 struct extent_map *em, *n;
3760
3761 write_lock(&tree->lock);
3762 list_for_each_entry_safe(em, n, &tree->modified_extents, list)
3763 list_del_init(&em->list);
3764 write_unlock(&tree->lock);
3765 }
3766
3767 if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
3768 ret = log_directory_changes(trans, root, inode, path, dst_path);
3769 if (ret) {
3770 err = ret;
3771 goto out_unlock;
3772 }
3773 }
3774 BTRFS_I(inode)->logged_trans = trans->transid;
3775 BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->last_sub_trans;
3776out_unlock:
3777 if (err)
3778 btrfs_free_logged_extents(log, log->log_transid);
3779 mutex_unlock(&BTRFS_I(inode)->log_mutex);
3780
3781 btrfs_free_path(path);
3782 btrfs_free_path(dst_path);
3783 return err;
3784}
3785
3786
3787
3788
3789
3790
3791
3792static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
3793 struct inode *inode,
3794 struct dentry *parent,
3795 struct super_block *sb,
3796 u64 last_committed)
3797{
3798 int ret = 0;
3799 struct btrfs_root *root;
3800 struct dentry *old_parent = NULL;
3801
3802
3803
3804
3805
3806
3807
3808 if (S_ISREG(inode->i_mode) &&
3809 BTRFS_I(inode)->generation <= last_committed &&
3810 BTRFS_I(inode)->last_unlink_trans <= last_committed)
3811 goto out;
3812
3813 if (!S_ISDIR(inode->i_mode)) {
3814 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
3815 goto out;
3816 inode = parent->d_inode;
3817 }
3818
3819 while (1) {
3820 BTRFS_I(inode)->logged_trans = trans->transid;
3821 smp_mb();
3822
3823 if (BTRFS_I(inode)->last_unlink_trans > last_committed) {
3824 root = BTRFS_I(inode)->root;
3825
3826
3827
3828
3829
3830 root->fs_info->last_trans_log_full_commit =
3831 trans->transid;
3832 ret = 1;
3833 break;
3834 }
3835
3836 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
3837 break;
3838
3839 if (IS_ROOT(parent))
3840 break;
3841
3842 parent = dget_parent(parent);
3843 dput(old_parent);
3844 old_parent = parent;
3845 inode = parent->d_inode;
3846
3847 }
3848 dput(old_parent);
3849out:
3850 return ret;
3851}
3852
3853
3854
3855
3856
3857
3858
3859static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
3860 struct btrfs_root *root, struct inode *inode,
3861 struct dentry *parent, int exists_only)
3862{
3863 int inode_only = exists_only ? LOG_INODE_EXISTS : LOG_INODE_ALL;
3864 struct super_block *sb;
3865 struct dentry *old_parent = NULL;
3866 int ret = 0;
3867 u64 last_committed = root->fs_info->last_trans_committed;
3868
3869 sb = inode->i_sb;
3870
3871 if (btrfs_test_opt(root, NOTREELOG)) {
3872 ret = 1;
3873 goto end_no_trans;
3874 }
3875
3876 if (root->fs_info->last_trans_log_full_commit >
3877 root->fs_info->last_trans_committed) {
3878 ret = 1;
3879 goto end_no_trans;
3880 }
3881
3882 if (root != BTRFS_I(inode)->root ||
3883 btrfs_root_refs(&root->root_item) == 0) {
3884 ret = 1;
3885 goto end_no_trans;
3886 }
3887
3888 ret = check_parent_dirs_for_sync(trans, inode, parent,
3889 sb, last_committed);
3890 if (ret)
3891 goto end_no_trans;
3892
3893 if (btrfs_inode_in_log(inode, trans->transid)) {
3894 ret = BTRFS_NO_LOG_SYNC;
3895 goto end_no_trans;
3896 }
3897
3898 ret = start_log_trans(trans, root);
3899 if (ret)
3900 goto end_trans;
3901
3902 ret = btrfs_log_inode(trans, root, inode, inode_only);
3903 if (ret)
3904 goto end_trans;
3905
3906
3907
3908
3909
3910
3911
3912 if (S_ISREG(inode->i_mode) &&
3913 BTRFS_I(inode)->generation <= last_committed &&
3914 BTRFS_I(inode)->last_unlink_trans <= last_committed) {
3915 ret = 0;
3916 goto end_trans;
3917 }
3918
3919 inode_only = LOG_INODE_EXISTS;
3920 while (1) {
3921 if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb)
3922 break;
3923
3924 inode = parent->d_inode;
3925 if (root != BTRFS_I(inode)->root)
3926 break;
3927
3928 if (BTRFS_I(inode)->generation >
3929 root->fs_info->last_trans_committed) {
3930 ret = btrfs_log_inode(trans, root, inode, inode_only);
3931 if (ret)
3932 goto end_trans;
3933 }
3934 if (IS_ROOT(parent))
3935 break;
3936
3937 parent = dget_parent(parent);
3938 dput(old_parent);
3939 old_parent = parent;
3940 }
3941 ret = 0;
3942end_trans:
3943 dput(old_parent);
3944 if (ret < 0) {
3945 root->fs_info->last_trans_log_full_commit = trans->transid;
3946 ret = 1;
3947 }
3948 btrfs_end_log_trans(root);
3949end_no_trans:
3950 return ret;
3951}
3952
3953
3954
3955
3956
3957
3958
3959int btrfs_log_dentry_safe(struct btrfs_trans_handle *trans,
3960 struct btrfs_root *root, struct dentry *dentry)
3961{
3962 struct dentry *parent = dget_parent(dentry);
3963 int ret;
3964
3965 ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent, 0);
3966 dput(parent);
3967
3968 return ret;
3969}
3970
3971
3972
3973
3974
3975int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
3976{
3977 int ret;
3978 struct btrfs_path *path;
3979 struct btrfs_trans_handle *trans;
3980 struct btrfs_key key;
3981 struct btrfs_key found_key;
3982 struct btrfs_key tmp_key;
3983 struct btrfs_root *log;
3984 struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
3985 struct walk_control wc = {
3986 .process_func = process_one_buffer,
3987 .stage = 0,
3988 };
3989
3990 path = btrfs_alloc_path();
3991 if (!path)
3992 return -ENOMEM;
3993
3994 fs_info->log_root_recovering = 1;
3995
3996 trans = btrfs_start_transaction(fs_info->tree_root, 0);
3997 if (IS_ERR(trans)) {
3998 ret = PTR_ERR(trans);
3999 goto error;
4000 }
4001
4002 wc.trans = trans;
4003 wc.pin = 1;
4004
4005 ret = walk_log_tree(trans, log_root_tree, &wc);
4006 if (ret) {
4007 btrfs_error(fs_info, ret, "Failed to pin buffers while "
4008 "recovering log root tree.");
4009 goto error;
4010 }
4011
4012again:
4013 key.objectid = BTRFS_TREE_LOG_OBJECTID;
4014 key.offset = (u64)-1;
4015 btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
4016
4017 while (1) {
4018 ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0);
4019
4020 if (ret < 0) {
4021 btrfs_error(fs_info, ret,
4022 "Couldn't find tree log root.");
4023 goto error;
4024 }
4025 if (ret > 0) {
4026 if (path->slots[0] == 0)
4027 break;
4028 path->slots[0]--;
4029 }
4030 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
4031 path->slots[0]);
4032 btrfs_release_path(path);
4033 if (found_key.objectid != BTRFS_TREE_LOG_OBJECTID)
4034 break;
4035
4036 log = btrfs_read_fs_root(log_root_tree, &found_key);
4037 if (IS_ERR(log)) {
4038 ret = PTR_ERR(log);
4039 btrfs_error(fs_info, ret,
4040 "Couldn't read tree log root.");
4041 goto error;
4042 }
4043
4044 tmp_key.objectid = found_key.offset;
4045 tmp_key.type = BTRFS_ROOT_ITEM_KEY;
4046 tmp_key.offset = (u64)-1;
4047
4048 wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key);
4049 if (IS_ERR(wc.replay_dest)) {
4050 ret = PTR_ERR(wc.replay_dest);
4051 free_extent_buffer(log->node);
4052 free_extent_buffer(log->commit_root);
4053 kfree(log);
4054 btrfs_error(fs_info, ret, "Couldn't read target root "
4055 "for tree log recovery.");
4056 goto error;
4057 }
4058
4059 wc.replay_dest->log_root = log;
4060 btrfs_record_root_in_trans(trans, wc.replay_dest);
4061 ret = walk_log_tree(trans, log, &wc);
4062
4063 if (!ret && wc.stage == LOG_WALK_REPLAY_ALL) {
4064 ret = fixup_inode_link_counts(trans, wc.replay_dest,
4065 path);
4066 }
4067
4068 key.offset = found_key.offset - 1;
4069 wc.replay_dest->log_root = NULL;
4070 free_extent_buffer(log->node);
4071 free_extent_buffer(log->commit_root);
4072 kfree(log);
4073
4074 if (ret)
4075 goto error;
4076
4077 if (found_key.offset == 0)
4078 break;
4079 }
4080 btrfs_release_path(path);
4081
4082
4083 if (wc.pin) {
4084 wc.pin = 0;
4085 wc.process_func = replay_one_buffer;
4086 wc.stage = LOG_WALK_REPLAY_INODES;
4087 goto again;
4088 }
4089
4090 if (wc.stage < LOG_WALK_REPLAY_ALL) {
4091 wc.stage++;
4092 goto again;
4093 }
4094
4095 btrfs_free_path(path);
4096
4097
4098 ret = btrfs_commit_transaction(trans, fs_info->tree_root);
4099 if (ret)
4100 return ret;
4101
4102 free_extent_buffer(log_root_tree->node);
4103 log_root_tree->log_root = NULL;
4104 fs_info->log_root_recovering = 0;
4105 kfree(log_root_tree);
4106
4107 return 0;
4108error:
4109 if (wc.trans)
4110 btrfs_end_transaction(wc.trans, fs_info->tree_root);
4111 btrfs_free_path(path);
4112 return ret;
4113}
4114
4115
4116
4117
4118
4119
4120
4121
4122
4123void btrfs_record_unlink_dir(struct btrfs_trans_handle *trans,
4124 struct inode *dir, struct inode *inode,
4125 int for_rename)
4126{
4127
4128
4129
4130
4131
4132
4133
4134
4135
4136
4137 if (S_ISREG(inode->i_mode))
4138 BTRFS_I(inode)->last_unlink_trans = trans->transid;
4139
4140
4141
4142
4143
4144 smp_mb();
4145 if (BTRFS_I(dir)->logged_trans == trans->transid)
4146 return;
4147
4148
4149
4150
4151
4152 if (BTRFS_I(inode)->logged_trans == trans->transid)
4153 return;
4154
4155
4156
4157
4158
4159
4160
4161
4162 if (for_rename)
4163 goto record;
4164
4165
4166 return;
4167
4168record:
4169 BTRFS_I(dir)->last_unlink_trans = trans->transid;
4170}
4171
4172
4173
4174
4175
4176
4177
4178
4179int btrfs_log_new_name(struct btrfs_trans_handle *trans,
4180 struct inode *inode, struct inode *old_dir,
4181 struct dentry *parent)
4182{
4183 struct btrfs_root * root = BTRFS_I(inode)->root;
4184
4185
4186
4187
4188
4189 if (S_ISREG(inode->i_mode))
4190 BTRFS_I(inode)->last_unlink_trans = trans->transid;
4191
4192
4193
4194
4195
4196 if (BTRFS_I(inode)->logged_trans <=
4197 root->fs_info->last_trans_committed &&
4198 (!old_dir || BTRFS_I(old_dir)->logged_trans <=
4199 root->fs_info->last_trans_committed))
4200 return 0;
4201
4202 return btrfs_log_inode_parent(trans, root, inode, parent, 1);
4203}
4204
4205