blob: 3559daf11d2b2d87f3e28cfe5906951276f2773a [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Uma Shankared34f342012-05-25 21:22:49 +05302/*
3 * (C) Copyright 2011 - 2012 Samsung Electronics
4 * EXT4 filesystem implementation in Uboot by
5 * Uma Shankar <uma.shankar@samsung.com>
6 * Manjunatha C Achar <a.manjunatha@samsung.com>
7 *
8 * Journal data structures and headers for Journaling feature of ext4
9 * have been referred from JBD2 (Journaling Block device 2)
10 * implementation in Linux Kernel.
11 * Written by Stephen C. Tweedie <sct@redhat.com>
12 *
13 * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
Uma Shankared34f342012-05-25 21:22:49 +053014 */
15
16#include <common.h>
17#include <ext4fs.h>
18#include <malloc.h>
19#include <ext_common.h>
20#include "ext4_common.h"
21
22static struct revoke_blk_list *revk_blk_list;
23static struct revoke_blk_list *prev_node;
York Sun472d5462013-04-01 11:29:11 -070024static int first_node = true;
Uma Shankared34f342012-05-25 21:22:49 +053025
26int gindex;
27int gd_index;
28int jrnl_blk_idx;
29struct journal_log *journal_ptr[MAX_JOURNAL_ENTRIES];
30struct dirty_blocks *dirty_block_ptr[MAX_JOURNAL_ENTRIES];
31
32int ext4fs_init_journal(void)
33{
34 int i;
35 char *temp = NULL;
36 struct ext_filesystem *fs = get_fs();
37
38 /* init globals */
39 revk_blk_list = NULL;
40 prev_node = NULL;
41 gindex = 0;
42 gd_index = 0;
43 jrnl_blk_idx = 1;
44
45 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
46 journal_ptr[i] = zalloc(sizeof(struct journal_log));
47 if (!journal_ptr[i])
48 goto fail;
49 dirty_block_ptr[i] = zalloc(sizeof(struct dirty_blocks));
50 if (!dirty_block_ptr[i])
51 goto fail;
52 journal_ptr[i]->buf = NULL;
53 journal_ptr[i]->blknr = -1;
54
55 dirty_block_ptr[i]->buf = NULL;
56 dirty_block_ptr[i]->blknr = -1;
57 }
58
59 if (fs->blksz == 4096) {
60 temp = zalloc(fs->blksz);
61 if (!temp)
62 goto fail;
63 journal_ptr[gindex]->buf = zalloc(fs->blksz);
64 if (!journal_ptr[gindex]->buf)
65 goto fail;
66 ext4fs_devread(0, 0, fs->blksz, temp);
67 memcpy(temp + SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE);
68 memcpy(journal_ptr[gindex]->buf, temp, fs->blksz);
69 journal_ptr[gindex++]->blknr = 0;
70 free(temp);
71 } else {
72 journal_ptr[gindex]->buf = zalloc(fs->blksz);
73 if (!journal_ptr[gindex]->buf)
74 goto fail;
75 memcpy(journal_ptr[gindex]->buf, fs->sb, SUPERBLOCK_SIZE);
76 journal_ptr[gindex++]->blknr = 1;
77 }
78
79 /* Check the file system state using journal super block */
80 if (ext4fs_check_journal_state(SCAN))
81 goto fail;
82 /* Check the file system state using journal super block */
83 if (ext4fs_check_journal_state(RECOVER))
84 goto fail;
85
86 return 0;
87fail:
88 return -1;
89}
90
91void ext4fs_dump_metadata(void)
92{
93 struct ext_filesystem *fs = get_fs();
94 int i;
95 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
96 if (dirty_block_ptr[i]->blknr == -1)
97 break;
98 put_ext4((uint64_t) ((uint64_t)dirty_block_ptr[i]->blknr *
99 (uint64_t)fs->blksz), dirty_block_ptr[i]->buf,
100 fs->blksz);
101 }
102}
103
104void ext4fs_free_journal(void)
105{
106 int i;
107 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
108 if (dirty_block_ptr[i]->blknr == -1)
109 break;
110 if (dirty_block_ptr[i]->buf)
111 free(dirty_block_ptr[i]->buf);
112 }
113
114 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
115 if (journal_ptr[i]->blknr == -1)
116 break;
117 if (journal_ptr[i]->buf)
118 free(journal_ptr[i]->buf);
119 }
120
121 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
122 if (journal_ptr[i])
123 free(journal_ptr[i]);
124 if (dirty_block_ptr[i])
125 free(dirty_block_ptr[i]);
126 }
127 gindex = 0;
128 gd_index = 0;
129 jrnl_blk_idx = 1;
130}
131
132int ext4fs_log_gdt(char *gd_table)
133{
134 struct ext_filesystem *fs = get_fs();
135 short i;
136 long int var = fs->gdtable_blkno;
137 for (i = 0; i < fs->no_blk_pergdt; i++) {
138 journal_ptr[gindex]->buf = zalloc(fs->blksz);
139 if (!journal_ptr[gindex]->buf)
140 return -ENOMEM;
141 memcpy(journal_ptr[gindex]->buf, gd_table, fs->blksz);
142 gd_table += fs->blksz;
143 journal_ptr[gindex++]->blknr = var++;
144 }
145
146 return 0;
147}
148
149/*
150 * This function stores the backup copy of meta data in RAM
151 * journal_buffer -- Buffer containing meta data
152 * blknr -- Block number on disk of the meta data buffer
153 */
Michael Walle58a9ecb2016-09-01 11:21:40 +0200154int ext4fs_log_journal(char *journal_buffer, uint32_t blknr)
Uma Shankared34f342012-05-25 21:22:49 +0530155{
156 struct ext_filesystem *fs = get_fs();
157 short i;
158
159 if (!journal_buffer) {
160 printf("Invalid input arguments %s\n", __func__);
161 return -EINVAL;
162 }
163
164 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
165 if (journal_ptr[i]->blknr == -1)
166 break;
167 if (journal_ptr[i]->blknr == blknr)
168 return 0;
169 }
170
171 journal_ptr[gindex]->buf = zalloc(fs->blksz);
172 if (!journal_ptr[gindex]->buf)
173 return -ENOMEM;
174
175 memcpy(journal_ptr[gindex]->buf, journal_buffer, fs->blksz);
176 journal_ptr[gindex++]->blknr = blknr;
177
178 return 0;
179}
180
181/*
182 * This function stores the modified meta data in RAM
183 * metadata_buffer -- Buffer containing meta data
184 * blknr -- Block number on disk of the meta data buffer
185 */
Michael Walle58a9ecb2016-09-01 11:21:40 +0200186int ext4fs_put_metadata(char *metadata_buffer, uint32_t blknr)
Uma Shankared34f342012-05-25 21:22:49 +0530187{
188 struct ext_filesystem *fs = get_fs();
189 if (!metadata_buffer) {
190 printf("Invalid input arguments %s\n", __func__);
191 return -EINVAL;
192 }
Stefan Brünsb1edcf02016-09-06 04:36:56 +0200193 if (dirty_block_ptr[gd_index]->buf)
194 assert(dirty_block_ptr[gd_index]->blknr == blknr);
195 else
196 dirty_block_ptr[gd_index]->buf = zalloc(fs->blksz);
197
Uma Shankared34f342012-05-25 21:22:49 +0530198 if (!dirty_block_ptr[gd_index]->buf)
199 return -ENOMEM;
200 memcpy(dirty_block_ptr[gd_index]->buf, metadata_buffer, fs->blksz);
201 dirty_block_ptr[gd_index++]->blknr = blknr;
202
203 return 0;
204}
205
206void print_revoke_blks(char *revk_blk)
207{
208 int offset;
209 int max;
210 long int blocknr;
211 struct journal_revoke_header_t *header;
212
213 if (revk_blk == NULL)
214 return;
215
216 header = (struct journal_revoke_header_t *) revk_blk;
217 offset = sizeof(struct journal_revoke_header_t);
218 max = be32_to_cpu(header->r_count);
219 printf("total bytes %d\n", max);
220
221 while (offset < max) {
Michael Walle58a9ecb2016-09-01 11:21:40 +0200222 blocknr = be32_to_cpu(*((__be32 *)(revk_blk + offset)));
Uma Shankared34f342012-05-25 21:22:49 +0530223 printf("revoke blknr is %ld\n", blocknr);
224 offset += 4;
225 }
226}
227
228static struct revoke_blk_list *_get_node(void)
229{
230 struct revoke_blk_list *tmp_node;
231 tmp_node = zalloc(sizeof(struct revoke_blk_list));
232 if (tmp_node == NULL)
233 return NULL;
234 tmp_node->content = NULL;
235 tmp_node->next = NULL;
236
237 return tmp_node;
238}
239
240void ext4fs_push_revoke_blk(char *buffer)
241{
242 struct revoke_blk_list *node = NULL;
243 struct ext_filesystem *fs = get_fs();
244 if (buffer == NULL) {
245 printf("buffer ptr is NULL\n");
246 return;
247 }
248 node = _get_node();
249 if (!node) {
250 printf("_get_node: malloc failed\n");
251 return;
252 }
253
254 node->content = zalloc(fs->blksz);
255 if (node->content == NULL)
256 return;
257 memcpy(node->content, buffer, fs->blksz);
258
York Sun472d5462013-04-01 11:29:11 -0700259 if (first_node == true) {
Uma Shankared34f342012-05-25 21:22:49 +0530260 revk_blk_list = node;
261 prev_node = node;
York Sun472d5462013-04-01 11:29:11 -0700262 first_node = false;
Uma Shankared34f342012-05-25 21:22:49 +0530263 } else {
264 prev_node->next = node;
265 prev_node = node;
266 }
267}
268
269void ext4fs_free_revoke_blks(void)
270{
271 struct revoke_blk_list *tmp_node = revk_blk_list;
272 struct revoke_blk_list *next_node = NULL;
273
274 while (tmp_node != NULL) {
275 if (tmp_node->content)
276 free(tmp_node->content);
277 tmp_node = tmp_node->next;
278 }
279
280 tmp_node = revk_blk_list;
281 while (tmp_node != NULL) {
282 next_node = tmp_node->next;
283 free(tmp_node);
284 tmp_node = next_node;
285 }
286
287 revk_blk_list = NULL;
288 prev_node = NULL;
York Sun472d5462013-04-01 11:29:11 -0700289 first_node = true;
Uma Shankared34f342012-05-25 21:22:49 +0530290}
291
292int check_blknr_for_revoke(long int blknr, int sequence_no)
293{
294 struct journal_revoke_header_t *header;
295 int offset;
296 int max;
297 long int blocknr;
298 char *revk_blk;
299 struct revoke_blk_list *tmp_revk_node = revk_blk_list;
300 while (tmp_revk_node != NULL) {
301 revk_blk = tmp_revk_node->content;
302
303 header = (struct journal_revoke_header_t *) revk_blk;
304 if (sequence_no < be32_to_cpu(header->r_header.h_sequence)) {
305 offset = sizeof(struct journal_revoke_header_t);
306 max = be32_to_cpu(header->r_count);
307
308 while (offset < max) {
Michael Walle58a9ecb2016-09-01 11:21:40 +0200309 blocknr = be32_to_cpu(*((__be32 *)
Uma Shankared34f342012-05-25 21:22:49 +0530310 (revk_blk + offset)));
311 if (blocknr == blknr)
312 goto found;
313 offset += 4;
314 }
315 }
316 tmp_revk_node = tmp_revk_node->next;
317 }
318
319 return -1;
320
321found:
322 return 0;
323}
324
325/*
326 * This function parses the journal blocks and replays the
327 * suceessful transactions. A transaction is successfull
328 * if commit block is found for a descriptor block
329 * The tags in descriptor block contain the disk block
330 * numbers of the metadata to be replayed
331 */
332void recover_transaction(int prev_desc_logical_no)
333{
334 struct ext2_inode inode_journal;
335 struct ext_filesystem *fs = get_fs();
336 struct journal_header_t *jdb;
337 long int blknr;
338 char *p_jdb;
339 int ofs, flags;
340 int i;
341 struct ext3_journal_block_tag *tag;
342 char *temp_buff = zalloc(fs->blksz);
343 char *metadata_buff = zalloc(fs->blksz);
344 if (!temp_buff || !metadata_buff)
345 goto fail;
346 i = prev_desc_logical_no;
347 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
348 (struct ext2_inode *)&inode_journal);
349 blknr = read_allocated_block((struct ext2_inode *)
Stephen Warrend5aee652019-01-30 12:58:05 -0700350 &inode_journal, i, NULL);
Frederic Leroy04735e92013-06-26 18:11:25 +0200351 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
352 temp_buff);
Uma Shankared34f342012-05-25 21:22:49 +0530353 p_jdb = (char *)temp_buff;
354 jdb = (struct journal_header_t *) temp_buff;
355 ofs = sizeof(struct journal_header_t);
356
357 do {
Tom Rini10b078d2017-08-20 22:30:15 -0400358 tag = (struct ext3_journal_block_tag *)(p_jdb + ofs);
Uma Shankared34f342012-05-25 21:22:49 +0530359 ofs += sizeof(struct ext3_journal_block_tag);
360
361 if (ofs > fs->blksz)
362 break;
363
364 flags = be32_to_cpu(tag->flags);
365 if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID))
366 ofs += 16;
367
368 i++;
369 debug("\t\ttag %u\n", be32_to_cpu(tag->block));
370 if (revk_blk_list != NULL) {
371 if (check_blknr_for_revoke(be32_to_cpu(tag->block),
372 be32_to_cpu(jdb->h_sequence)) == 0)
373 continue;
374 }
Stephen Warrend5aee652019-01-30 12:58:05 -0700375 blknr = read_allocated_block(&inode_journal, i, NULL);
Frederic Leroy04735e92013-06-26 18:11:25 +0200376 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
Uma Shankared34f342012-05-25 21:22:49 +0530377 fs->blksz, metadata_buff);
Ma Haijun05508702014-01-08 08:15:33 +0800378 put_ext4((uint64_t)((uint64_t)be32_to_cpu(tag->block) * (uint64_t)fs->blksz),
Uma Shankared34f342012-05-25 21:22:49 +0530379 metadata_buff, (uint32_t) fs->blksz);
380 } while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG));
381fail:
382 free(temp_buff);
383 free(metadata_buff);
384}
385
386void print_jrnl_status(int recovery_flag)
387{
388 if (recovery_flag == RECOVER)
389 printf("Journal Recovery Completed\n");
390 else
391 printf("Journal Scan Completed\n");
392}
393
394int ext4fs_check_journal_state(int recovery_flag)
395{
396 int i;
397 int DB_FOUND = NO;
398 long int blknr;
399 int transaction_state = TRANSACTION_COMPLETE;
400 int prev_desc_logical_no = 0;
401 int curr_desc_logical_no = 0;
Łukasz Majewskid429ca02012-12-05 08:06:39 +0000402 int ofs, flags;
Uma Shankared34f342012-05-25 21:22:49 +0530403 struct ext2_inode inode_journal;
404 struct journal_superblock_t *jsb = NULL;
405 struct journal_header_t *jdb = NULL;
406 char *p_jdb = NULL;
407 struct ext3_journal_block_tag *tag = NULL;
408 char *temp_buff = NULL;
409 char *temp_buff1 = NULL;
410 struct ext_filesystem *fs = get_fs();
411
412 temp_buff = zalloc(fs->blksz);
413 if (!temp_buff)
414 return -ENOMEM;
415 temp_buff1 = zalloc(fs->blksz);
416 if (!temp_buff1) {
417 free(temp_buff);
418 return -ENOMEM;
419 }
420
421 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
Stephen Warrend5aee652019-01-30 12:58:05 -0700422 blknr = read_allocated_block(&inode_journal, EXT2_JOURNAL_SUPERBLOCK,
423 NULL);
Frederic Leroy04735e92013-06-26 18:11:25 +0200424 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
425 temp_buff);
Uma Shankared34f342012-05-25 21:22:49 +0530426 jsb = (struct journal_superblock_t *) temp_buff;
427
Michael Walle58a9ecb2016-09-01 11:21:40 +0200428 if (le32_to_cpu(fs->sb->feature_incompat) & EXT3_FEATURE_INCOMPAT_RECOVER) {
Uma Shankared34f342012-05-25 21:22:49 +0530429 if (recovery_flag == RECOVER)
430 printf("Recovery required\n");
431 } else {
432 if (recovery_flag == RECOVER)
433 printf("File System is consistent\n");
434 goto end;
435 }
436
437 if (be32_to_cpu(jsb->s_start) == 0)
438 goto end;
439
440 if (!(jsb->s_feature_compat &
441 cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM)))
442 jsb->s_feature_compat |=
443 cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM);
444
445 i = be32_to_cpu(jsb->s_first);
446 while (1) {
Stephen Warrend5aee652019-01-30 12:58:05 -0700447 blknr = read_allocated_block(&inode_journal, i, NULL);
Uma Shankared34f342012-05-25 21:22:49 +0530448 memset(temp_buff1, '\0', fs->blksz);
Frederic Leroy04735e92013-06-26 18:11:25 +0200449 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk,
Uma Shankared34f342012-05-25 21:22:49 +0530450 0, fs->blksz, temp_buff1);
451 jdb = (struct journal_header_t *) temp_buff1;
452
453 if (be32_to_cpu(jdb->h_blocktype) ==
454 EXT3_JOURNAL_DESCRIPTOR_BLOCK) {
455 if (be32_to_cpu(jdb->h_sequence) !=
456 be32_to_cpu(jsb->s_sequence)) {
457 print_jrnl_status(recovery_flag);
458 break;
459 }
460
461 curr_desc_logical_no = i;
462 if (transaction_state == TRANSACTION_COMPLETE)
463 transaction_state = TRANSACTION_RUNNING;
464 else
465 return -1;
466 p_jdb = (char *)temp_buff1;
467 ofs = sizeof(struct journal_header_t);
468 do {
469 tag = (struct ext3_journal_block_tag *)
Tom Rini10b078d2017-08-20 22:30:15 -0400470 (p_jdb + ofs);
Uma Shankared34f342012-05-25 21:22:49 +0530471 ofs += sizeof(struct ext3_journal_block_tag);
472 if (ofs > fs->blksz)
473 break;
474 flags = be32_to_cpu(tag->flags);
475 if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID))
476 ofs += 16;
477 i++;
478 debug("\t\ttag %u\n", be32_to_cpu(tag->block));
479 } while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG));
480 i++;
481 DB_FOUND = YES;
482 } else if (be32_to_cpu(jdb->h_blocktype) ==
483 EXT3_JOURNAL_COMMIT_BLOCK) {
484 if (be32_to_cpu(jdb->h_sequence) !=
485 be32_to_cpu(jsb->s_sequence)) {
486 print_jrnl_status(recovery_flag);
487 break;
488 }
489
490 if (transaction_state == TRANSACTION_RUNNING ||
491 (DB_FOUND == NO)) {
492 transaction_state = TRANSACTION_COMPLETE;
493 i++;
494 jsb->s_sequence =
495 cpu_to_be32(be32_to_cpu(
496 jsb->s_sequence) + 1);
497 }
498 prev_desc_logical_no = curr_desc_logical_no;
499 if ((recovery_flag == RECOVER) && (DB_FOUND == YES))
500 recover_transaction(prev_desc_logical_no);
501
502 DB_FOUND = NO;
503 } else if (be32_to_cpu(jdb->h_blocktype) ==
504 EXT3_JOURNAL_REVOKE_BLOCK) {
505 if (be32_to_cpu(jdb->h_sequence) !=
506 be32_to_cpu(jsb->s_sequence)) {
507 print_jrnl_status(recovery_flag);
508 break;
509 }
510 if (recovery_flag == SCAN)
511 ext4fs_push_revoke_blk((char *)jdb);
512 i++;
513 } else {
514 debug("Else Case\n");
515 if (be32_to_cpu(jdb->h_sequence) !=
516 be32_to_cpu(jsb->s_sequence)) {
517 print_jrnl_status(recovery_flag);
518 break;
519 }
520 }
521 }
522
523end:
524 if (recovery_flag == RECOVER) {
Michael Walle58a9ecb2016-09-01 11:21:40 +0200525 uint32_t new_feature_incompat;
Uma Shankared34f342012-05-25 21:22:49 +0530526 jsb->s_start = cpu_to_be32(1);
527 jsb->s_sequence = cpu_to_be32(be32_to_cpu(jsb->s_sequence) + 1);
528 /* get the superblock */
Egbert Eich50ce4c02013-05-01 01:13:19 +0000529 ext4_read_superblock((char *)fs->sb);
Michael Walle58a9ecb2016-09-01 11:21:40 +0200530 new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat);
531 new_feature_incompat |= EXT3_FEATURE_INCOMPAT_RECOVER;
532 fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat);
Uma Shankared34f342012-05-25 21:22:49 +0530533
534 /* Update the super block */
535 put_ext4((uint64_t) (SUPERBLOCK_SIZE),
536 (struct ext2_sblock *)fs->sb,
537 (uint32_t) SUPERBLOCK_SIZE);
Egbert Eich50ce4c02013-05-01 01:13:19 +0000538 ext4_read_superblock((char *)fs->sb);
Uma Shankared34f342012-05-25 21:22:49 +0530539
540 blknr = read_allocated_block(&inode_journal,
Stephen Warrend5aee652019-01-30 12:58:05 -0700541 EXT2_JOURNAL_SUPERBLOCK, NULL);
Ma Haijun05508702014-01-08 08:15:33 +0800542 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz),
Uma Shankared34f342012-05-25 21:22:49 +0530543 (struct journal_superblock_t *)temp_buff,
544 (uint32_t) fs->blksz);
545 ext4fs_free_revoke_blks();
546 }
547 free(temp_buff);
548 free(temp_buff1);
549
550 return 0;
551}
552
553static void update_descriptor_block(long int blknr)
554{
555 int i;
556 long int jsb_blknr;
557 struct journal_header_t jdb;
558 struct ext3_journal_block_tag tag;
559 struct ext2_inode inode_journal;
560 struct journal_superblock_t *jsb = NULL;
561 char *buf = NULL;
562 char *temp = NULL;
563 struct ext_filesystem *fs = get_fs();
564 char *temp_buff = zalloc(fs->blksz);
565 if (!temp_buff)
566 return;
567
568 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
569 jsb_blknr = read_allocated_block(&inode_journal,
Stephen Warrend5aee652019-01-30 12:58:05 -0700570 EXT2_JOURNAL_SUPERBLOCK, NULL);
Frederic Leroy04735e92013-06-26 18:11:25 +0200571 ext4fs_devread((lbaint_t)jsb_blknr * fs->sect_perblk, 0, fs->blksz,
572 temp_buff);
Uma Shankared34f342012-05-25 21:22:49 +0530573 jsb = (struct journal_superblock_t *) temp_buff;
574
575 jdb.h_blocktype = cpu_to_be32(EXT3_JOURNAL_DESCRIPTOR_BLOCK);
576 jdb.h_magic = cpu_to_be32(EXT3_JOURNAL_MAGIC_NUMBER);
577 jdb.h_sequence = jsb->s_sequence;
578 buf = zalloc(fs->blksz);
579 if (!buf) {
580 free(temp_buff);
581 return;
582 }
583 temp = buf;
584 memcpy(buf, &jdb, sizeof(struct journal_header_t));
585 temp += sizeof(struct journal_header_t);
586
587 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
588 if (journal_ptr[i]->blknr == -1)
589 break;
590
591 tag.block = cpu_to_be32(journal_ptr[i]->blknr);
592 tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_SAME_UUID);
593 memcpy(temp, &tag, sizeof(struct ext3_journal_block_tag));
594 temp = temp + sizeof(struct ext3_journal_block_tag);
595 }
596
597 tag.block = cpu_to_be32(journal_ptr[--i]->blknr);
598 tag.flags = cpu_to_be32(EXT3_JOURNAL_FLAG_LAST_TAG);
599 memcpy(temp - sizeof(struct ext3_journal_block_tag), &tag,
600 sizeof(struct ext3_journal_block_tag));
Ma Haijun05508702014-01-08 08:15:33 +0800601 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), buf, (uint32_t) fs->blksz);
Uma Shankared34f342012-05-25 21:22:49 +0530602
603 free(temp_buff);
604 free(buf);
605}
606
607static void update_commit_block(long int blknr)
608{
609 struct journal_header_t jdb;
610 struct ext_filesystem *fs = get_fs();
611 char *buf = NULL;
612 struct ext2_inode inode_journal;
613 struct journal_superblock_t *jsb;
614 long int jsb_blknr;
615 char *temp_buff = zalloc(fs->blksz);
616 if (!temp_buff)
617 return;
618
Frederic Leroy04735e92013-06-26 18:11:25 +0200619 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
620 &inode_journal);
Uma Shankared34f342012-05-25 21:22:49 +0530621 jsb_blknr = read_allocated_block(&inode_journal,
Stephen Warrend5aee652019-01-30 12:58:05 -0700622 EXT2_JOURNAL_SUPERBLOCK, NULL);
Frederic Leroy04735e92013-06-26 18:11:25 +0200623 ext4fs_devread((lbaint_t)jsb_blknr * fs->sect_perblk, 0, fs->blksz,
624 temp_buff);
Uma Shankared34f342012-05-25 21:22:49 +0530625 jsb = (struct journal_superblock_t *) temp_buff;
626
627 jdb.h_blocktype = cpu_to_be32(EXT3_JOURNAL_COMMIT_BLOCK);
628 jdb.h_magic = cpu_to_be32(EXT3_JOURNAL_MAGIC_NUMBER);
629 jdb.h_sequence = jsb->s_sequence;
630 buf = zalloc(fs->blksz);
631 if (!buf) {
632 free(temp_buff);
633 return;
634 }
635 memcpy(buf, &jdb, sizeof(struct journal_header_t));
Ma Haijun05508702014-01-08 08:15:33 +0800636 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), buf, (uint32_t) fs->blksz);
Uma Shankared34f342012-05-25 21:22:49 +0530637
638 free(temp_buff);
639 free(buf);
640}
641
642void ext4fs_update_journal(void)
643{
644 struct ext2_inode inode_journal;
645 struct ext_filesystem *fs = get_fs();
646 long int blknr;
647 int i;
Marek Szyprowskibd8fbd82019-06-21 15:35:35 +0200648
649 if (!(fs->sb->feature_compatibility & EXT4_FEATURE_COMPAT_HAS_JOURNAL))
650 return;
651
Uma Shankared34f342012-05-25 21:22:49 +0530652 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal);
Stephen Warrend5aee652019-01-30 12:58:05 -0700653 blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++, NULL);
Uma Shankared34f342012-05-25 21:22:49 +0530654 update_descriptor_block(blknr);
655 for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) {
656 if (journal_ptr[i]->blknr == -1)
657 break;
Stephen Warrend5aee652019-01-30 12:58:05 -0700658 blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++,
659 NULL);
Uma Shankared34f342012-05-25 21:22:49 +0530660 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz),
661 journal_ptr[i]->buf, fs->blksz);
662 }
Stephen Warrend5aee652019-01-30 12:58:05 -0700663 blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++, NULL);
Uma Shankared34f342012-05-25 21:22:49 +0530664 update_commit_block(blknr);
665 printf("update journal finished\n");
666}