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