1
2
3
4
5
6
7
8
9
10#include "ubifs.h"
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43static int dbg_check_orphans(struct ubifs_info *c);
44
45static struct ubifs_orphan *orphan_add(struct ubifs_info *c, ino_t inum,
46 struct ubifs_orphan *parent_orphan)
47{
48 struct ubifs_orphan *orphan, *o;
49 struct rb_node **p, *parent = NULL;
50
51 orphan = kzalloc(sizeof(struct ubifs_orphan), GFP_NOFS);
52 if (!orphan)
53 return ERR_PTR(-ENOMEM);
54 orphan->inum = inum;
55 orphan->new = 1;
56 INIT_LIST_HEAD(&orphan->child_list);
57
58 spin_lock(&c->orphan_lock);
59 if (c->tot_orphans >= c->max_orphans) {
60 spin_unlock(&c->orphan_lock);
61 kfree(orphan);
62 return ERR_PTR(-ENFILE);
63 }
64 p = &c->orph_tree.rb_node;
65 while (*p) {
66 parent = *p;
67 o = rb_entry(parent, struct ubifs_orphan, rb);
68 if (inum < o->inum)
69 p = &(*p)->rb_left;
70 else if (inum > o->inum)
71 p = &(*p)->rb_right;
72 else {
73 ubifs_err(c, "orphaned twice");
74 spin_unlock(&c->orphan_lock);
75 kfree(orphan);
76 return ERR_PTR(-EINVAL);
77 }
78 }
79 c->tot_orphans += 1;
80 c->new_orphans += 1;
81 rb_link_node(&orphan->rb, parent, p);
82 rb_insert_color(&orphan->rb, &c->orph_tree);
83 list_add_tail(&orphan->list, &c->orph_list);
84 list_add_tail(&orphan->new_list, &c->orph_new);
85
86 if (parent_orphan) {
87 list_add_tail(&orphan->child_list,
88 &parent_orphan->child_list);
89 }
90
91 spin_unlock(&c->orphan_lock);
92 dbg_gen("ino %lu", (unsigned long)inum);
93 return orphan;
94}
95
96static struct ubifs_orphan *lookup_orphan(struct ubifs_info *c, ino_t inum)
97{
98 struct ubifs_orphan *o;
99 struct rb_node *p;
100
101 p = c->orph_tree.rb_node;
102 while (p) {
103 o = rb_entry(p, struct ubifs_orphan, rb);
104 if (inum < o->inum)
105 p = p->rb_left;
106 else if (inum > o->inum)
107 p = p->rb_right;
108 else {
109 return o;
110 }
111 }
112 return NULL;
113}
114
115static void __orphan_drop(struct ubifs_info *c, struct ubifs_orphan *o)
116{
117 rb_erase(&o->rb, &c->orph_tree);
118 list_del(&o->list);
119 c->tot_orphans -= 1;
120
121 if (o->new) {
122 list_del(&o->new_list);
123 c->new_orphans -= 1;
124 }
125
126 kfree(o);
127}
128
129static void orphan_delete(struct ubifs_info *c, struct ubifs_orphan *orph)
130{
131 if (orph->del) {
132 dbg_gen("deleted twice ino %lu", orph->inum);
133 return;
134 }
135
136 if (orph->cmt) {
137 orph->del = 1;
138 orph->dnext = c->orph_dnext;
139 c->orph_dnext = orph;
140 dbg_gen("delete later ino %lu", orph->inum);
141 return;
142 }
143
144 __orphan_drop(c, orph);
145}
146
147
148
149
150
151
152
153
154
155int ubifs_add_orphan(struct ubifs_info *c, ino_t inum)
156{
157 int err = 0;
158 ino_t xattr_inum;
159 union ubifs_key key;
160 struct ubifs_dent_node *xent;
161 struct fscrypt_name nm = {0};
162 struct ubifs_orphan *xattr_orphan;
163 struct ubifs_orphan *orphan;
164
165 orphan = orphan_add(c, inum, NULL);
166 if (IS_ERR(orphan))
167 return PTR_ERR(orphan);
168
169 lowest_xent_key(c, &key, inum);
170 while (1) {
171 xent = ubifs_tnc_next_ent(c, &key, &nm);
172 if (IS_ERR(xent)) {
173 err = PTR_ERR(xent);
174 if (err == -ENOENT)
175 break;
176 return err;
177 }
178
179 fname_name(&nm) = xent->name;
180 fname_len(&nm) = le16_to_cpu(xent->nlen);
181 xattr_inum = le64_to_cpu(xent->inum);
182
183 xattr_orphan = orphan_add(c, xattr_inum, orphan);
184 if (IS_ERR(xattr_orphan))
185 return PTR_ERR(xattr_orphan);
186
187 key_read(c, &xent->key, &key);
188 }
189
190 return 0;
191}
192
193
194
195
196
197
198
199
200void ubifs_delete_orphan(struct ubifs_info *c, ino_t inum)
201{
202 struct ubifs_orphan *orph, *child_orph, *tmp_o;
203
204 spin_lock(&c->orphan_lock);
205
206 orph = lookup_orphan(c, inum);
207 if (!orph) {
208 spin_unlock(&c->orphan_lock);
209 ubifs_err(c, "missing orphan ino %lu", (unsigned long)inum);
210 dump_stack();
211
212 return;
213 }
214
215 list_for_each_entry_safe(child_orph, tmp_o, &orph->child_list, child_list) {
216 list_del(&child_orph->child_list);
217 orphan_delete(c, child_orph);
218 }
219
220 orphan_delete(c, orph);
221
222 spin_unlock(&c->orphan_lock);
223}
224
225
226
227
228
229
230
231int ubifs_orphan_start_commit(struct ubifs_info *c)
232{
233 struct ubifs_orphan *orphan, **last;
234
235 spin_lock(&c->orphan_lock);
236 last = &c->orph_cnext;
237 list_for_each_entry(orphan, &c->orph_new, new_list) {
238 ubifs_assert(c, orphan->new);
239 ubifs_assert(c, !orphan->cmt);
240 orphan->new = 0;
241 orphan->cmt = 1;
242 *last = orphan;
243 last = &orphan->cnext;
244 }
245 *last = NULL;
246 c->cmt_orphans = c->new_orphans;
247 c->new_orphans = 0;
248 dbg_cmt("%d orphans to commit", c->cmt_orphans);
249 INIT_LIST_HEAD(&c->orph_new);
250 if (c->tot_orphans == 0)
251 c->no_orphs = 1;
252 else
253 c->no_orphs = 0;
254 spin_unlock(&c->orphan_lock);
255 return 0;
256}
257
258
259
260
261
262
263
264
265static int avail_orphs(struct ubifs_info *c)
266{
267 int avail_lebs, avail, gap;
268
269 avail_lebs = c->orph_lebs - (c->ohead_lnum - c->orph_first) - 1;
270 avail = avail_lebs *
271 ((c->leb_size - UBIFS_ORPH_NODE_SZ) / sizeof(__le64));
272 gap = c->leb_size - c->ohead_offs;
273 if (gap >= UBIFS_ORPH_NODE_SZ + sizeof(__le64))
274 avail += (gap - UBIFS_ORPH_NODE_SZ) / sizeof(__le64);
275 return avail;
276}
277
278
279
280
281
282
283
284
285static int tot_avail_orphs(struct ubifs_info *c)
286{
287 int avail_lebs, avail;
288
289 avail_lebs = c->orph_lebs;
290 avail = avail_lebs *
291 ((c->leb_size - UBIFS_ORPH_NODE_SZ) / sizeof(__le64));
292 return avail / 2;
293}
294
295
296
297
298
299
300
301
302
303
304
305static int do_write_orph_node(struct ubifs_info *c, int len, int atomic)
306{
307 int err = 0;
308
309 if (atomic) {
310 ubifs_assert(c, c->ohead_offs == 0);
311 ubifs_prepare_node(c, c->orph_buf, len, 1);
312 len = ALIGN(len, c->min_io_size);
313 err = ubifs_leb_change(c, c->ohead_lnum, c->orph_buf, len);
314 } else {
315 if (c->ohead_offs == 0) {
316
317 err = ubifs_leb_unmap(c, c->ohead_lnum);
318 if (err)
319 return err;
320 }
321 err = ubifs_write_node(c, c->orph_buf, len, c->ohead_lnum,
322 c->ohead_offs);
323 }
324 return err;
325}
326
327
328
329
330
331
332
333
334
335
336static int write_orph_node(struct ubifs_info *c, int atomic)
337{
338 struct ubifs_orphan *orphan, *cnext;
339 struct ubifs_orph_node *orph;
340 int gap, err, len, cnt, i;
341
342 ubifs_assert(c, c->cmt_orphans > 0);
343 gap = c->leb_size - c->ohead_offs;
344 if (gap < UBIFS_ORPH_NODE_SZ + sizeof(__le64)) {
345 c->ohead_lnum += 1;
346 c->ohead_offs = 0;
347 gap = c->leb_size;
348 if (c->ohead_lnum > c->orph_last) {
349
350
351
352
353 ubifs_err(c, "out of space in orphan area");
354 return -EINVAL;
355 }
356 }
357 cnt = (gap - UBIFS_ORPH_NODE_SZ) / sizeof(__le64);
358 if (cnt > c->cmt_orphans)
359 cnt = c->cmt_orphans;
360 len = UBIFS_ORPH_NODE_SZ + cnt * sizeof(__le64);
361 ubifs_assert(c, c->orph_buf);
362 orph = c->orph_buf;
363 orph->ch.node_type = UBIFS_ORPH_NODE;
364 spin_lock(&c->orphan_lock);
365 cnext = c->orph_cnext;
366 for (i = 0; i < cnt; i++) {
367 orphan = cnext;
368 ubifs_assert(c, orphan->cmt);
369 orph->inos[i] = cpu_to_le64(orphan->inum);
370 orphan->cmt = 0;
371 cnext = orphan->cnext;
372 orphan->cnext = NULL;
373 }
374 c->orph_cnext = cnext;
375 c->cmt_orphans -= cnt;
376 spin_unlock(&c->orphan_lock);
377 if (c->cmt_orphans)
378 orph->cmt_no = cpu_to_le64(c->cmt_no);
379 else
380
381 orph->cmt_no = cpu_to_le64((c->cmt_no) | (1ULL << 63));
382 ubifs_assert(c, c->ohead_offs + len <= c->leb_size);
383 ubifs_assert(c, c->ohead_lnum >= c->orph_first);
384 ubifs_assert(c, c->ohead_lnum <= c->orph_last);
385 err = do_write_orph_node(c, len, atomic);
386 c->ohead_offs += ALIGN(len, c->min_io_size);
387 c->ohead_offs = ALIGN(c->ohead_offs, 8);
388 return err;
389}
390
391
392
393
394
395
396
397
398
399static int write_orph_nodes(struct ubifs_info *c, int atomic)
400{
401 int err;
402
403 while (c->cmt_orphans > 0) {
404 err = write_orph_node(c, atomic);
405 if (err)
406 return err;
407 }
408 if (atomic) {
409 int lnum;
410
411
412 for (lnum = c->ohead_lnum + 1; lnum <= c->orph_last; lnum++) {
413 err = ubifs_leb_unmap(c, lnum);
414 if (err)
415 return err;
416 }
417 }
418 return 0;
419}
420
421
422
423
424
425
426
427
428
429
430
431
432static int consolidate(struct ubifs_info *c)
433{
434 int tot_avail = tot_avail_orphs(c), err = 0;
435
436 spin_lock(&c->orphan_lock);
437 dbg_cmt("there is space for %d orphans and there are %d",
438 tot_avail, c->tot_orphans);
439 if (c->tot_orphans - c->new_orphans <= tot_avail) {
440 struct ubifs_orphan *orphan, **last;
441 int cnt = 0;
442
443
444 last = &c->orph_cnext;
445 list_for_each_entry(orphan, &c->orph_list, list) {
446 if (orphan->new)
447 continue;
448 orphan->cmt = 1;
449 *last = orphan;
450 last = &orphan->cnext;
451 cnt += 1;
452 }
453 *last = NULL;
454 ubifs_assert(c, cnt == c->tot_orphans - c->new_orphans);
455 c->cmt_orphans = cnt;
456 c->ohead_lnum = c->orph_first;
457 c->ohead_offs = 0;
458 } else {
459
460
461
462
463 ubifs_err(c, "out of space in orphan area");
464 err = -EINVAL;
465 }
466 spin_unlock(&c->orphan_lock);
467 return err;
468}
469
470
471
472
473
474
475
476
477static int commit_orphans(struct ubifs_info *c)
478{
479 int avail, atomic = 0, err;
480
481 ubifs_assert(c, c->cmt_orphans > 0);
482 avail = avail_orphs(c);
483 if (avail < c->cmt_orphans) {
484
485 err = consolidate(c);
486 if (err)
487 return err;
488 atomic = 1;
489 }
490 err = write_orph_nodes(c, atomic);
491 return err;
492}
493
494
495
496
497
498
499
500
501
502
503static void erase_deleted(struct ubifs_info *c)
504{
505 struct ubifs_orphan *orphan, *dnext;
506
507 spin_lock(&c->orphan_lock);
508 dnext = c->orph_dnext;
509 while (dnext) {
510 orphan = dnext;
511 dnext = orphan->dnext;
512 ubifs_assert(c, !orphan->new);
513 ubifs_assert(c, orphan->del);
514 rb_erase(&orphan->rb, &c->orph_tree);
515 list_del(&orphan->list);
516 c->tot_orphans -= 1;
517 dbg_gen("deleting orphan ino %lu", (unsigned long)orphan->inum);
518 kfree(orphan);
519 }
520 c->orph_dnext = NULL;
521 spin_unlock(&c->orphan_lock);
522}
523
524
525
526
527
528
529
530int ubifs_orphan_end_commit(struct ubifs_info *c)
531{
532 int err;
533
534 if (c->cmt_orphans != 0) {
535 err = commit_orphans(c);
536 if (err)
537 return err;
538 }
539 erase_deleted(c);
540 err = dbg_check_orphans(c);
541 return err;
542}
543
544
545
546
547
548
549
550
551
552int ubifs_clear_orphans(struct ubifs_info *c)
553{
554 int lnum, err;
555
556 for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
557 err = ubifs_leb_unmap(c, lnum);
558 if (err)
559 return err;
560 }
561 c->ohead_lnum = c->orph_first;
562 c->ohead_offs = 0;
563 return 0;
564}
565
566
567
568
569
570
571
572
573
574
575static int insert_dead_orphan(struct ubifs_info *c, ino_t inum)
576{
577 struct ubifs_orphan *orphan, *o;
578 struct rb_node **p, *parent = NULL;
579
580 orphan = kzalloc(sizeof(struct ubifs_orphan), GFP_KERNEL);
581 if (!orphan)
582 return -ENOMEM;
583 orphan->inum = inum;
584
585 p = &c->orph_tree.rb_node;
586 while (*p) {
587 parent = *p;
588 o = rb_entry(parent, struct ubifs_orphan, rb);
589 if (inum < o->inum)
590 p = &(*p)->rb_left;
591 else if (inum > o->inum)
592 p = &(*p)->rb_right;
593 else {
594
595 kfree(orphan);
596 return 0;
597 }
598 }
599 c->tot_orphans += 1;
600 rb_link_node(&orphan->rb, parent, p);
601 rb_insert_color(&orphan->rb, &c->orph_tree);
602 list_add_tail(&orphan->list, &c->orph_list);
603 orphan->del = 1;
604 orphan->dnext = c->orph_dnext;
605 c->orph_dnext = orphan;
606 dbg_mnt("ino %lu, new %d, tot %d", (unsigned long)inum,
607 c->new_orphans, c->tot_orphans);
608 return 0;
609}
610
611
612
613
614
615
616
617
618
619
620
621
622
623static int do_kill_orphans(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
624 unsigned long long *last_cmt_no, int *outofdate,
625 int *last_flagged)
626{
627 struct ubifs_scan_node *snod;
628 struct ubifs_orph_node *orph;
629 struct ubifs_ino_node *ino = NULL;
630 unsigned long long cmt_no;
631 ino_t inum;
632 int i, n, err, first = 1;
633
634 list_for_each_entry(snod, &sleb->nodes, list) {
635 if (snod->type != UBIFS_ORPH_NODE) {
636 ubifs_err(c, "invalid node type %d in orphan area at %d:%d",
637 snod->type, sleb->lnum, snod->offs);
638 ubifs_dump_node(c, snod->node);
639 return -EINVAL;
640 }
641
642 orph = snod->node;
643
644
645 cmt_no = le64_to_cpu(orph->cmt_no) & LLONG_MAX;
646
647
648
649
650
651
652
653
654 if (cmt_no > c->cmt_no)
655 c->cmt_no = cmt_no;
656 if (cmt_no < *last_cmt_no && *last_flagged) {
657
658
659
660
661
662 if (!first) {
663 ubifs_err(c, "out of order commit number %llu in orphan node at %d:%d",
664 cmt_no, sleb->lnum, snod->offs);
665 ubifs_dump_node(c, snod->node);
666 return -EINVAL;
667 }
668 dbg_rcvry("out of date LEB %d", sleb->lnum);
669 *outofdate = 1;
670 return 0;
671 }
672
673 if (first)
674 first = 0;
675
676 ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS);
677 if (!ino)
678 return -ENOMEM;
679
680 n = (le32_to_cpu(orph->ch.len) - UBIFS_ORPH_NODE_SZ) >> 3;
681 for (i = 0; i < n; i++) {
682 union ubifs_key key1, key2;
683
684 inum = le64_to_cpu(orph->inos[i]);
685
686 ino_key_init(c, &key1, inum);
687 err = ubifs_tnc_lookup(c, &key1, ino);
688 if (err)
689 goto out_free;
690
691
692
693
694
695 if (ino->nlink == 0) {
696 dbg_rcvry("deleting orphaned inode %lu",
697 (unsigned long)inum);
698
699 lowest_ino_key(c, &key1, inum);
700 highest_ino_key(c, &key2, inum);
701
702 err = ubifs_tnc_remove_range(c, &key1, &key2);
703 if (err)
704 goto out_ro;
705 }
706
707 err = insert_dead_orphan(c, inum);
708 if (err)
709 goto out_free;
710 }
711
712 *last_cmt_no = cmt_no;
713 if (le64_to_cpu(orph->cmt_no) & (1ULL << 63)) {
714 dbg_rcvry("last orph node for commit %llu at %d:%d",
715 cmt_no, sleb->lnum, snod->offs);
716 *last_flagged = 1;
717 } else
718 *last_flagged = 0;
719 }
720
721 err = 0;
722out_free:
723 kfree(ino);
724 return err;
725
726out_ro:
727 ubifs_ro_mode(c, err);
728 kfree(ino);
729 return err;
730}
731
732
733
734
735
736
737
738
739
740
741
742static int kill_orphans(struct ubifs_info *c)
743{
744 unsigned long long last_cmt_no = 0;
745 int lnum, err = 0, outofdate = 0, last_flagged = 0;
746
747 c->ohead_lnum = c->orph_first;
748 c->ohead_offs = 0;
749
750 if (c->no_orphs) {
751 dbg_rcvry("no orphans");
752 return 0;
753 }
754
755
756
757
758
759
760
761
762
763
764
765 for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
766 struct ubifs_scan_leb *sleb;
767
768 dbg_rcvry("LEB %d", lnum);
769 sleb = ubifs_scan(c, lnum, 0, c->sbuf, 1);
770 if (IS_ERR(sleb)) {
771 if (PTR_ERR(sleb) == -EUCLEAN)
772 sleb = ubifs_recover_leb(c, lnum, 0,
773 c->sbuf, -1);
774 if (IS_ERR(sleb)) {
775 err = PTR_ERR(sleb);
776 break;
777 }
778 }
779 err = do_kill_orphans(c, sleb, &last_cmt_no, &outofdate,
780 &last_flagged);
781 if (err || outofdate) {
782 ubifs_scan_destroy(sleb);
783 break;
784 }
785 if (sleb->endpt) {
786 c->ohead_lnum = lnum;
787 c->ohead_offs = sleb->endpt;
788 }
789 ubifs_scan_destroy(sleb);
790 }
791 return err;
792}
793
794
795
796
797
798
799
800
801
802
803
804int ubifs_mount_orphans(struct ubifs_info *c, int unclean, int read_only)
805{
806 int err = 0;
807
808 c->max_orphans = tot_avail_orphs(c);
809
810 if (!read_only) {
811 c->orph_buf = vmalloc(c->leb_size);
812 if (!c->orph_buf)
813 return -ENOMEM;
814 }
815
816 if (unclean)
817 err = kill_orphans(c);
818 else if (!read_only)
819 err = ubifs_clear_orphans(c);
820
821 return err;
822}
823
824
825
826
827
828struct check_orphan {
829 struct rb_node rb;
830 ino_t inum;
831};
832
833struct check_info {
834 unsigned long last_ino;
835 unsigned long tot_inos;
836 unsigned long missing;
837 unsigned long long leaf_cnt;
838 struct ubifs_ino_node *node;
839 struct rb_root root;
840};
841
842static bool dbg_find_orphan(struct ubifs_info *c, ino_t inum)
843{
844 bool found = false;
845
846 spin_lock(&c->orphan_lock);
847 found = !!lookup_orphan(c, inum);
848 spin_unlock(&c->orphan_lock);
849
850 return found;
851}
852
853static int dbg_ins_check_orphan(struct rb_root *root, ino_t inum)
854{
855 struct check_orphan *orphan, *o;
856 struct rb_node **p, *parent = NULL;
857
858 orphan = kzalloc(sizeof(struct check_orphan), GFP_NOFS);
859 if (!orphan)
860 return -ENOMEM;
861 orphan->inum = inum;
862
863 p = &root->rb_node;
864 while (*p) {
865 parent = *p;
866 o = rb_entry(parent, struct check_orphan, rb);
867 if (inum < o->inum)
868 p = &(*p)->rb_left;
869 else if (inum > o->inum)
870 p = &(*p)->rb_right;
871 else {
872 kfree(orphan);
873 return 0;
874 }
875 }
876 rb_link_node(&orphan->rb, parent, p);
877 rb_insert_color(&orphan->rb, root);
878 return 0;
879}
880
881static int dbg_find_check_orphan(struct rb_root *root, ino_t inum)
882{
883 struct check_orphan *o;
884 struct rb_node *p;
885
886 p = root->rb_node;
887 while (p) {
888 o = rb_entry(p, struct check_orphan, rb);
889 if (inum < o->inum)
890 p = p->rb_left;
891 else if (inum > o->inum)
892 p = p->rb_right;
893 else
894 return 1;
895 }
896 return 0;
897}
898
899static void dbg_free_check_tree(struct rb_root *root)
900{
901 struct check_orphan *o, *n;
902
903 rbtree_postorder_for_each_entry_safe(o, n, root, rb)
904 kfree(o);
905}
906
907static int dbg_orphan_check(struct ubifs_info *c, struct ubifs_zbranch *zbr,
908 void *priv)
909{
910 struct check_info *ci = priv;
911 ino_t inum;
912 int err;
913
914 inum = key_inum(c, &zbr->key);
915 if (inum != ci->last_ino) {
916
917 if (key_type(c, &zbr->key) != UBIFS_INO_KEY)
918 ubifs_err(c, "found orphan node ino %lu, type %d",
919 (unsigned long)inum, key_type(c, &zbr->key));
920 ci->last_ino = inum;
921 ci->tot_inos += 1;
922 err = ubifs_tnc_read_node(c, zbr, ci->node);
923 if (err) {
924 ubifs_err(c, "node read failed, error %d", err);
925 return err;
926 }
927 if (ci->node->nlink == 0)
928
929 if (!dbg_find_check_orphan(&ci->root, inum) &&
930 !dbg_find_orphan(c, inum)) {
931 ubifs_err(c, "missing orphan, ino %lu",
932 (unsigned long)inum);
933 ci->missing += 1;
934 }
935 }
936 ci->leaf_cnt += 1;
937 return 0;
938}
939
940static int dbg_read_orphans(struct check_info *ci, struct ubifs_scan_leb *sleb)
941{
942 struct ubifs_scan_node *snod;
943 struct ubifs_orph_node *orph;
944 ino_t inum;
945 int i, n, err;
946
947 list_for_each_entry(snod, &sleb->nodes, list) {
948 cond_resched();
949 if (snod->type != UBIFS_ORPH_NODE)
950 continue;
951 orph = snod->node;
952 n = (le32_to_cpu(orph->ch.len) - UBIFS_ORPH_NODE_SZ) >> 3;
953 for (i = 0; i < n; i++) {
954 inum = le64_to_cpu(orph->inos[i]);
955 err = dbg_ins_check_orphan(&ci->root, inum);
956 if (err)
957 return err;
958 }
959 }
960 return 0;
961}
962
963static int dbg_scan_orphans(struct ubifs_info *c, struct check_info *ci)
964{
965 int lnum, err = 0;
966 void *buf;
967
968
969 if (c->no_orphs)
970 return 0;
971
972 buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
973 if (!buf) {
974 ubifs_err(c, "cannot allocate memory to check orphans");
975 return 0;
976 }
977
978 for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
979 struct ubifs_scan_leb *sleb;
980
981 sleb = ubifs_scan(c, lnum, 0, buf, 0);
982 if (IS_ERR(sleb)) {
983 err = PTR_ERR(sleb);
984 break;
985 }
986
987 err = dbg_read_orphans(ci, sleb);
988 ubifs_scan_destroy(sleb);
989 if (err)
990 break;
991 }
992
993 vfree(buf);
994 return err;
995}
996
997static int dbg_check_orphans(struct ubifs_info *c)
998{
999 struct check_info ci;
1000 int err;
1001
1002 if (!dbg_is_chk_orph(c))
1003 return 0;
1004
1005 ci.last_ino = 0;
1006 ci.tot_inos = 0;
1007 ci.missing = 0;
1008 ci.leaf_cnt = 0;
1009 ci.root = RB_ROOT;
1010 ci.node = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS);
1011 if (!ci.node) {
1012 ubifs_err(c, "out of memory");
1013 return -ENOMEM;
1014 }
1015
1016 err = dbg_scan_orphans(c, &ci);
1017 if (err)
1018 goto out;
1019
1020 err = dbg_walk_index(c, &dbg_orphan_check, NULL, &ci);
1021 if (err) {
1022 ubifs_err(c, "cannot scan TNC, error %d", err);
1023 goto out;
1024 }
1025
1026 if (ci.missing) {
1027 ubifs_err(c, "%lu missing orphan(s)", ci.missing);
1028 err = -EINVAL;
1029 goto out;
1030 }
1031
1032 dbg_cmt("last inode number is %lu", ci.last_ino);
1033 dbg_cmt("total number of inodes is %lu", ci.tot_inos);
1034 dbg_cmt("total number of leaf nodes is %llu", ci.leaf_cnt);
1035
1036out:
1037 dbg_free_check_tree(&ci.root);
1038 kfree(ci.node);
1039 return err;
1040}
1041