static int expand_dir_proc(ext2_filsys fs,
blk_t *blocknr,
e2_blkcnt_t blockcnt,
blk_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct expand_dir_struct *es = (struct expand_dir_struct *) priv_data;
blk_t new_blk;
static blk_t last_blk = 0;
char *block;
errcode_t retval;
if (*blocknr) {
last_blk = *blocknr;
return 0;
}
retval = ext2fs_new_block(fs, last_blk, 0, &new_blk);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
if (blockcnt > 0) {
retval = ext2fs_new_dir_block(fs, 0, 0, &block);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
es->done = 1;
retval = ext2fs_write_dir_block(fs, new_blk, block);
} else {
retval = ext2fs_get_mem(fs->blocksize, &block);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
memset(block, 0, fs->blocksize);
retval = io_channel_write_blk(fs->io, new_blk, 1, block);
}
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
ext2fs_free_mem(&block);
*blocknr = new_blk;
ext2fs_block_alloc_stats(fs, new_blk, +1);
es->newblocks++;
if (es->done)
return (BLOCK_CHANGED | BLOCK_ABORT);
else
return BLOCK_CHANGED;
}
static int set_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
e2_blkcnt_t blockcnt,
blk_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct set_badblock_record *rec = (struct set_badblock_record *)
priv_data;
errcode_t retval;
blk_t blk;
if (blockcnt >= 0) {
/*
* Get the next bad block.
*/
if (!ext2fs_badblocks_list_iterate(rec->bb_iter, &blk))
return BLOCK_ABORT;
rec->bad_block_count++;
} else {
/*
* An indirect block; fetch a block from the
* previously used indirect block list. The block
* most be not marked as used; if so, get another one.
* If we run out of reserved indirect blocks, allocate
* a new one.
*/
retry:
if (rec->ind_blocks_ptr < rec->ind_blocks_size) {
blk = rec->ind_blocks[rec->ind_blocks_ptr++];
if (ext2fs_test_block_bitmap(fs->block_map, blk))
goto retry;
} else {
retval = ext2fs_new_block(fs, 0, 0, &blk);
if (retval) {
rec->err = retval;
return BLOCK_ABORT;
}
}
retval = io_channel_write_blk(fs->io, blk, 1, rec->block_buf);
if (retval) {
rec->err = retval;
return BLOCK_ABORT;
}
}
/*
* Update block counts
*/
ext2fs_block_alloc_stats(fs, blk, +1);
*block_nr = blk;
return BLOCK_CHANGED;
}
static int mkjournal_proc(ext2_filsys fs,
blk_t *blocknr,
e2_blkcnt_t blockcnt,
blk_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct mkjournal_struct *es = (struct mkjournal_struct *) priv_data;
blk_t new_blk;
static blk_t last_blk = 0;
errcode_t retval;
if (*blocknr) {
last_blk = *blocknr;
return 0;
}
retval = ext2fs_new_block(fs, last_blk, 0, &new_blk);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
if (blockcnt > 0)
es->num_blocks--;
es->newblocks++;
retval = io_channel_write_blk(fs->io, new_blk, 1, es->buf);
if (blockcnt == 0)
memset(es->buf, 0, fs->blocksize);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
*blocknr = new_blk;
last_blk = new_blk;
ext2fs_block_alloc_stats(fs, new_blk, +1);
if (es->num_blocks == 0)
return (BLOCK_CHANGED | BLOCK_ABORT);
else
return BLOCK_CHANGED;
}
/*
* This function zeros out the allocated block, and updates all of the
* appropriate filesystem records.
*/
errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
char *block_buf, blk_t *ret)
{
errcode_t retval;
blk_t block;
char *buf = 0;
if (!block_buf) {
retval = ext2fs_get_mem(fs->blocksize, &buf);
if (retval)
return retval;
block_buf = buf;
}
memset(block_buf, 0, fs->blocksize);
if (!fs->block_map) {
retval = ext2fs_read_block_bitmap(fs);
if (retval)
goto fail;
}
retval = ext2fs_new_block(fs, goal, 0, &block);
if (retval)
goto fail;
retval = io_channel_write_blk(fs->io, block, 1, block_buf);
if (retval)
goto fail;
ext2fs_block_alloc_stats(fs, block, +1);
*ret = block;
return 0;
fail:
if (buf)
ext2fs_free_mem(&buf);
return retval;
}
static int mkjournal_proc(ext2_filsys fs,
blk_t *blocknr,
e2_blkcnt_t blockcnt,
blk_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct mkjournal_struct *es = (struct mkjournal_struct *) priv_data;
blk_t new_blk;
errcode_t retval;
if (*blocknr) {
es->goal = *blocknr;
return 0;
}
retval = ext2fs_new_block(fs, es->goal, 0, &new_blk);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
if (blockcnt >= 0)
es->num_blocks--;
es->newblocks++;
retval = 0;
if (blockcnt <= 0)
retval = io_channel_write_blk(fs->io, new_blk, 1, es->buf);
else {
if (es->zero_count) {
if ((es->blk_to_zero + es->zero_count == new_blk) &&
(es->zero_count < 1024))
es->zero_count++;
else {
retval = ext2fs_zero_blocks(fs,
es->blk_to_zero,
es->zero_count,
0, 0);
es->zero_count = 0;
}
}
if (es->zero_count == 0) {
es->blk_to_zero = new_blk;
es->zero_count = 1;
}
}
if (blockcnt == 0)
memset(es->buf, 0, fs->blocksize);
if (retval) {
es->err = retval;
return BLOCK_ABORT;
}
*blocknr = es->goal = new_blk;
ext2fs_block_alloc_stats(fs, new_blk, +1);
if (es->num_blocks == 0)
return (BLOCK_CHANGED | BLOCK_ABORT);
else
return BLOCK_CHANGED;
}
errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
const char *name)
{
errcode_t retval;
struct ext2_inode parent_inode, inode;
ext2_ino_t ino = inum;
ext2_ino_t scratch_ino;
blk_t blk;
char *block = 0;
char *ext2bp_block = 0;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
/*
* Allocate an inode, if necessary
*/
if (!ino) {
retval = ext2fs_new_inode(fs, parent, LINUX_S_IFDIR | 0755,
0, &ino);
if (retval)
goto cleanup;
}
/*
* Allocate a data block for the directory
*/
retval = ext2fs_new_block(fs, 0, 0, &blk);
printf("Using block %lu for the dir\n", blk);
if (retval)
goto cleanup;
printf("Writing the dir info into the buffer\n");
/*
* Create a scratch template for the directory
*/
/* Vijay: Offset the block address by the backpointer information */
retval = ext2fs_new_dir_block(fs, ino, parent, &block);
//ext2bp_block = block + EXT2BP_HEADER_SIZE;
//retval = ext2fs_new_dir_block(fs, ino, parent, &ext2bp_block);
if (retval)
goto cleanup;
/*
* Get the parent's inode, if necessary
*/
if (parent != ino) {
retval = ext2fs_read_inode(fs, parent, &parent_inode);
if (retval)
goto cleanup;
} else
memset(&parent_inode, 0, sizeof(parent_inode));
/*
* Create the inode structure....
*/
memset(&inode, 0, sizeof(struct ext2_inode));
inode.i_mode = LINUX_S_IFDIR | (0777 & ~fs->umask);
inode.i_uid = inode.i_gid = 0;
ext2fs_iblk_set(fs, &inode, 1);
inode.i_block[0] = blk;
inode.i_links_count = 2;
inode.i_size = fs->blocksize;
/* Vijay: Adding backlink to the inode - Modifying position 0
* since this is a new inode - It will not have any other links
* pointing to it. First, we need to reset all the backlinks.
*/
printf("Vijay: Adding the backlink to %s\n", name);
int i;
for(i=0; i < EXT2_N_LINKS; i++)
inode.i_backlinks[i] = 0;
inode.i_backlinks[0] = parent;
printf("Going to write the dir block\n");
/*
* Write out the inode and inode data block
*/
retval = ext2fs_write_dir_block(fs, blk, block);
if (retval)
goto cleanup;
retval = ext2fs_write_new_inode(fs, ino, &inode);
if (retval)
goto cleanup;
printf("Link the directory into the filesystem hierarchy\n");
/*
* Link the directory into the filesystem hierarchy
*/
if (name) {
retval = ext2fs_lookup(fs, parent, name, strlen(name), 0,
&scratch_ino);
if (!retval) {
retval = EXT2_ET_DIR_EXISTS;
name = 0;
goto cleanup;
}
if (retval != EXT2_ET_FILE_NOT_FOUND)
goto cleanup;
retval = ext2fs_link(fs, parent, name, ino, EXT2_FT_DIR);
printf("Linking done: %lu\n", retval);
if (retval)
goto cleanup;
}
/*
* Update parent inode's counts
*/
if (parent != ino) {
parent_inode.i_links_count++;
retval = ext2fs_write_inode(fs, parent, &parent_inode);
if (retval)
goto cleanup;
}
/*
* Update accounting....
*/
ext2fs_block_alloc_stats(fs, blk, +1);
ext2fs_inode_alloc_stats2(fs, ino, +1, 1);
cleanup:
if (block)
ext2fs_free_mem(&block);
return retval;
}
errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
const char *name)
{
errcode_t retval;
struct ext2_inode parent_inode, inode;
ext2_ino_t ino = inum;
ext2_ino_t scratch_ino;
blk_t blk;
char *block = 0;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
/*
* Allocate an inode, if necessary
*/
if (!ino) {
retval = ext2fs_new_inode(fs, parent, LINUX_S_IFDIR | 0755,
0, &ino);
if (retval)
goto cleanup;
}
/*
* Allocate a data block for the directory
*/
retval = ext2fs_new_block(fs, 0, 0, &blk);
if (retval)
goto cleanup;
/*
* Create a scratch template for the directory
*/
retval = ext2fs_new_dir_block(fs, ino, parent, &block);
if (retval)
goto cleanup;
/*
* Get the parent's inode, if necessary
*/
if (parent != ino) {
retval = ext2fs_read_inode(fs, parent, &parent_inode);
if (retval)
goto cleanup;
} else
memset(&parent_inode, 0, sizeof(parent_inode));
/*
* Create the inode structure....
*/
memset(&inode, 0, sizeof(struct ext2_inode));
inode.i_mode = LINUX_S_IFDIR | (0777 & ~fs->umask);
inode.i_uid = inode.i_gid = 0;
inode.i_blocks = fs->blocksize / 512;
inode.i_block[0] = blk;
inode.i_links_count = 2;
inode.i_ctime = inode.i_atime = inode.i_mtime = fs->now ? fs->now : time(NULL);
inode.i_size = fs->blocksize;
/*
* Write out the inode and inode data block
*/
retval = ext2fs_write_dir_block(fs, blk, block);
if (retval)
goto cleanup;
retval = ext2fs_write_new_inode(fs, ino, &inode);
if (retval)
goto cleanup;
/*
* Link the directory into the filesystem hierarchy
*/
if (name) {
retval = ext2fs_lookup(fs, parent, name, strlen(name), 0,
&scratch_ino);
if (!retval) {
retval = EXT2_ET_DIR_EXISTS;
name = 0;
goto cleanup;
}
if (retval != EXT2_ET_FILE_NOT_FOUND)
goto cleanup;
retval = ext2fs_link(fs, parent, name, ino, EXT2_FT_DIR);
if (retval)
goto cleanup;
}
/*
* Update parent inode's counts
*/
if (parent != ino) {
parent_inode.i_links_count++;
retval = ext2fs_write_inode(fs, parent, &parent_inode);
if (retval)
goto cleanup;
}
/*
* Update accounting....
*/
ext2fs_block_alloc_stats(fs, blk, +1);
ext2fs_inode_alloc_stats2(fs, ino, +1, 1);
cleanup:
if (block)
ext2fs_free_mem(&block);
return retval;
}
static ext2_ino_t ext2CreateSymlink(ext2_vd *vd, const char *path, const char * targetdir, const char * name, mode_t type)
{
ext2_inode_t *target_ni = NULL;
ext2_ino_t newentry = 0;
ext2_ino_t ino = 0;
// Check if it does exist
target_ni = ext2OpenEntry(vd, targetdir);
if (!target_ni)
goto cleanup;
int err = ext2fs_new_inode(vd->fs, target_ni->ino, type, 0, &ino);
if (err) {
errno = EFAULT;
goto cleanup;
}
while((err = ext2fs_link(vd->fs, target_ni->ino, name, ino, EXT2_FT_SYMLINK)) == EXT2_ET_DIR_NO_SPACE)
{
if (ext2fs_expand_dir(vd->fs, target_ni->ino) != EXT2_ET_OK) {
errno = EMLINK;
goto cleanup;
}
}
if(err != EXT2_ET_OK) {
errno = EMLINK;
return 0;
}
ext2fs_inode_alloc_stats2(vd->fs, ino, +1, 0);
struct ext2_inode inode;
memset(&inode, 0, sizeof(inode));
inode.i_mode = type;
inode.i_atime = inode.i_ctime = inode.i_mtime = time(NULL);
inode.i_links_count = 1;
inode.i_size = strlen(path); //initial size of file
inode.i_uid = target_ni->ni.i_uid;
inode.i_gid = target_ni->ni.i_gid;
if (strlen(path) <= sizeof(inode.i_block))
{
/* fast symlink */
strncpy((char *)&(inode.i_block[0]),path,sizeof(inode.i_blocks));
}
else
{
/* slow symlink */
char * buffer = mem_alloc(vd->fs->blocksize);
if (buffer)
{
blk_t blk;
strncpy(buffer, path, vd->fs->blocksize);
err = ext2fs_new_block(vd->fs, 0, 0, &blk);
if (!err)
{
inode.i_block[0] = blk;
inode.i_blocks = vd->fs->blocksize / 512;
vd->fs->io->manager->write_blk(vd->fs->io, blk, 1, buffer);
ext2fs_block_alloc_stats(vd->fs, blk, +1);
}
mem_free(buffer);
}
}
if(ext2fs_write_new_inode(vd->fs, ino, &inode) != 0)
newentry = ino;
cleanup:
if(target_ni)
ext2CloseEntry(vd, target_ni);
return newentry;
}
/*
* allocate_dir_block --- this function allocates a new directory
* block for a particular inode; this is done if a directory has
* a "hole" in it, or if a directory has a illegal block number
* that was zeroed out and now needs to be replaced.
*/
static int allocate_dir_block(e2fsck_t ctx,
struct ext2_db_entry *db,
char *buf, struct problem_context *pctx)
{
ext2_filsys fs = ctx->fs;
blk_t blk;
char *block;
struct ext2_inode inode;
if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0)
return 1;
/*
* Read the inode and block bitmaps in; we'll be messing with
* them.
*/
e2fsck_read_bitmaps(ctx);
/*
* First, find a free block
*/
pctx->errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
if (pctx->errcode) {
pctx->str = "ext2fs_new_block";
fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
return 1;
}
ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
ext2fs_mark_block_bitmap(fs->block_map, blk);
ext2fs_mark_bb_dirty(fs);
/*
* Now let's create the actual data block for the inode
*/
if (db->blockcnt)
pctx->errcode = ext2fs_new_dir_block(fs, 0, 0, &block);
else
pctx->errcode = ext2fs_new_dir_block(fs, db->ino,
EXT2_ROOT_INO, &block);
if (pctx->errcode) {
pctx->str = "ext2fs_new_dir_block";
fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
return 1;
}
pctx->errcode = ext2fs_write_dir_block(fs, blk, block);
ext2fs_free_mem((void **) &block);
if (pctx->errcode) {
pctx->str = "ext2fs_write_dir_block";
fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
return 1;
}
/*
* Update the inode block count
*/
e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block");
inode.i_blocks += fs->blocksize / 512;
if (inode.i_size < (db->blockcnt+1) * fs->blocksize)
inode.i_size = (db->blockcnt+1) * fs->blocksize;
e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block");
/*
* Finally, update the block pointers for the inode
*/
db->blk = blk;
pctx->errcode = ext2fs_block_iterate2(fs, db->ino, BLOCK_FLAG_HOLE,
0, update_dir_block, db);
if (pctx->errcode) {
pctx->str = "ext2fs_block_iterate";
fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
return 1;
}
return 0;
}
/*
* This routine gets the lost_and_found inode, making it a directory
* if necessary
*/
ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix)
{
ext2_filsys fs = ctx->fs;
ext2_ino_t ino;
blk_t blk;
errcode_t retval;
struct ext2_inode inode;
char * block;
static const char name[] = "lost+found";
struct problem_context pctx;
if (ctx->lost_and_found)
return ctx->lost_and_found;
clear_problem_context(&pctx);
retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name,
sizeof(name)-1, 0, &ino);
if (retval && !fix)
return 0;
if (!retval) {
if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) {
ctx->lost_and_found = ino;
return ino;
}
/* Lost+found isn't a directory! */
if (!fix)
return 0;
pctx.ino = ino;
if (!fix_problem(ctx, PR_3_LPF_NOTDIR, &pctx))
return 0;
/* OK, unlink the old /lost+found file. */
pctx.errcode = ext2fs_unlink(fs, EXT2_ROOT_INO, name, ino, 0);
if (pctx.errcode) {
pctx.str = "ext2fs_unlink";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
(void) e2fsck_dir_info_set_parent(ctx, ino, 0);
e2fsck_adjust_inode_count(ctx, ino, -1);
} else if (retval != EXT2_ET_FILE_NOT_FOUND) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx);
}
if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0))
return 0;
/*
* Read the inode and block bitmaps in; we'll be messing with
* them.
*/
e2fsck_read_bitmaps(ctx);
/*
* First, find a free block
*/
retval = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx);
return 0;
}
ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
ext2fs_block_alloc_stats(fs, blk, +1);
/*
* Next find a free inode.
*/
retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700,
ctx->inode_used_map, &ino);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx);
return 0;
}
ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino);
ext2fs_inode_alloc_stats2(fs, ino, +1, 1);
/*
* Now let's create the actual data block for the inode
*/
retval = ext2fs_new_dir_block(fs, ino, EXT2_ROOT_INO, &block);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_DIR_BLOCK, &pctx);
return 0;
}
retval = ext2fs_write_dir_block(fs, blk, block);
ext2fs_free_mem(&block);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx);
return 0;
}
/*
* Set up the inode structure
*/
memset(&inode, 0, sizeof(inode));
inode.i_mode = 040700;
inode.i_size = fs->blocksize;
inode.i_atime = inode.i_ctime = inode.i_mtime = ctx->now;
inode.i_links_count = 2;
ext2fs_iblk_set(fs, &inode, 1);
inode.i_block[0] = blk;
/*
* Next, write out the inode.
*/
pctx.errcode = ext2fs_write_new_inode(fs, ino, &inode);
if (pctx.errcode) {
pctx.str = "ext2fs_write_inode";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
/*
* Finally, create the directory link
*/
pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR);
if (pctx.errcode) {
pctx.str = "ext2fs_link";
fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
return 0;
}
/*
* Miscellaneous bookkeeping that needs to be kept straight.
*/
e2fsck_add_dir_info(ctx, ino, EXT2_ROOT_INO);
e2fsck_adjust_inode_count(ctx, EXT2_ROOT_INO, 1);
ext2fs_icount_store(ctx->inode_count, ino, 2);
ext2fs_icount_store(ctx->inode_link_info, ino, 2);
ctx->lost_and_found = ino;
#if 0
printf("/lost+found created; inode #%lu\n", ino);
#endif
return ino;
}
/*
* This makes sure the root inode is present; if not, we ask if the
* user wants us to create it. Not creating it is a fatal error.
*/
static void check_root(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
blk_t blk;
struct ext2_inode inode;
char * block;
struct problem_context pctx;
clear_problem_context(&pctx);
if (ext2fs_test_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO)) {
/*
* If the root inode is not a directory, die here. The
* user must have answered 'no' in pass1 when we
* offered to clear it.
*/
if (!(ext2fs_test_inode_bitmap(ctx->inode_dir_map,
EXT2_ROOT_INO))) {
fix_problem(ctx, PR_3_ROOT_NOT_DIR_ABORT, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
}
return;
}
if (!fix_problem(ctx, PR_3_NO_ROOT_INODE, &pctx)) {
fix_problem(ctx, PR_3_NO_ROOT_INODE_ABORT, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
e2fsck_read_bitmaps(ctx);
/*
* First, find a free block
*/
pctx.errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
if (pctx.errcode) {
pctx.str = "ext2fs_new_block";
fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
ext2fs_mark_block_bitmap(fs->block_map, blk);
ext2fs_mark_bb_dirty(fs);
/*
* Now let's create the actual data block for the inode
*/
pctx.errcode = ext2fs_new_dir_block(fs, EXT2_ROOT_INO, EXT2_ROOT_INO,
&block);
if (pctx.errcode) {
pctx.str = "ext2fs_new_dir_block";
fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
pctx.errcode = ext2fs_write_dir_block(fs, blk, block);
if (pctx.errcode) {
pctx.str = "ext2fs_write_dir_block";
fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
ext2fs_free_mem(&block);
/*
* Set up the inode structure
*/
memset(&inode, 0, sizeof(inode));
inode.i_mode = 040755;
inode.i_size = fs->blocksize;
inode.i_atime = inode.i_ctime = inode.i_mtime = ctx->now;
inode.i_links_count = 2;
ext2fs_iblk_set(fs, &inode, 1);
inode.i_block[0] = blk;
/*
* Write out the inode.
*/
pctx.errcode = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode);
if (pctx.errcode) {
pctx.str = "ext2fs_write_inode";
fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
}
/*
* Miscellaneous bookkeeping...
*/
e2fsck_add_dir_info(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO);
ext2fs_icount_store(ctx->inode_count, EXT2_ROOT_INO, 2);
ext2fs_icount_store(ctx->inode_link_info, EXT2_ROOT_INO, 2);
ext2fs_mark_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO);
ext2fs_mark_inode_bitmap(ctx->inode_dir_map, EXT2_ROOT_INO);
ext2fs_mark_inode_bitmap(fs->inode_map, EXT2_ROOT_INO);
ext2fs_mark_ib_dirty(fs);
}
