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