struct ext2_qcow2_hdr *qcow2_read_header(int fd) { void *buffer = NULL; struct ext2_qcow2_hdr *hdr = NULL; size_t size; errcode_t ret; ret = ext2fs_get_mem(sizeof(struct ext2_qcow2_hdr), &buffer); if (ret) return NULL; memset(buffer, 0, sizeof(struct ext2_qcow2_hdr)); if (ext2fs_llseek(fd, 0, SEEK_SET < 0)) return NULL; size = read(fd, buffer, sizeof(struct ext2_qcow2_hdr)); if (size != sizeof(struct ext2_qcow2_hdr)) { ext2fs_free_mem(&buffer); return NULL; } hdr = (struct ext2_qcow2_hdr *)(buffer); if ((ext2fs_be32_to_cpu(hdr->magic) != QCOW_MAGIC) || (ext2fs_be32_to_cpu(hdr->version) != 2)) { ext2fs_free_mem(&hdr); return NULL; } return hdr; }
static int scan_revoke_records(journal_t *journal, struct buffer_head *bh, tid_t sequence, struct recovery_info *info) { journal_revoke_header_t *header; int offset, max; int record_len = 4; header = (journal_revoke_header_t *) bh->b_data; offset = sizeof(journal_revoke_header_t); max = ext2fs_be32_to_cpu(header->r_count); if (!jbd2_revoke_block_csum_verify(journal, header)) return -EINVAL; if (JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_64BIT)) record_len = 8; while (offset + record_len <= max) { unsigned long long blocknr; int err; if (record_len == 4) blocknr = ext2fs_be32_to_cpu(* ((__u32 *) (bh->b_data+offset))); else blocknr = ext2fs_be64_to_cpu(* ((__u64 *) (bh->b_data+offset))); offset += record_len; err = journal_set_revoke(journal, blocknr, sequence); if (err) return err; ++info->nr_revokes; } return 0; }
static inline unsigned long long read_tag_block(journal_t *journal, journal_block_tag_t *tag) { unsigned long long block = ext2fs_be32_to_cpu(tag->t_blocknr); if (jfs_has_feature_64bit(journal)) block |= (u64)ext2fs_be32_to_cpu(tag->t_blocknr_high) << 32; return block; }
static inline unsigned long long read_tag_block(journal_t *journal, journal_block_tag_t *tag) { unsigned long long block = ext2fs_be32_to_cpu(tag->t_blocknr); if (JFS_HAS_INCOMPAT_FEATURE(journal, JFS_FEATURE_INCOMPAT_64BIT)) block |= (u64)ext2fs_be32_to_cpu(tag->t_blocknr_high) << 32; return block; }
/** * journal_recover - recovers a on-disk journal * @journal: the journal to recover * * The primary function for recovering the log contents when mounting a * journaled device. * * Recovery is done in three passes. In the first pass, we look for the * end of the log. In the second, we assemble the list of revoke * blocks. In the third and final pass, we replay any un-revoked blocks * in the log. */ int journal_recover(journal_t *journal) { int err, err2; journal_superblock_t * sb; struct recovery_info info; memset(&info, 0, sizeof(info)); sb = journal->j_superblock; /* * The journal superblock's s_start field (the current log head) * is always zero if, and only if, the journal was cleanly * unmounted. */ if (!sb->s_start) { jbd_debug(1, "No recovery required, last transaction %d\n", ext2fs_be32_to_cpu(sb->s_sequence)); journal->j_transaction_sequence = ext2fs_be32_to_cpu(sb->s_sequence) + 1; return 0; } err = do_one_pass(journal, &info, PASS_SCAN); if (!err) err = do_one_pass(journal, &info, PASS_REVOKE); if (!err) err = do_one_pass(journal, &info, PASS_REPLAY); jbd_debug(1, "JBD2: recovery, exit status %d, " "recovered transactions %u to %u\n", err, info.start_transaction, info.end_transaction); jbd_debug(1, "JBD2: Replayed %d and revoked %d/%d blocks\n", info.nr_replays, info.nr_revoke_hits, info.nr_revokes); /* Restart the log at the next transaction ID, thus invalidating * any existing commit records in the log. */ journal->j_transaction_sequence = ++info.end_transaction; journal_clear_revoke(journal); err2 = sync_blockdev(journal->j_fs_dev); if (!err) err = err2; /* Make sure all replayed data is on permanent storage */ if (journal->j_flags & JFS_BARRIER) { err2 = blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL); if (!err) err = err2; } return err; }
/** * journal_skip_recovery - Start journal and wipe exiting records * @journal: journal to startup * * Locate any valid recovery information from the journal and set up the * journal structures in memory to ignore it (presumably because the * caller has evidence that it is out of date). * This function does'nt appear to be exorted.. * * We perform one pass over the journal to allow us to tell the user how * much recovery information is being erased, and to let us initialise * the journal transaction sequence numbers to the next unused ID. */ int journal_skip_recovery(journal_t *journal) { int err; struct recovery_info info; memset (&info, 0, sizeof(info)); err = do_one_pass(journal, &info, PASS_SCAN); if (err) { printk(KERN_ERR "JBD2: error %d scanning journal\n", err); ++journal->j_transaction_sequence; } else { #ifdef CONFIG_JFS_DEBUG int dropped = info.end_transaction - ext2fs_be32_to_cpu(journal->j_superblock->s_sequence); jbd_debug(1, "JBD2: ignoring %d transaction%s from the journal.\n", dropped, (dropped == 1) ? "" : "s"); #endif journal->j_transaction_sequence = ++info.end_transaction; } journal->j_tail = 0; return err; }
static int scan_revoke_records(journal_t *journal, struct buffer_head *bh, tid_t sequence, struct recovery_info *info) { journal_revoke_header_t *header; int offset, max; int csum_size = 0; __u32 rcount; int record_len = 4; header = (journal_revoke_header_t *) bh->b_data; offset = sizeof(journal_revoke_header_t); rcount = ext2fs_be32_to_cpu(header->r_count); if (!jbd2_revoke_block_csum_verify(journal, header)) return -EFSBADCRC; if (journal_has_csum_v2or3(journal)) csum_size = sizeof(struct journal_revoke_tail); if (rcount > journal->j_blocksize - csum_size) return -EINVAL; max = rcount; if (jfs_has_feature_64bit(journal)) record_len = 8; while (offset + record_len <= max) { unsigned long long blocknr; int err; if (record_len == 4) blocknr = ext2fs_be32_to_cpu(* ((__u32 *) (bh->b_data+offset))); else blocknr = ext2fs_be64_to_cpu(* ((__u64 *) (bh->b_data+offset))); offset += record_len; err = journal_set_revoke(journal, blocknr, sequence); if (err) return err; ++info->nr_revokes; } return 0; }
static void print_journal_information(ext2_filsys fs) { errcode_t retval; char buf[1024]; char str[80]; unsigned int i; journal_superblock_t *jsb; /* Get the journal superblock */ if ((retval = io_channel_read_blk64(fs->io, fs->super->s_first_data_block + 1, -1024, buf))) { com_err(program_name, retval, "%s", _("while reading journal superblock")); exit(1); } jsb = (journal_superblock_t *) buf; if ((jsb->s_header.h_magic != (unsigned) ntohl(JFS_MAGIC_NUMBER)) || (jsb->s_header.h_blocktype != (unsigned) ntohl(JFS_SUPERBLOCK_V2))) { com_err(program_name, 0, "%s", _("Couldn't find journal superblock magic numbers")); exit(1); } if (jsb->s_feature_compat & ext2fs_cpu_to_be32(JFS_FEATURE_COMPAT_CHECKSUM)) printf(_("Journal checksum type: crc32\n")); if (jsb->s_feature_incompat & ext2fs_cpu_to_be32(JFS_FEATURE_INCOMPAT_CSUM_V2)) printf(_("Journal checksum type: %s\n" "Journal checksum: 0x%08x\n"), journal_checksum_type_str(jsb->s_checksum_type), ext2fs_be32_to_cpu(jsb->s_checksum)); printf(_("\nJournal block size: %u\n" "Journal length: %u\n" "Journal first block: %u\n" "Journal sequence: 0x%08x\n" "Journal start: %u\n" "Journal number of users: %u\n"), (unsigned int)ntohl(jsb->s_blocksize), (unsigned int)ntohl(jsb->s_maxlen), (unsigned int)ntohl(jsb->s_first), (unsigned int)ntohl(jsb->s_sequence), (unsigned int)ntohl(jsb->s_start), (unsigned int)ntohl(jsb->s_nr_users)); for (i=0; i < ntohl(jsb->s_nr_users); i++) { uuid_unparse(&jsb->s_users[i*16], str); printf(i ? " %s\n" : _("Journal users: %s\n"), str); } }
static int e2fsck_journal_sb_csum_verify(journal_t *j, journal_superblock_t *jsb) { __u32 provided, calculated; if (!journal_has_csum_v2or3(j)) return 1; provided = ext2fs_be32_to_cpu(jsb->s_checksum); calculated = e2fsck_journal_sb_csum(jsb); return provided == calculated; }
static int e2fsck_journal_sb_csum_verify(journal_t *j, journal_superblock_t *jsb) { __u32 provided, calculated; if (!JFS_HAS_INCOMPAT_FEATURE(j, JFS_FEATURE_INCOMPAT_CSUM_V2)) return 1; provided = ext2fs_be32_to_cpu(jsb->s_checksum); calculated = e2fsck_journal_sb_csum(jsb); return provided == calculated; }
static int jbd2_commit_block_csum_verify(journal_t *j, void *buf) { struct commit_header *h; __u32 provided, calculated; if (!JFS_HAS_INCOMPAT_FEATURE(j, JFS_FEATURE_INCOMPAT_CSUM_V2)) return 1; h = buf; provided = h->h_chksum[0]; h->h_chksum[0] = 0; calculated = ext2fs_crc32c_le(~0, j->j_superblock->s_uuid, sizeof(j->j_superblock->s_uuid)); calculated = ext2fs_crc32c_le(calculated, buf, j->j_blocksize); h->h_chksum[0] = provided; provided = ext2fs_be32_to_cpu(provided); return provided == calculated; }
/* * Check whether given quota file is in our format */ static int v2_check_file(struct quota_handle *h, int type, int fmt) { struct v2_disk_dqheader dqh; int file_magics[] = INITQMAGICS; if (fmt != QFMT_VFS_V1) return 0; if (!v2_read_header(h, &dqh)) return 0; if (ext2fs_le32_to_cpu(dqh.dqh_magic) != file_magics[type]) { if (ext2fs_be32_to_cpu(dqh.dqh_magic) == file_magics[type]) log_err("Your quota file is stored in wrong endianity"); return 0; } if (V2_VERSION != ext2fs_le32_to_cpu(dqh.dqh_version)) return 0; return 1; }
static int jbd2_revoke_block_csum_verify(journal_t *j, void *buf) { struct journal_revoke_tail *tail; __u32 provided, calculated; if (!JFS_HAS_INCOMPAT_FEATURE(j, JFS_FEATURE_INCOMPAT_CSUM_V2)) return 1; tail = (struct journal_revoke_tail *)(buf + j->j_blocksize - sizeof(struct journal_revoke_tail)); provided = tail->r_checksum; tail->r_checksum = 0; calculated = ext2fs_crc32c_le(~0, j->j_superblock->s_uuid, sizeof(j->j_superblock->s_uuid)); calculated = ext2fs_crc32c_le(calculated, buf, j->j_blocksize); tail->r_checksum = provided; provided = ext2fs_be32_to_cpu(provided); return provided == calculated; }
static void print_inline_journal_information(ext2_filsys fs) { journal_superblock_t *jsb; struct ext2_inode inode; ext2_file_t journal_file; errcode_t retval; ino_t ino = fs->super->s_journal_inum; char buf[1024]; __u32 *mask_ptr, mask, m; int i, j, size, printed = 0; if (fs->flags & EXT2_FLAG_IMAGE_FILE) return; retval = ext2fs_read_inode(fs, ino, &inode); if (retval) { com_err(program_name, retval, "%s", _("while reading journal inode")); exit(1); } retval = ext2fs_file_open2(fs, ino, &inode, 0, &journal_file); if (retval) { com_err(program_name, retval, "%s", _("while opening journal inode")); exit(1); } retval = ext2fs_file_read(journal_file, buf, sizeof(buf), 0); if (retval) { com_err(program_name, retval, "%s", _("while reading journal super block")); exit(1); } ext2fs_file_close(journal_file); jsb = (journal_superblock_t *) buf; if (be32_to_cpu(jsb->s_header.h_magic) != JFS_MAGIC_NUMBER) { fprintf(stderr, "%s", _("Journal superblock magic number invalid!\n")); exit(1); } printf("%s", _("Journal features: ")); for (i=0, mask_ptr=&jsb->s_feature_compat; i <3; i++,mask_ptr++) { mask = be32_to_cpu(*mask_ptr); for (j=0,m=1; j < 32; j++, m<<=1) { if (mask & m) { printf(" %s", e2p_jrnl_feature2string(i, m)); printed++; } } } if (printed == 0) printf(" (none)"); printf("\n"); fputs(_("Journal size: "), stdout); if ((fs->super->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && (inode.i_flags & EXT4_HUGE_FILE_FL)) size = inode.i_blocks / (fs->blocksize / 1024); else size = inode.i_blocks >> 1; if (size < 8192) printf("%uk\n", size); else printf("%uM\n", size >> 10); printf(_("Journal length: %u\n" "Journal sequence: 0x%08x\n" "Journal start: %u\n"), (unsigned int)ntohl(jsb->s_maxlen), (unsigned int)ntohl(jsb->s_sequence), (unsigned int)ntohl(jsb->s_start)); if (jsb->s_feature_compat & ext2fs_cpu_to_be32(JFS_FEATURE_COMPAT_CHECKSUM)) printf(_("Journal checksum type: crc32\n")); if (jsb->s_feature_incompat & ext2fs_cpu_to_be32(JFS_FEATURE_INCOMPAT_CSUM_V2)) printf(_("Journal checksum type: %s\n" "Journal checksum: 0x%08x\n"), journal_checksum_type_str(jsb->s_checksum_type), ext2fs_be32_to_cpu(jsb->s_checksum)); if (jsb->s_errno != 0) printf(_("Journal errno: %d\n"), (int) ntohl(jsb->s_errno)); }
int qcow2_write_raw_image(int qcow2_fd, int raw_fd, struct ext2_qcow2_hdr *hdr) { struct ext2_qcow2_image img; errcode_t ret = 0; unsigned int l1_index, l2_index; ext2_off64_t offset; blk64_t *l1_table, *l2_table = 0; void *copy_buf = NULL; size_t size; if (hdr->crypt_method) return -QCOW_ENCRYPTED; img.fd = qcow2_fd; img.hdr = hdr; img.l2_cache = NULL; img.l1_table = NULL; img.cluster_bits = ext2fs_be32_to_cpu(hdr->cluster_bits); img.cluster_size = 1 << img.cluster_bits; img.l1_size = ext2fs_be32_to_cpu(hdr->l1_size); img.l1_offset = ext2fs_be64_to_cpu(hdr->l1_table_offset); img.l2_size = 1 << (img.cluster_bits - 3); img.image_size = ext2fs_be64_to_cpu(hdr->size); ret = ext2fs_get_memzero(img.cluster_size, &l2_table); if (ret) goto out; ret = ext2fs_get_memzero(1 << img.cluster_bits, ©_buf); if (ret) goto out; if (ext2fs_llseek(raw_fd, 0, SEEK_SET) < 0) { ret = errno; goto out; } ret = qcow2_read_l1_table(&img); if (ret) goto out; l1_table = img.l1_table; /* Walk through l1 table */ for (l1_index = 0; l1_index < img.l1_size; l1_index++) { ext2_off64_t off_out; offset = ext2fs_be64_to_cpu(l1_table[l1_index]) & ~QCOW_OFLAG_COPIED; if ((offset > img.image_size) || (offset <= 0)) continue; if (offset & QCOW_OFLAG_COMPRESSED) { ret = -QCOW_COMPRESSED; goto out; } ret = qcow2_read_l2_table(&img, offset, &l2_table); if (ret) break; /* Walk through l2 table and copy data blocks into raw image */ for (l2_index = 0; l2_index < img.l2_size; l2_index++) { offset = ext2fs_be64_to_cpu(l2_table[l2_index]) & ~QCOW_OFLAG_COPIED; if (offset == 0) continue; off_out = (l1_index * img.l2_size) + l2_index; off_out <<= img.cluster_bits; ret = qcow2_copy_data(qcow2_fd, raw_fd, offset, off_out, copy_buf, img.cluster_size); if (ret) goto out; } } /* Resize the output image to the filesystem size */ if (ext2fs_llseek(raw_fd, img.image_size - 1, SEEK_SET) < 0) return errno; ((char *)copy_buf)[0] = 0; size = write(raw_fd, copy_buf, 1); if (size != 1) return errno; out: if (copy_buf) ext2fs_free_mem(©_buf); if (img.l1_table) ext2fs_free_mem(&img.l1_table); if (l2_table) ext2fs_free_mem(&l2_table); return ret; }
static int do_one_pass(journal_t *journal, struct recovery_info *info, enum passtype pass) { unsigned int first_commit_ID, next_commit_ID; unsigned long next_log_block; int err, success = 0; journal_superblock_t * sb; journal_header_t * tmp; struct buffer_head * bh; unsigned int sequence; int blocktype; int tag_bytes = journal_tag_bytes(journal); __u32 crc32_sum = ~0; /* Transactional Checksums */ int descr_csum_size = 0; int block_error = 0; /* * First thing is to establish what we expect to find in the log * (in terms of transaction IDs), and where (in terms of log * block offsets): query the superblock. */ sb = journal->j_superblock; next_commit_ID = ext2fs_be32_to_cpu(sb->s_sequence); next_log_block = ext2fs_be32_to_cpu(sb->s_start); first_commit_ID = next_commit_ID; if (pass == PASS_SCAN) info->start_transaction = first_commit_ID; jbd_debug(1, "Starting recovery pass %d\n", pass); /* * Now we walk through the log, transaction by transaction, * making sure that each transaction has a commit block in the * expected place. Each complete transaction gets replayed back * into the main filesystem. */ while (1) { int flags; char * tagp; journal_block_tag_t * tag; struct buffer_head * obh; struct buffer_head * nbh; cond_resched(); /* If we already know where to stop the log traversal, * check right now that we haven't gone past the end of * the log. */ if (pass != PASS_SCAN) if (tid_geq(next_commit_ID, info->end_transaction)) break; jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n", next_commit_ID, next_log_block, journal->j_last); /* Skip over each chunk of the transaction looking * either the next descriptor block or the final commit * record. */ jbd_debug(3, "JBD2: checking block %ld\n", next_log_block); err = jread(&bh, journal, next_log_block); if (err) goto failed; next_log_block++; wrap(journal, next_log_block); /* What kind of buffer is it? * * If it is a descriptor block, check that it has the * expected sequence number. Otherwise, we're all done * here. */ tmp = (journal_header_t *)bh->b_data; if (tmp->h_magic != ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER)) { brelse(bh); break; } blocktype = ext2fs_be32_to_cpu(tmp->h_blocktype); sequence = ext2fs_be32_to_cpu(tmp->h_sequence); jbd_debug(3, "Found magic %d, sequence %d\n", blocktype, sequence); if (sequence != next_commit_ID) { brelse(bh); break; } /* OK, we have a valid descriptor block which matches * all of the sequence number checks. What are we going * to do with it? That depends on the pass... */ switch(blocktype) { case JFS_DESCRIPTOR_BLOCK: /* Verify checksum first */ if (journal_has_csum_v2or3(journal)) descr_csum_size = sizeof(struct journal_block_tail); if (descr_csum_size > 0 && !jbd2_descr_block_csum_verify(journal, bh->b_data)) { err = -EFSBADCRC; brelse(bh); goto failed; } /* If it is a valid descriptor block, replay it * in pass REPLAY; if journal_checksums enabled, then * calculate checksums in PASS_SCAN, otherwise, * just skip over the blocks it describes. */ if (pass != PASS_REPLAY) { if (pass == PASS_SCAN && jfs_has_feature_checksum(journal) && !info->end_transaction) { if (calc_chksums(journal, bh, &next_log_block, &crc32_sum)) { put_bh(bh); break; } put_bh(bh); continue; } next_log_block += count_tags(journal, bh); wrap(journal, next_log_block); put_bh(bh); continue; } /* A descriptor block: we can now write all of * the data blocks. Yay, useful work is finally * getting done here! */ tagp = &bh->b_data[sizeof(journal_header_t)]; while ((tagp - bh->b_data + tag_bytes) <= journal->j_blocksize - descr_csum_size) { unsigned long io_block; tag = (journal_block_tag_t *) tagp; flags = ext2fs_be16_to_cpu(tag->t_flags); io_block = next_log_block++; wrap(journal, next_log_block); err = jread(&obh, journal, io_block); if (err) { /* Recover what we can, but * report failure at the end. */ success = err; printk(KERN_ERR "JBD2: IO error %d recovering " "block %ld in log\n", err, io_block); } else { unsigned long long blocknr; J_ASSERT(obh != NULL); blocknr = read_tag_block(journal, tag); /* If the block has been * revoked, then we're all done * here. */ if (journal_test_revoke (journal, blocknr, next_commit_ID)) { brelse(obh); ++info->nr_revoke_hits; goto skip_write; } /* Look for block corruption */ if (!jbd2_block_tag_csum_verify( journal, tag, obh->b_data, ext2fs_be32_to_cpu(tmp->h_sequence))) { brelse(obh); success = -EFSBADCRC; printk(KERN_ERR "JBD2: Invalid " "checksum recovering " "block %llu in log\n", blocknr); block_error = 1; goto skip_write; } /* Find a buffer for the new * data being restored */ nbh = __getblk(journal->j_fs_dev, blocknr, journal->j_blocksize); if (nbh == NULL) { printk(KERN_ERR "JBD2: Out of memory " "during recovery.\n"); err = -ENOMEM; brelse(bh); brelse(obh); goto failed; } lock_buffer(nbh); memcpy(nbh->b_data, obh->b_data, journal->j_blocksize); if (flags & JFS_FLAG_ESCAPE) { *((__u32 *)nbh->b_data) = ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER); } BUFFER_TRACE(nbh, "marking dirty"); set_buffer_uptodate(nbh); mark_buffer_dirty(nbh); BUFFER_TRACE(nbh, "marking uptodate"); ++info->nr_replays; /* ll_rw_block(WRITE, 1, &nbh); */ unlock_buffer(nbh); brelse(obh); brelse(nbh); } skip_write: tagp += tag_bytes; if (!(flags & JFS_FLAG_SAME_UUID)) tagp += 16; if (flags & JFS_FLAG_LAST_TAG) break; } brelse(bh); continue; case JFS_COMMIT_BLOCK: /* How to differentiate between interrupted commit * and journal corruption ? * * {nth transaction} * Checksum Verification Failed * | * ____________________ * | | * async_commit sync_commit * | | * | GO TO NEXT "Journal Corruption" * | TRANSACTION * | * {(n+1)th transanction} * | * _______|______________ * | | * Commit block found Commit block not found * | | * "Journal Corruption" | * _____________|_________ * | | * nth trans corrupt OR nth trans * and (n+1)th interrupted interrupted * before commit block * could reach the disk. * (Cannot find the difference in above * mentioned conditions. Hence assume * "Interrupted Commit".) */ /* Found an expected commit block: if checksums * are present verify them in PASS_SCAN; else not * much to do other than move on to the next sequence * number. */ if (pass == PASS_SCAN && jfs_has_feature_checksum(journal)) { int chksum_err, chksum_seen; struct commit_header *cbh = (struct commit_header *)bh->b_data; unsigned found_chksum = ext2fs_be32_to_cpu(cbh->h_chksum[0]); chksum_err = chksum_seen = 0; if (info->end_transaction) { journal->j_failed_commit = info->end_transaction; brelse(bh); break; } if (crc32_sum == found_chksum && cbh->h_chksum_type == JFS_CRC32_CHKSUM && cbh->h_chksum_size == JFS_CRC32_CHKSUM_SIZE) chksum_seen = 1; else if (!(cbh->h_chksum_type == 0 && cbh->h_chksum_size == 0 && found_chksum == 0 && !chksum_seen)) /* * If fs is mounted using an old kernel and then * kernel with journal_chksum is used then we * get a situation where the journal flag has * checksum flag set but checksums are not * present i.e chksum = 0, in the individual * commit blocks. * Hence to avoid checksum failures, in this * situation, this extra check is added. */ chksum_err = 1; if (chksum_err) { info->end_transaction = next_commit_ID; if (!jfs_has_feature_async_commit(journal)){ journal->j_failed_commit = next_commit_ID; brelse(bh); break; } } crc32_sum = ~0; } if (pass == PASS_SCAN && !jbd2_commit_block_csum_verify(journal, bh->b_data)) { info->end_transaction = next_commit_ID; if (!jfs_has_feature_async_commit(journal)) { journal->j_failed_commit = next_commit_ID; brelse(bh); break; } } brelse(bh); next_commit_ID++; continue; case JFS_REVOKE_BLOCK: /* If we aren't in the REVOKE pass, then we can * just skip over this block. */ if (pass != PASS_REVOKE) { brelse(bh); continue; } err = scan_revoke_records(journal, bh, next_commit_ID, info); brelse(bh); if (err) goto failed; continue; default: jbd_debug(3, "Unrecognised magic %d, end of scan.\n", blocktype); brelse(bh); goto done; } } done: /* * We broke out of the log scan loop: either we came to the * known end of the log or we found an unexpected block in the * log. If the latter happened, then we know that the "current" * transaction marks the end of the valid log. */ if (pass == PASS_SCAN) { if (!info->end_transaction) info->end_transaction = next_commit_ID; } else { /* It's really bad news if different passes end up at * different places (but possible due to IO errors). */ if (info->end_transaction != next_commit_ID) { printk(KERN_ERR "JBD2: recovery pass %d ended at " "transaction %u, expected %u\n", pass, next_commit_ID, info->end_transaction); if (!success) success = -EIO; } } if (block_error && success == 0) success = -EIO; return success; failed: return err; }
errcode_t journal_find_head(journal_t *journal) { unsigned int next_commit_ID; blk64_t next_log_block, head_block; int err; journal_superblock_t *sb; journal_header_t *tmp; struct buffer_head *bh; unsigned int sequence; int blocktype; /* * First thing is to establish what we expect to find in the log * (in terms of transaction IDs), and where (in terms of log * block offsets): query the superblock. */ sb = journal->j_superblock; next_commit_ID = ext2fs_be32_to_cpu(sb->s_sequence); next_log_block = ext2fs_be32_to_cpu(sb->s_start); head_block = next_log_block; if (next_log_block == 0) return 0; bh = getblk(journal->j_dev, 0, journal->j_blocksize); if (bh == NULL) return ENOMEM; /* * Now we walk through the log, transaction by transaction, * making sure that each transaction has a commit block in the * expected place. Each complete transaction gets replayed back * into the main filesystem. */ while (1) { dbg_printf("Scanning for sequence ID %u at %lu/%lu\n", next_commit_ID, (unsigned long)next_log_block, journal->j_last); /* Skip over each chunk of the transaction looking * either the next descriptor block or the final commit * record. */ err = journal_bmap(journal, next_log_block, &bh->b_blocknr); if (err) goto err; mark_buffer_uptodate(bh, 0); ll_rw_block(READ, 1, &bh); err = bh->b_err; if (err) goto err; next_log_block++; wrap(journal, next_log_block); /* What kind of buffer is it? * * If it is a descriptor block, check that it has the * expected sequence number. Otherwise, we're all done * here. */ tmp = (journal_header_t *)bh->b_data; if (tmp->h_magic != ext2fs_cpu_to_be32(JFS_MAGIC_NUMBER)) { dbg_printf("JBD2: wrong magic 0x%x\n", tmp->h_magic); goto err; } blocktype = ext2fs_be32_to_cpu(tmp->h_blocktype); sequence = ext2fs_be32_to_cpu(tmp->h_sequence); dbg_printf("Found magic %d, sequence %d\n", blocktype, sequence); if (sequence != next_commit_ID) { dbg_printf("JBD2: Wrong sequence %d (wanted %d)\n", sequence, next_commit_ID); goto err; } /* OK, we have a valid descriptor block which matches * all of the sequence number checks. What are we going * to do with it? That depends on the pass... */ switch (blocktype) { case JFS_DESCRIPTOR_BLOCK: next_log_block += count_tags(journal, bh->b_data); wrap(journal, next_log_block); continue; case JFS_COMMIT_BLOCK: head_block = next_log_block; next_commit_ID++; continue; case JFS_REVOKE_BLOCK: continue; default: dbg_printf("Unrecognised magic %d, end of scan.\n", blocktype); err = -EINVAL; goto err; } } err: if (err == 0) { dbg_printf("head seq=%d blk=%llu\n", next_commit_ID, head_block); journal->j_transaction_sequence = next_commit_ID; journal->j_head = head_block; } brelse(bh); return err; }