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