int build_root(struct gfs2_sbd *sdp) { struct gfs2_inum inum; uint64_t bn; struct gfs2_buffer_head *bh = NULL; int err = lgfs2_dinode_alloc(sdp, 1, &bn); if (err != 0) return -1; inum.no_formal_ino = sdp->md.next_inum++; inum.no_addr = bn; err = init_dinode(sdp, &bh, &inum, S_IFDIR | 0755, 0, &inum); if (err != 0) return -1; sdp->md.rooti = lgfs2_inode_get(sdp, bh); if (sdp->md.rooti == NULL) return -1; if (cfg_debug) { printf("\nRoot directory:\n"); gfs2_dinode_print(&sdp->md.rooti->i_di); } sdp->md.rooti->bh_owned = 1; return 0; }
int build_master(struct gfs2_sbd *sdp) { struct gfs2_inum inum; uint64_t bn; struct gfs2_buffer_head *bh = NULL; int err = lgfs2_dinode_alloc(sdp, 1, &bn); if (err != 0) return -1; inum.no_formal_ino = sdp->md.next_inum++; inum.no_addr = bn; err = init_dinode(sdp, &bh, &inum, S_IFDIR | 0755, GFS2_DIF_SYSTEM, &inum); if (err != 0) return -1; sdp->master_dir = lgfs2_inode_get(sdp, bh); if (sdp->master_dir == NULL) return -1; if (cfg_debug) { printf("\nMaster dir:\n"); gfs2_dinode_print(&sdp->master_dir->i_di); } sdp->master_dir->bh_owned = 1; return 0; }
/** * find_journal_block - figure out where a journal starts, given the name * Returns: journal block number, changes j_size to the journal size */ uint64_t find_journal_block(const char *journal, uint64_t *j_size) { int journal_num; uint64_t jindex_block, jblock = 0; int amtread; struct gfs2_buffer_head *jindex_bh, *j_bh; char jbuf[sbd.bsize]; journal_num = atoi(journal + 7); if (journal_num < 0) return 0; /* Figure out the block of the jindex file */ if (sbd.gfs1) jindex_block = sbd1->sb_jindex_di.no_addr; else jindex_block = masterblock("jindex"); /* read in the block */ jindex_bh = bread(&sbd, jindex_block); /* get the dinode data from it. */ gfs2_dinode_in(&di, jindex_bh); /* parse disk inode to struct*/ if (!sbd.gfs1) do_dinode_extended(&di, jindex_bh); /* parse dir. */ if (sbd.gfs1) { struct gfs2_inode *jiinode; struct gfs_jindex ji; jiinode = lgfs2_inode_get(&sbd, jindex_bh); if (jiinode == NULL) return 0; amtread = gfs2_readi(jiinode, (void *)&jbuf, journal_num * sizeof(struct gfs_jindex), sizeof(struct gfs_jindex)); if (amtread) { gfs_jindex_in(&ji, jbuf); jblock = ji.ji_addr; *j_size = ji.ji_nsegment * 0x10; } inode_put(&jiinode); } else { struct gfs2_dinode jdi; if (journal_num > indirect->ii[0].dirents - 2) return 0; jblock = indirect->ii[0].dirent[journal_num + 2].block; j_bh = bread(&sbd, jblock); gfs2_dinode_in(&jdi, j_bh);/* parse dinode to struct */ *j_size = jdi.di_size; brelse(j_bh); } brelse(jindex_bh); return jblock; }
/** * dump_journal - dump a journal file's contents. * @journal: name of the journal to dump * @tblk: block number to trace in the journals * * This function dumps the contents of a journal. If a trace block is specified * then only information printed is: (1) log descriptors that reference that * block, (2) metadata in the journal that references the block, or (3) * rgrp bitmaps that reference that block's allocation bit status. */ void dump_journal(const char *journal, int tblk) { struct gfs2_buffer_head *j_bh = NULL, dummy_bh; uint64_t jblock, j_size, jb, abs_block, saveblk, wrappt = 0; int start_line, journal_num; struct gfs2_inode *j_inode = NULL; int ld_blocks = 0, offset_from_ld = 0; uint64_t tblk_off = 0, bblk_off = 0, bitblk = 0; uint64_t highest_seq = 0; char *jbuf = NULL; struct rgrp_tree *rgd = NULL; uint64_t abs_ld = 0; start_line = line; lines_per_row[dmode] = 1; journal_num = atoi(journal + 7); print_gfs2("Dumping journal #%d.", journal_num); if (tblk) { dmode = HEX_MODE; print_gfs2(" Tracing block 0x%llx", (unsigned long long)tblk); } eol(0); jblock = find_journal_block(journal, &j_size); if (!jblock) return; if (!sbd.gfs1) { j_bh = bread(&sbd, jblock); j_inode = lgfs2_inode_get(&sbd, j_bh); if (j_inode == NULL) { fprintf(stderr, "Out of memory\n"); exit(-1); } jbuf = malloc(sbd.bsize); if (jbuf == NULL) { fprintf(stderr, "Out of memory\n"); exit(-1); } } if (tblk) { uint64_t wp; rgd = gfs2_blk2rgrpd(&sbd, tblk); if (!rgd) { print_gfs2("Can't locate the rgrp for block 0x%x", tblk); eol(0); } else { uint64_t o; int bmap = 0; print_gfs2("rgd: 0x%llx for 0x%x, ", rgd->ri.ri_addr, rgd->ri.ri_length); o = tblk - rgd->ri.ri_data0; if (o >= (rgd->bits->bi_start + rgd->bits->bi_len) * GFS2_NBBY) o += (sizeof(struct gfs2_rgrp) - sizeof(struct gfs2_meta_header)) * GFS2_NBBY; bmap = o / sbd.sd_blocks_per_bitmap; bitblk = rgd->ri.ri_addr + bmap; print_gfs2("bitmap: %d, bitblk: 0x%llx", bmap, (unsigned long long)bitblk); eol(0); } wrappt = find_wrap_pt(j_inode, jbuf, jblock, j_size); wp = wrappt / (sbd.gfs1 ? 1 : sbd.bsize); print_gfs2("Starting at journal wrap block: 0x%llx " "(j + 0x%llx)", (unsigned long long)jblock + wp, (unsigned long long)wp); eol(0); } for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.bsize)) { int is_pertinent = 1; uint32_t block_type = 0; if (sbd.gfs1) { if (j_bh) brelse(j_bh); abs_block = jblock + ((jb + wrappt) % j_size); j_bh = bread(&sbd, abs_block); dummy_bh.b_data = j_bh->b_data; } else { int error = fsck_readi(j_inode, (void *)jbuf, ((jb + wrappt) % j_size), sbd.bsize, &abs_block); if (!error) /* end of file */ break; dummy_bh.b_data = jbuf; } offset_from_ld++; block_type = get_block_type(&dummy_bh, NULL); if (block_type == GFS2_METATYPE_LD) { ld_blocks = process_ld(abs_block, wrappt, j_size, jb, &dummy_bh, tblk, &tblk_off, bitblk, rgd, &is_pertinent, &bblk_off); offset_from_ld = 0; abs_ld = abs_block; } else if (!tblk && block_type == GFS2_METATYPE_LH) { struct gfs2_log_header lh; struct gfs_log_header lh1; if (sbd.gfs1) { gfs_log_header_in(&lh1, &dummy_bh); check_journal_wrap(lh1.lh_sequence, &highest_seq); print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: " "Flags:%x, Seq: 0x%llx, 1st: 0x%llx, " "tail: 0x%llx, last: 0x%llx", abs_block, jb + wrappt, lh1.lh_flags, lh1.lh_sequence, lh1.lh_first, lh1.lh_tail, lh1.lh_last_dump); } else { gfs2_log_header_in(&lh, &dummy_bh); check_journal_wrap(lh.lh_sequence, &highest_seq); print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: Seq" ": 0x%llx, tail: 0x%x, blk: 0x%x%s", abs_block, ((jb + wrappt) % j_size) / sbd.bsize, lh.lh_sequence, lh.lh_tail, lh.lh_blkno, lh.lh_flags == GFS2_LOG_HEAD_UNMOUNT ? " [UNMOUNTED]" : ""); } eol(0); } else if ((ld_blocks > 0) && (sbd.gfs1 || block_type == GFS2_METATYPE_LB)) { print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log descriptor" " continuation block", abs_block, ((jb + wrappt) % j_size) / sbd.bsize); eol(0); print_gfs2(" "); ld_blocks -= print_ld_blks((uint64_t *)dummy_bh.b_data + (sbd.gfs1 ? 0 : sizeof(struct gfs2_meta_header)), (dummy_bh.b_data + sbd.bsize), start_line, tblk, &tblk_off, 0, rgd, 0, 1, NULL, 0); } else if (block_type == 0) { continue; } /* Check if this metadata block references the block we're trying to trace. */ if (details || (tblk && ((is_pertinent && ((tblk_off && offset_from_ld == tblk_off) || (bblk_off && offset_from_ld == bblk_off))) || meta_has_ref(abs_block, tblk)))) { uint64_t ref_blk = 0; saveblk = block; block = abs_block; if (tblk && !details) { ref_blk = get_ldref(abs_ld, offset_from_ld); display(0, 1, tblk, ref_blk); } else { display(0, 0, 0, 0); } block = saveblk; } } inode_put(&j_inode); brelse(j_bh); blockhist = -1; /* So we don't print anything else */ free(jbuf); if (!termlines) fflush(stdout); }