1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include "ubifs.h"
24#include <linux/list_sort.h>
25#include <crypto/hash.h>
26#include <crypto/algapi.h>
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45struct replay_entry {
46 int lnum;
47 int offs;
48 int len;
49 u8 hash[UBIFS_HASH_ARR_SZ];
50 unsigned int deletion:1;
51 unsigned long long sqnum;
52 struct list_head list;
53 union ubifs_key key;
54 union {
55 struct fscrypt_name nm;
56 struct {
57 loff_t old_size;
58 loff_t new_size;
59 };
60 };
61};
62
63
64
65
66
67
68
69
70
71struct bud_entry {
72 struct list_head list;
73 struct ubifs_bud *bud;
74 unsigned long long sqnum;
75 int free;
76 int dirty;
77};
78
79
80
81
82
83
84
85
86
87
88static int set_bud_lprops(struct ubifs_info *c, struct bud_entry *b)
89{
90 const struct ubifs_lprops *lp;
91 int err = 0, dirty;
92
93 ubifs_get_lprops(c);
94
95 lp = ubifs_lpt_lookup_dirty(c, b->bud->lnum);
96 if (IS_ERR(lp)) {
97 err = PTR_ERR(lp);
98 goto out;
99 }
100
101 dirty = lp->dirty;
102 if (b->bud->start == 0 && (lp->free != c->leb_size || lp->dirty != 0)) {
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122 dbg_mnt("bud LEB %d was GC'd (%d free, %d dirty)", b->bud->lnum,
123 lp->free, lp->dirty);
124 dbg_gc("bud LEB %d was GC'd (%d free, %d dirty)", b->bud->lnum,
125 lp->free, lp->dirty);
126 dirty -= c->leb_size - lp->free;
127
128
129
130
131
132
133
134 if (dirty != 0)
135 dbg_mnt("LEB %d lp: %d free %d dirty replay: %d free %d dirty",
136 b->bud->lnum, lp->free, lp->dirty, b->free,
137 b->dirty);
138 }
139 lp = ubifs_change_lp(c, lp, b->free, dirty + b->dirty,
140 lp->flags | LPROPS_TAKEN, 0);
141 if (IS_ERR(lp)) {
142 err = PTR_ERR(lp);
143 goto out;
144 }
145
146
147 err = ubifs_wbuf_seek_nolock(&c->jheads[b->bud->jhead].wbuf,
148 b->bud->lnum, c->leb_size - b->free);
149
150out:
151 ubifs_release_lprops(c);
152 return err;
153}
154
155
156
157
158
159
160
161
162static int set_buds_lprops(struct ubifs_info *c)
163{
164 struct bud_entry *b;
165 int err;
166
167 list_for_each_entry(b, &c->replay_buds, list) {
168 err = set_bud_lprops(c, b);
169 if (err)
170 return err;
171 }
172
173 return 0;
174}
175
176
177
178
179
180
181static int trun_remove_range(struct ubifs_info *c, struct replay_entry *r)
182{
183 unsigned min_blk, max_blk;
184 union ubifs_key min_key, max_key;
185 ino_t ino;
186
187 min_blk = r->new_size / UBIFS_BLOCK_SIZE;
188 if (r->new_size & (UBIFS_BLOCK_SIZE - 1))
189 min_blk += 1;
190
191 max_blk = r->old_size / UBIFS_BLOCK_SIZE;
192 if ((r->old_size & (UBIFS_BLOCK_SIZE - 1)) == 0)
193 max_blk -= 1;
194
195 ino = key_inum(c, &r->key);
196
197 data_key_init(c, &min_key, ino, min_blk);
198 data_key_init(c, &max_key, ino, max_blk);
199
200 return ubifs_tnc_remove_range(c, &min_key, &max_key);
201}
202
203
204
205
206
207
208
209
210
211
212
213static bool inode_still_linked(struct ubifs_info *c, struct replay_entry *rino)
214{
215 struct replay_entry *r;
216
217 ubifs_assert(c, rino->deletion);
218 ubifs_assert(c, key_type(c, &rino->key) == UBIFS_INO_KEY);
219
220
221
222
223
224 list_for_each_entry_reverse(r, &c->replay_list, list) {
225 ubifs_assert(c, r->sqnum >= rino->sqnum);
226 if (key_inum(c, &r->key) == key_inum(c, &rino->key))
227 return r->deletion == 0;
228
229 }
230
231 ubifs_assert(c, 0);
232 return false;
233}
234
235
236
237
238
239
240
241
242static int apply_replay_entry(struct ubifs_info *c, struct replay_entry *r)
243{
244 int err;
245
246 dbg_mntk(&r->key, "LEB %d:%d len %d deletion %d sqnum %llu key ",
247 r->lnum, r->offs, r->len, r->deletion, r->sqnum);
248
249 if (is_hash_key(c, &r->key)) {
250 if (r->deletion)
251 err = ubifs_tnc_remove_nm(c, &r->key, &r->nm);
252 else
253 err = ubifs_tnc_add_nm(c, &r->key, r->lnum, r->offs,
254 r->len, r->hash, &r->nm);
255 } else {
256 if (r->deletion)
257 switch (key_type(c, &r->key)) {
258 case UBIFS_INO_KEY:
259 {
260 ino_t inum = key_inum(c, &r->key);
261
262 if (inode_still_linked(c, r)) {
263 err = 0;
264 break;
265 }
266
267 err = ubifs_tnc_remove_ino(c, inum);
268 break;
269 }
270 case UBIFS_TRUN_KEY:
271 err = trun_remove_range(c, r);
272 break;
273 default:
274 err = ubifs_tnc_remove(c, &r->key);
275 break;
276 }
277 else
278 err = ubifs_tnc_add(c, &r->key, r->lnum, r->offs,
279 r->len, r->hash);
280 if (err)
281 return err;
282
283 if (c->need_recovery)
284 err = ubifs_recover_size_accum(c, &r->key, r->deletion,
285 r->new_size);
286 }
287
288 return err;
289}
290
291
292
293
294
295
296
297
298
299
300
301static int replay_entries_cmp(void *priv, struct list_head *a,
302 struct list_head *b)
303{
304 struct ubifs_info *c = priv;
305 struct replay_entry *ra, *rb;
306
307 cond_resched();
308 if (a == b)
309 return 0;
310
311 ra = list_entry(a, struct replay_entry, list);
312 rb = list_entry(b, struct replay_entry, list);
313 ubifs_assert(c, ra->sqnum != rb->sqnum);
314 if (ra->sqnum > rb->sqnum)
315 return 1;
316 return -1;
317}
318
319
320
321
322
323
324
325
326static int apply_replay_list(struct ubifs_info *c)
327{
328 struct replay_entry *r;
329 int err;
330
331 list_sort(c, &c->replay_list, &replay_entries_cmp);
332
333 list_for_each_entry(r, &c->replay_list, list) {
334 cond_resched();
335
336 err = apply_replay_entry(c, r);
337 if (err)
338 return err;
339 }
340
341 return 0;
342}
343
344
345
346
347
348
349
350static void destroy_replay_list(struct ubifs_info *c)
351{
352 struct replay_entry *r, *tmp;
353
354 list_for_each_entry_safe(r, tmp, &c->replay_list, list) {
355 if (is_hash_key(c, &r->key))
356 kfree(fname_name(&r->nm));
357 list_del(&r->list);
358 kfree(r);
359 }
360}
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382static int insert_node(struct ubifs_info *c, int lnum, int offs, int len,
383 const u8 *hash, union ubifs_key *key,
384 unsigned long long sqnum, int deletion, int *used,
385 loff_t old_size, loff_t new_size)
386{
387 struct replay_entry *r;
388
389 dbg_mntk(key, "add LEB %d:%d, key ", lnum, offs);
390
391 if (key_inum(c, key) >= c->highest_inum)
392 c->highest_inum = key_inum(c, key);
393
394 r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL);
395 if (!r)
396 return -ENOMEM;
397
398 if (!deletion)
399 *used += ALIGN(len, 8);
400 r->lnum = lnum;
401 r->offs = offs;
402 r->len = len;
403 ubifs_copy_hash(c, hash, r->hash);
404 r->deletion = !!deletion;
405 r->sqnum = sqnum;
406 key_copy(c, key, &r->key);
407 r->old_size = old_size;
408 r->new_size = new_size;
409
410 list_add_tail(&r->list, &c->replay_list);
411 return 0;
412}
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431static int insert_dent(struct ubifs_info *c, int lnum, int offs, int len,
432 const u8 *hash, union ubifs_key *key,
433 const char *name, int nlen, unsigned long long sqnum,
434 int deletion, int *used)
435{
436 struct replay_entry *r;
437 char *nbuf;
438
439 dbg_mntk(key, "add LEB %d:%d, key ", lnum, offs);
440 if (key_inum(c, key) >= c->highest_inum)
441 c->highest_inum = key_inum(c, key);
442
443 r = kzalloc(sizeof(struct replay_entry), GFP_KERNEL);
444 if (!r)
445 return -ENOMEM;
446
447 nbuf = kmalloc(nlen + 1, GFP_KERNEL);
448 if (!nbuf) {
449 kfree(r);
450 return -ENOMEM;
451 }
452
453 if (!deletion)
454 *used += ALIGN(len, 8);
455 r->lnum = lnum;
456 r->offs = offs;
457 r->len = len;
458 ubifs_copy_hash(c, hash, r->hash);
459 r->deletion = !!deletion;
460 r->sqnum = sqnum;
461 key_copy(c, key, &r->key);
462 fname_len(&r->nm) = nlen;
463 memcpy(nbuf, name, nlen);
464 nbuf[nlen] = '\0';
465 fname_name(&r->nm) = nbuf;
466
467 list_add_tail(&r->list, &c->replay_list);
468 return 0;
469}
470
471
472
473
474
475
476
477
478
479int ubifs_validate_entry(struct ubifs_info *c,
480 const struct ubifs_dent_node *dent)
481{
482 int key_type = key_type_flash(c, dent->key);
483 int nlen = le16_to_cpu(dent->nlen);
484
485 if (le32_to_cpu(dent->ch.len) != nlen + UBIFS_DENT_NODE_SZ + 1 ||
486 dent->type >= UBIFS_ITYPES_CNT ||
487 nlen > UBIFS_MAX_NLEN || dent->name[nlen] != 0 ||
488 (key_type == UBIFS_XENT_KEY && strnlen(dent->name, nlen) != nlen) ||
489 le64_to_cpu(dent->inum) > MAX_INUM) {
490 ubifs_err(c, "bad %s node", key_type == UBIFS_DENT_KEY ?
491 "directory entry" : "extended attribute entry");
492 return -EINVAL;
493 }
494
495 if (key_type != UBIFS_DENT_KEY && key_type != UBIFS_XENT_KEY) {
496 ubifs_err(c, "bad key type %d", key_type);
497 return -EINVAL;
498 }
499
500 return 0;
501}
502
503
504
505
506
507
508
509
510
511
512
513static int is_last_bud(struct ubifs_info *c, struct ubifs_bud *bud)
514{
515 struct ubifs_jhead *jh = &c->jheads[bud->jhead];
516 struct ubifs_bud *next;
517 uint32_t data;
518 int err;
519
520 if (list_is_last(&bud->list, &jh->buds_list))
521 return 1;
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550 next = list_entry(bud->list.next, struct ubifs_bud, list);
551 if (!list_is_last(&next->list, &jh->buds_list))
552 return 0;
553
554 err = ubifs_leb_read(c, next->lnum, (char *)&data, next->start, 4, 1);
555 if (err)
556 return 0;
557
558 return data == 0xFFFFFFFF;
559}
560
561
562static int authenticate_sleb_hash(struct ubifs_info *c, struct shash_desc *log_hash, u8 *hash)
563{
564 SHASH_DESC_ON_STACK(hash_desc, c->hash_tfm);
565
566 hash_desc->tfm = c->hash_tfm;
567
568 ubifs_shash_copy_state(c, log_hash, hash_desc);
569 return crypto_shash_final(hash_desc, hash);
570}
571
572static int authenticate_sleb_hmac(struct ubifs_info *c, u8 *hash, u8 *hmac)
573{
574 SHASH_DESC_ON_STACK(hmac_desc, c->hmac_tfm);
575
576 hmac_desc->tfm = c->hmac_tfm;
577
578 return crypto_shash_digest(hmac_desc, hash, c->hash_len, hmac);
579}
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597static int authenticate_sleb(struct ubifs_info *c, struct ubifs_scan_leb *sleb,
598 struct shash_desc *log_hash, int is_last)
599{
600 int n_not_auth = 0;
601 struct ubifs_scan_node *snod;
602 int n_nodes = 0;
603 int err;
604 u8 *hash, *hmac;
605
606 if (!ubifs_authenticated(c))
607 return sleb->nodes_cnt;
608
609 hash = kmalloc(crypto_shash_descsize(c->hash_tfm), GFP_NOFS);
610 hmac = kmalloc(c->hmac_desc_len, GFP_NOFS);
611 if (!hash || !hmac) {
612 err = -ENOMEM;
613 goto out;
614 }
615
616 list_for_each_entry(snod, &sleb->nodes, list) {
617
618 n_nodes++;
619
620 if (snod->type == UBIFS_AUTH_NODE) {
621 struct ubifs_auth_node *auth = snod->node;
622
623 err = authenticate_sleb_hash(c, log_hash, hash);
624 if (err)
625 goto out;
626
627 err = authenticate_sleb_hmac(c, hash, hmac);
628 if (err)
629 goto out;
630
631 err = ubifs_check_hmac(c, auth->hmac, hmac);
632 if (err) {
633 err = -EPERM;
634 goto out;
635 }
636 n_not_auth = 0;
637 } else {
638 err = crypto_shash_update(log_hash, snod->node,
639 snod->len);
640 if (err)
641 goto out;
642 n_not_auth++;
643 }
644 }
645
646
647
648
649
650
651 if (n_not_auth) {
652 if (is_last) {
653 dbg_mnt("%d unauthenticated nodes found on LEB %d, Ignoring them",
654 n_not_auth, sleb->lnum);
655 err = 0;
656 } else {
657 dbg_mnt("%d unauthenticated nodes found on non-last LEB %d",
658 n_not_auth, sleb->lnum);
659 err = -EPERM;
660 }
661 } else {
662 err = 0;
663 }
664out:
665 kfree(hash);
666 kfree(hmac);
667
668 return err ? err : n_nodes - n_not_auth;
669}
670
671
672
673
674
675
676
677
678
679
680static int replay_bud(struct ubifs_info *c, struct bud_entry *b)
681{
682 int is_last = is_last_bud(c, b->bud);
683 int err = 0, used = 0, lnum = b->bud->lnum, offs = b->bud->start;
684 int n_nodes, n = 0;
685 struct ubifs_scan_leb *sleb;
686 struct ubifs_scan_node *snod;
687
688 dbg_mnt("replay bud LEB %d, head %d, offs %d, is_last %d",
689 lnum, b->bud->jhead, offs, is_last);
690
691 if (c->need_recovery && is_last)
692
693
694
695
696
697
698 sleb = ubifs_recover_leb(c, lnum, offs, c->sbuf, b->bud->jhead);
699 else
700 sleb = ubifs_scan(c, lnum, offs, c->sbuf, 0);
701 if (IS_ERR(sleb))
702 return PTR_ERR(sleb);
703
704 n_nodes = authenticate_sleb(c, sleb, b->bud->log_hash, is_last);
705 if (n_nodes < 0) {
706 err = n_nodes;
707 goto out;
708 }
709
710 ubifs_shash_copy_state(c, b->bud->log_hash,
711 c->jheads[b->bud->jhead].log_hash);
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735 list_for_each_entry(snod, &sleb->nodes, list) {
736 u8 hash[UBIFS_HASH_ARR_SZ];
737 int deletion = 0;
738
739 cond_resched();
740
741 if (snod->sqnum >= SQNUM_WATERMARK) {
742 ubifs_err(c, "file system's life ended");
743 goto out_dump;
744 }
745
746 ubifs_node_calc_hash(c, snod->node, hash);
747
748 if (snod->sqnum > c->max_sqnum)
749 c->max_sqnum = snod->sqnum;
750
751 switch (snod->type) {
752 case UBIFS_INO_NODE:
753 {
754 struct ubifs_ino_node *ino = snod->node;
755 loff_t new_size = le64_to_cpu(ino->size);
756
757 if (le32_to_cpu(ino->nlink) == 0)
758 deletion = 1;
759 err = insert_node(c, lnum, snod->offs, snod->len, hash,
760 &snod->key, snod->sqnum, deletion,
761 &used, 0, new_size);
762 break;
763 }
764 case UBIFS_DATA_NODE:
765 {
766 struct ubifs_data_node *dn = snod->node;
767 loff_t new_size = le32_to_cpu(dn->size) +
768 key_block(c, &snod->key) *
769 UBIFS_BLOCK_SIZE;
770
771 err = insert_node(c, lnum, snod->offs, snod->len, hash,
772 &snod->key, snod->sqnum, deletion,
773 &used, 0, new_size);
774 break;
775 }
776 case UBIFS_DENT_NODE:
777 case UBIFS_XENT_NODE:
778 {
779 struct ubifs_dent_node *dent = snod->node;
780
781 err = ubifs_validate_entry(c, dent);
782 if (err)
783 goto out_dump;
784
785 err = insert_dent(c, lnum, snod->offs, snod->len, hash,
786 &snod->key, dent->name,
787 le16_to_cpu(dent->nlen), snod->sqnum,
788 !le64_to_cpu(dent->inum), &used);
789 break;
790 }
791 case UBIFS_TRUN_NODE:
792 {
793 struct ubifs_trun_node *trun = snod->node;
794 loff_t old_size = le64_to_cpu(trun->old_size);
795 loff_t new_size = le64_to_cpu(trun->new_size);
796 union ubifs_key key;
797
798
799 if (old_size < 0 || old_size > c->max_inode_sz ||
800 new_size < 0 || new_size > c->max_inode_sz ||
801 old_size <= new_size) {
802 ubifs_err(c, "bad truncation node");
803 goto out_dump;
804 }
805
806
807
808
809
810 trun_key_init(c, &key, le32_to_cpu(trun->inum));
811 err = insert_node(c, lnum, snod->offs, snod->len, hash,
812 &key, snod->sqnum, 1, &used,
813 old_size, new_size);
814 break;
815 }
816 case UBIFS_AUTH_NODE:
817 break;
818 default:
819 ubifs_err(c, "unexpected node type %d in bud LEB %d:%d",
820 snod->type, lnum, snod->offs);
821 err = -EINVAL;
822 goto out_dump;
823 }
824 if (err)
825 goto out;
826
827 n++;
828 if (n == n_nodes)
829 break;
830 }
831
832 ubifs_assert(c, ubifs_search_bud(c, lnum));
833 ubifs_assert(c, sleb->endpt - offs >= used);
834 ubifs_assert(c, sleb->endpt % c->min_io_size == 0);
835
836 b->dirty = sleb->endpt - offs - used;
837 b->free = c->leb_size - sleb->endpt;
838 dbg_mnt("bud LEB %d replied: dirty %d, free %d",
839 lnum, b->dirty, b->free);
840
841out:
842 ubifs_scan_destroy(sleb);
843 return err;
844
845out_dump:
846 ubifs_err(c, "bad node is at LEB %d:%d", lnum, snod->offs);
847 ubifs_dump_node(c, snod->node);
848 ubifs_scan_destroy(sleb);
849 return -EINVAL;
850}
851
852
853
854
855
856
857
858
859static int replay_buds(struct ubifs_info *c)
860{
861 struct bud_entry *b;
862 int err;
863 unsigned long long prev_sqnum = 0;
864
865 list_for_each_entry(b, &c->replay_buds, list) {
866 err = replay_bud(c, b);
867 if (err)
868 return err;
869
870 ubifs_assert(c, b->sqnum > prev_sqnum);
871 prev_sqnum = b->sqnum;
872 }
873
874 return 0;
875}
876
877
878
879
880
881static void destroy_bud_list(struct ubifs_info *c)
882{
883 struct bud_entry *b;
884
885 while (!list_empty(&c->replay_buds)) {
886 b = list_entry(c->replay_buds.next, struct bud_entry, list);
887 list_del(&b->list);
888 kfree(b);
889 }
890}
891
892
893
894
895
896
897
898
899
900
901
902
903static int add_replay_bud(struct ubifs_info *c, int lnum, int offs, int jhead,
904 unsigned long long sqnum)
905{
906 struct ubifs_bud *bud;
907 struct bud_entry *b;
908 int err;
909
910 dbg_mnt("add replay bud LEB %d:%d, head %d", lnum, offs, jhead);
911
912 bud = kmalloc(sizeof(struct ubifs_bud), GFP_KERNEL);
913 if (!bud)
914 return -ENOMEM;
915
916 b = kmalloc(sizeof(struct bud_entry), GFP_KERNEL);
917 if (!b) {
918 err = -ENOMEM;
919 goto out;
920 }
921
922 bud->lnum = lnum;
923 bud->start = offs;
924 bud->jhead = jhead;
925 bud->log_hash = ubifs_hash_get_desc(c);
926 if (IS_ERR(bud->log_hash)) {
927 err = PTR_ERR(bud->log_hash);
928 goto out;
929 }
930
931 ubifs_shash_copy_state(c, c->log_hash, bud->log_hash);
932
933 ubifs_add_bud(c, bud);
934
935 b->bud = bud;
936 b->sqnum = sqnum;
937 list_add_tail(&b->list, &c->replay_buds);
938
939 return 0;
940out:
941 kfree(bud);
942 kfree(b);
943
944 return err;
945}
946
947
948
949
950
951
952
953
954
955
956
957
958static int validate_ref(struct ubifs_info *c, const struct ubifs_ref_node *ref)
959{
960 struct ubifs_bud *bud;
961 int lnum = le32_to_cpu(ref->lnum);
962 unsigned int offs = le32_to_cpu(ref->offs);
963 unsigned int jhead = le32_to_cpu(ref->jhead);
964
965
966
967
968
969
970 if (jhead >= c->jhead_cnt || lnum >= c->leb_cnt ||
971 lnum < c->main_first || offs > c->leb_size ||
972 offs & (c->min_io_size - 1))
973 return -EINVAL;
974
975
976 bud = ubifs_search_bud(c, lnum);
977 if (bud) {
978 if (bud->jhead == jhead && bud->start <= offs)
979 return 1;
980 ubifs_err(c, "bud at LEB %d:%d was already referred", lnum, offs);
981 return -EINVAL;
982 }
983
984 return 0;
985}
986
987
988
989
990
991
992
993
994
995
996
997
998static int replay_log_leb(struct ubifs_info *c, int lnum, int offs, void *sbuf)
999{
1000 int err;
1001 struct ubifs_scan_leb *sleb;
1002 struct ubifs_scan_node *snod;
1003 const struct ubifs_cs_node *node;
1004
1005 dbg_mnt("replay log LEB %d:%d", lnum, offs);
1006 sleb = ubifs_scan(c, lnum, offs, sbuf, c->need_recovery);
1007 if (IS_ERR(sleb)) {
1008 if (PTR_ERR(sleb) != -EUCLEAN || !c->need_recovery)
1009 return PTR_ERR(sleb);
1010
1011
1012
1013
1014
1015 sleb = ubifs_recover_log_leb(c, lnum, offs, sbuf);
1016 if (IS_ERR(sleb))
1017 return PTR_ERR(sleb);
1018 }
1019
1020 if (sleb->nodes_cnt == 0) {
1021 err = 1;
1022 goto out;
1023 }
1024
1025 node = sleb->buf;
1026 snod = list_entry(sleb->nodes.next, struct ubifs_scan_node, list);
1027 if (c->cs_sqnum == 0) {
1028
1029
1030
1031
1032
1033
1034
1035 if (snod->type != UBIFS_CS_NODE) {
1036 ubifs_err(c, "first log node at LEB %d:%d is not CS node",
1037 lnum, offs);
1038 goto out_dump;
1039 }
1040 if (le64_to_cpu(node->cmt_no) != c->cmt_no) {
1041 ubifs_err(c, "first CS node at LEB %d:%d has wrong commit number %llu expected %llu",
1042 lnum, offs,
1043 (unsigned long long)le64_to_cpu(node->cmt_no),
1044 c->cmt_no);
1045 goto out_dump;
1046 }
1047
1048 c->cs_sqnum = le64_to_cpu(node->ch.sqnum);
1049 dbg_mnt("commit start sqnum %llu", c->cs_sqnum);
1050
1051 err = ubifs_shash_init(c, c->log_hash);
1052 if (err)
1053 goto out;
1054
1055 err = ubifs_shash_update(c, c->log_hash, node, UBIFS_CS_NODE_SZ);
1056 if (err < 0)
1057 goto out;
1058 }
1059
1060 if (snod->sqnum < c->cs_sqnum) {
1061
1062
1063
1064
1065
1066
1067
1068 err = 1;
1069 goto out;
1070 }
1071
1072
1073 if (snod->offs != 0) {
1074 ubifs_err(c, "first node is not at zero offset");
1075 goto out_dump;
1076 }
1077
1078 list_for_each_entry(snod, &sleb->nodes, list) {
1079 cond_resched();
1080
1081 if (snod->sqnum >= SQNUM_WATERMARK) {
1082 ubifs_err(c, "file system's life ended");
1083 goto out_dump;
1084 }
1085
1086 if (snod->sqnum < c->cs_sqnum) {
1087 ubifs_err(c, "bad sqnum %llu, commit sqnum %llu",
1088 snod->sqnum, c->cs_sqnum);
1089 goto out_dump;
1090 }
1091
1092 if (snod->sqnum > c->max_sqnum)
1093 c->max_sqnum = snod->sqnum;
1094
1095 switch (snod->type) {
1096 case UBIFS_REF_NODE: {
1097 const struct ubifs_ref_node *ref = snod->node;
1098
1099 err = validate_ref(c, ref);
1100 if (err == 1)
1101 break;
1102 if (err)
1103 goto out_dump;
1104
1105 err = ubifs_shash_update(c, c->log_hash, ref,
1106 UBIFS_REF_NODE_SZ);
1107 if (err)
1108 goto out;
1109
1110 err = add_replay_bud(c, le32_to_cpu(ref->lnum),
1111 le32_to_cpu(ref->offs),
1112 le32_to_cpu(ref->jhead),
1113 snod->sqnum);
1114 if (err)
1115 goto out;
1116
1117 break;
1118 }
1119 case UBIFS_CS_NODE:
1120
1121 if (snod->offs != 0) {
1122 ubifs_err(c, "unexpected node in log");
1123 goto out_dump;
1124 }
1125 break;
1126 default:
1127 ubifs_err(c, "unexpected node in log");
1128 goto out_dump;
1129 }
1130 }
1131
1132 if (sleb->endpt || c->lhead_offs >= c->leb_size) {
1133 c->lhead_lnum = lnum;
1134 c->lhead_offs = sleb->endpt;
1135 }
1136
1137 err = !sleb->endpt;
1138out:
1139 ubifs_scan_destroy(sleb);
1140 return err;
1141
1142out_dump:
1143 ubifs_err(c, "log error detected while replaying the log at LEB %d:%d",
1144 lnum, offs + snod->offs);
1145 ubifs_dump_node(c, snod->node);
1146 ubifs_scan_destroy(sleb);
1147 return -EINVAL;
1148}
1149
1150
1151
1152
1153
1154
1155
1156
1157static int take_ihead(struct ubifs_info *c)
1158{
1159 const struct ubifs_lprops *lp;
1160 int err, free;
1161
1162 ubifs_get_lprops(c);
1163
1164 lp = ubifs_lpt_lookup_dirty(c, c->ihead_lnum);
1165 if (IS_ERR(lp)) {
1166 err = PTR_ERR(lp);
1167 goto out;
1168 }
1169
1170 free = lp->free;
1171
1172 lp = ubifs_change_lp(c, lp, LPROPS_NC, LPROPS_NC,
1173 lp->flags | LPROPS_TAKEN, 0);
1174 if (IS_ERR(lp)) {
1175 err = PTR_ERR(lp);
1176 goto out;
1177 }
1178
1179 err = free;
1180out:
1181 ubifs_release_lprops(c);
1182 return err;
1183}
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193int ubifs_replay_journal(struct ubifs_info *c)
1194{
1195 int err, lnum, free;
1196
1197 BUILD_BUG_ON(UBIFS_TRUN_KEY > 5);
1198
1199
1200 free = take_ihead(c);
1201 if (free < 0)
1202 return free;
1203
1204 if (c->ihead_offs != c->leb_size - free) {
1205 ubifs_err(c, "bad index head LEB %d:%d", c->ihead_lnum,
1206 c->ihead_offs);
1207 return -EINVAL;
1208 }
1209
1210 dbg_mnt("start replaying the journal");
1211 c->replaying = 1;
1212 lnum = c->ltail_lnum = c->lhead_lnum;
1213
1214 do {
1215 err = replay_log_leb(c, lnum, 0, c->sbuf);
1216 if (err == 1) {
1217 if (lnum != c->lhead_lnum)
1218
1219 break;
1220
1221
1222
1223
1224
1225
1226
1227
1228 ubifs_err(c, "no UBIFS nodes found at the log head LEB %d:%d, possibly corrupted",
1229 lnum, 0);
1230 err = -EINVAL;
1231 }
1232 if (err)
1233 goto out;
1234 lnum = ubifs_next_log_lnum(c, lnum);
1235 } while (lnum != c->ltail_lnum);
1236
1237 err = replay_buds(c);
1238 if (err)
1239 goto out;
1240
1241 err = apply_replay_list(c);
1242 if (err)
1243 goto out;
1244
1245 err = set_buds_lprops(c);
1246 if (err)
1247 goto out;
1248
1249
1250
1251
1252
1253
1254
1255 c->bi.uncommitted_idx = atomic_long_read(&c->dirty_zn_cnt);
1256 c->bi.uncommitted_idx *= c->max_idx_node_sz;
1257
1258 ubifs_assert(c, c->bud_bytes <= c->max_bud_bytes || c->need_recovery);
1259 dbg_mnt("finished, log head LEB %d:%d, max_sqnum %llu, highest_inum %lu",
1260 c->lhead_lnum, c->lhead_offs, c->max_sqnum,
1261 (unsigned long)c->highest_inum);
1262out:
1263 destroy_replay_list(c);
1264 destroy_bud_list(c);
1265 c->replaying = 0;
1266 return err;
1267}
1268