This source file includes following definitions.
- orphan_add
- lookup_orphan
- __orphan_drop
- orphan_delete
- ubifs_add_orphan
- ubifs_delete_orphan
- ubifs_orphan_start_commit
- avail_orphs
- tot_avail_orphs
- do_write_orph_node
- write_orph_node
- write_orph_nodes
- consolidate
- commit_orphans
- erase_deleted
- ubifs_orphan_end_commit
- ubifs_clear_orphans
- insert_dead_orphan
- do_kill_orphans
- kill_orphans
- ubifs_mount_orphans
- dbg_find_orphan
- dbg_ins_check_orphan
- dbg_find_check_orphan
- dbg_free_check_tree
- dbg_orphan_check
- dbg_read_orphans
- dbg_scan_orphans
- dbg_check_orphans
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
43 static int dbg_check_orphans(struct ubifs_info *c);
44
45 static 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
96 static 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
115 static 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
129 static void orphan_delete(struct ubifs_info *c, struct ubifs_orphan *orph)
130 {
131 if (orph->del) {
132 dbg_gen("deleted twice ino %lu", (unsigned long)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", (unsigned long)orph->inum);
141 return;
142 }
143
144 __orphan_drop(c, orph);
145 }
146
147
148
149
150
151
152
153
154
155 int 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
200 void 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
231 int 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
265 static 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
285 static 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
305 static 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
336 static 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
399 static 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
432 static 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
477 static 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
503 static 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
530 int 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
552 int 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
575 static 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
623 static 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 ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS);
635 if (!ino)
636 return -ENOMEM;
637
638 list_for_each_entry(snod, &sleb->nodes, list) {
639 if (snod->type != UBIFS_ORPH_NODE) {
640 ubifs_err(c, "invalid node type %d in orphan area at %d:%d",
641 snod->type, sleb->lnum, snod->offs);
642 ubifs_dump_node(c, snod->node);
643 err = -EINVAL;
644 goto out_free;
645 }
646
647 orph = snod->node;
648
649
650 cmt_no = le64_to_cpu(orph->cmt_no) & LLONG_MAX;
651
652
653
654
655
656
657
658
659 if (cmt_no > c->cmt_no)
660 c->cmt_no = cmt_no;
661 if (cmt_no < *last_cmt_no && *last_flagged) {
662
663
664
665
666
667 if (!first) {
668 ubifs_err(c, "out of order commit number %llu in orphan node at %d:%d",
669 cmt_no, sleb->lnum, snod->offs);
670 ubifs_dump_node(c, snod->node);
671 err = -EINVAL;
672 goto out_free;
673 }
674 dbg_rcvry("out of date LEB %d", sleb->lnum);
675 *outofdate = 1;
676 err = 0;
677 goto out_free;
678 }
679
680 if (first)
681 first = 0;
682
683 n = (le32_to_cpu(orph->ch.len) - UBIFS_ORPH_NODE_SZ) >> 3;
684 for (i = 0; i < n; i++) {
685 union ubifs_key key1, key2;
686
687 inum = le64_to_cpu(orph->inos[i]);
688
689 ino_key_init(c, &key1, inum);
690 err = ubifs_tnc_lookup(c, &key1, ino);
691 if (err && err != -ENOENT)
692 goto out_free;
693
694
695
696
697
698 if (err == 0 && ino->nlink == 0) {
699 dbg_rcvry("deleting orphaned inode %lu",
700 (unsigned long)inum);
701
702 lowest_ino_key(c, &key1, inum);
703 highest_ino_key(c, &key2, inum);
704
705 err = ubifs_tnc_remove_range(c, &key1, &key2);
706 if (err)
707 goto out_ro;
708 }
709
710 err = insert_dead_orphan(c, inum);
711 if (err)
712 goto out_free;
713 }
714
715 *last_cmt_no = cmt_no;
716 if (le64_to_cpu(orph->cmt_no) & (1ULL << 63)) {
717 dbg_rcvry("last orph node for commit %llu at %d:%d",
718 cmt_no, sleb->lnum, snod->offs);
719 *last_flagged = 1;
720 } else
721 *last_flagged = 0;
722 }
723
724 err = 0;
725 out_free:
726 kfree(ino);
727 return err;
728
729 out_ro:
730 ubifs_ro_mode(c, err);
731 kfree(ino);
732 return err;
733 }
734
735
736
737
738
739
740
741
742
743
744
745 static int kill_orphans(struct ubifs_info *c)
746 {
747 unsigned long long last_cmt_no = 0;
748 int lnum, err = 0, outofdate = 0, last_flagged = 0;
749
750 c->ohead_lnum = c->orph_first;
751 c->ohead_offs = 0;
752
753 if (c->no_orphs) {
754 dbg_rcvry("no orphans");
755 return 0;
756 }
757
758
759
760
761
762
763
764
765
766
767
768 for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
769 struct ubifs_scan_leb *sleb;
770
771 dbg_rcvry("LEB %d", lnum);
772 sleb = ubifs_scan(c, lnum, 0, c->sbuf, 1);
773 if (IS_ERR(sleb)) {
774 if (PTR_ERR(sleb) == -EUCLEAN)
775 sleb = ubifs_recover_leb(c, lnum, 0,
776 c->sbuf, -1);
777 if (IS_ERR(sleb)) {
778 err = PTR_ERR(sleb);
779 break;
780 }
781 }
782 err = do_kill_orphans(c, sleb, &last_cmt_no, &outofdate,
783 &last_flagged);
784 if (err || outofdate) {
785 ubifs_scan_destroy(sleb);
786 break;
787 }
788 if (sleb->endpt) {
789 c->ohead_lnum = lnum;
790 c->ohead_offs = sleb->endpt;
791 }
792 ubifs_scan_destroy(sleb);
793 }
794 return err;
795 }
796
797
798
799
800
801
802
803
804
805
806
807 int ubifs_mount_orphans(struct ubifs_info *c, int unclean, int read_only)
808 {
809 int err = 0;
810
811 c->max_orphans = tot_avail_orphs(c);
812
813 if (!read_only) {
814 c->orph_buf = vmalloc(c->leb_size);
815 if (!c->orph_buf)
816 return -ENOMEM;
817 }
818
819 if (unclean)
820 err = kill_orphans(c);
821 else if (!read_only)
822 err = ubifs_clear_orphans(c);
823
824 return err;
825 }
826
827
828
829
830
831 struct check_orphan {
832 struct rb_node rb;
833 ino_t inum;
834 };
835
836 struct check_info {
837 unsigned long last_ino;
838 unsigned long tot_inos;
839 unsigned long missing;
840 unsigned long long leaf_cnt;
841 struct ubifs_ino_node *node;
842 struct rb_root root;
843 };
844
845 static bool dbg_find_orphan(struct ubifs_info *c, ino_t inum)
846 {
847 bool found = false;
848
849 spin_lock(&c->orphan_lock);
850 found = !!lookup_orphan(c, inum);
851 spin_unlock(&c->orphan_lock);
852
853 return found;
854 }
855
856 static int dbg_ins_check_orphan(struct rb_root *root, ino_t inum)
857 {
858 struct check_orphan *orphan, *o;
859 struct rb_node **p, *parent = NULL;
860
861 orphan = kzalloc(sizeof(struct check_orphan), GFP_NOFS);
862 if (!orphan)
863 return -ENOMEM;
864 orphan->inum = inum;
865
866 p = &root->rb_node;
867 while (*p) {
868 parent = *p;
869 o = rb_entry(parent, struct check_orphan, rb);
870 if (inum < o->inum)
871 p = &(*p)->rb_left;
872 else if (inum > o->inum)
873 p = &(*p)->rb_right;
874 else {
875 kfree(orphan);
876 return 0;
877 }
878 }
879 rb_link_node(&orphan->rb, parent, p);
880 rb_insert_color(&orphan->rb, root);
881 return 0;
882 }
883
884 static int dbg_find_check_orphan(struct rb_root *root, ino_t inum)
885 {
886 struct check_orphan *o;
887 struct rb_node *p;
888
889 p = root->rb_node;
890 while (p) {
891 o = rb_entry(p, struct check_orphan, rb);
892 if (inum < o->inum)
893 p = p->rb_left;
894 else if (inum > o->inum)
895 p = p->rb_right;
896 else
897 return 1;
898 }
899 return 0;
900 }
901
902 static void dbg_free_check_tree(struct rb_root *root)
903 {
904 struct check_orphan *o, *n;
905
906 rbtree_postorder_for_each_entry_safe(o, n, root, rb)
907 kfree(o);
908 }
909
910 static int dbg_orphan_check(struct ubifs_info *c, struct ubifs_zbranch *zbr,
911 void *priv)
912 {
913 struct check_info *ci = priv;
914 ino_t inum;
915 int err;
916
917 inum = key_inum(c, &zbr->key);
918 if (inum != ci->last_ino) {
919
920 if (key_type(c, &zbr->key) != UBIFS_INO_KEY)
921 ubifs_err(c, "found orphan node ino %lu, type %d",
922 (unsigned long)inum, key_type(c, &zbr->key));
923 ci->last_ino = inum;
924 ci->tot_inos += 1;
925 err = ubifs_tnc_read_node(c, zbr, ci->node);
926 if (err) {
927 ubifs_err(c, "node read failed, error %d", err);
928 return err;
929 }
930 if (ci->node->nlink == 0)
931
932 if (!dbg_find_check_orphan(&ci->root, inum) &&
933 !dbg_find_orphan(c, inum)) {
934 ubifs_err(c, "missing orphan, ino %lu",
935 (unsigned long)inum);
936 ci->missing += 1;
937 }
938 }
939 ci->leaf_cnt += 1;
940 return 0;
941 }
942
943 static int dbg_read_orphans(struct check_info *ci, struct ubifs_scan_leb *sleb)
944 {
945 struct ubifs_scan_node *snod;
946 struct ubifs_orph_node *orph;
947 ino_t inum;
948 int i, n, err;
949
950 list_for_each_entry(snod, &sleb->nodes, list) {
951 cond_resched();
952 if (snod->type != UBIFS_ORPH_NODE)
953 continue;
954 orph = snod->node;
955 n = (le32_to_cpu(orph->ch.len) - UBIFS_ORPH_NODE_SZ) >> 3;
956 for (i = 0; i < n; i++) {
957 inum = le64_to_cpu(orph->inos[i]);
958 err = dbg_ins_check_orphan(&ci->root, inum);
959 if (err)
960 return err;
961 }
962 }
963 return 0;
964 }
965
966 static int dbg_scan_orphans(struct ubifs_info *c, struct check_info *ci)
967 {
968 int lnum, err = 0;
969 void *buf;
970
971
972 if (c->no_orphs)
973 return 0;
974
975 buf = __vmalloc(c->leb_size, GFP_NOFS, PAGE_KERNEL);
976 if (!buf) {
977 ubifs_err(c, "cannot allocate memory to check orphans");
978 return 0;
979 }
980
981 for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
982 struct ubifs_scan_leb *sleb;
983
984 sleb = ubifs_scan(c, lnum, 0, buf, 0);
985 if (IS_ERR(sleb)) {
986 err = PTR_ERR(sleb);
987 break;
988 }
989
990 err = dbg_read_orphans(ci, sleb);
991 ubifs_scan_destroy(sleb);
992 if (err)
993 break;
994 }
995
996 vfree(buf);
997 return err;
998 }
999
1000 static int dbg_check_orphans(struct ubifs_info *c)
1001 {
1002 struct check_info ci;
1003 int err;
1004
1005 if (!dbg_is_chk_orph(c))
1006 return 0;
1007
1008 ci.last_ino = 0;
1009 ci.tot_inos = 0;
1010 ci.missing = 0;
1011 ci.leaf_cnt = 0;
1012 ci.root = RB_ROOT;
1013 ci.node = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS);
1014 if (!ci.node) {
1015 ubifs_err(c, "out of memory");
1016 return -ENOMEM;
1017 }
1018
1019 err = dbg_scan_orphans(c, &ci);
1020 if (err)
1021 goto out;
1022
1023 err = dbg_walk_index(c, &dbg_orphan_check, NULL, &ci);
1024 if (err) {
1025 ubifs_err(c, "cannot scan TNC, error %d", err);
1026 goto out;
1027 }
1028
1029 if (ci.missing) {
1030 ubifs_err(c, "%lu missing orphan(s)", ci.missing);
1031 err = -EINVAL;
1032 goto out;
1033 }
1034
1035 dbg_cmt("last inode number is %lu", ci.last_ino);
1036 dbg_cmt("total number of inodes is %lu", ci.tot_inos);
1037 dbg_cmt("total number of leaf nodes is %llu", ci.leaf_cnt);
1038
1039 out:
1040 dbg_free_check_tree(&ci.root);
1041 kfree(ci.node);
1042 return err;
1043 }