static void create_root_dir(ext2_filsys fs)
{
errcode_t retval;
struct ext2_inode inode;
retval = ext2fs_mkdir(fs, EXT2_ROOT_INO, EXT2_ROOT_INO, 0);
if (retval) {
com_err("ext2fs_mkdir", retval, _("while creating root dir"));
exit(1);
}
if (geteuid()) {
retval = ext2fs_read_inode(fs, EXT2_ROOT_INO, &inode);
if (retval) {
com_err("ext2fs_read_inode", retval,
_("while reading root inode"));
exit(1);
}
inode.i_uid = getuid();
if (inode.i_uid)
inode.i_gid = getgid();
retval = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode);
if (retval) {
com_err("ext2fs_write_inode", retval,
_("while setting root inode ownership"));
exit(1);
}
}
}
static void move_quota_inode(ext2_filsys fs, ext2_ino_t from_ino,
ext2_ino_t to_ino, int qtype)
{
struct ext2_inode inode;
char qf_name[QUOTA_NAME_LEN];
/* We need the inode bitmap to be loaded */
if (ext2fs_read_bitmaps(fs))
return;
if (ext2fs_read_inode(fs, from_ino, &inode))
return;
inode.i_links_count = 1;
inode.i_mode = LINUX_S_IFREG | 0600;
inode.i_flags = EXT2_IMMUTABLE_FL;
if (fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_EXTENTS)
inode.i_flags |= EXT4_EXTENTS_FL;
ext2fs_write_new_inode(fs, to_ino, &inode);
/* unlink the old inode */
quota_get_qf_name(qtype, QFMT_VFS_V1, qf_name);
ext2fs_unlink(fs, EXT2_ROOT_INO, qf_name, from_ino, 0);
ext2fs_inode_alloc_stats(fs, from_ino, -1);
/* Clear out the original inode in the inode-table block. */
memset(&inode, 0, sizeof(struct ext2_inode));
ext2fs_write_inode(fs, from_ino, &inode);
}
static errcode_t mk_hugefile(ext2_filsys fs, blk64_t num,
ext2_ino_t dir, unsigned long idx, ext2_ino_t *ino)
{
errcode_t retval;
struct ext2_inode inode;
retval = ext2fs_new_inode(fs, 0, LINUX_S_IFREG, NULL, ino);
if (retval)
return retval;
memset(&inode, 0, sizeof(struct ext2_inode));
inode.i_mode = LINUX_S_IFREG | (0666 & ~fs->umask);
inode.i_links_count = 1;
inode.i_uid = uid & 0xFFFF;
ext2fs_set_i_uid_high(inode, (uid >> 16) & 0xffff);
inode.i_gid = gid & 0xFFFF;
ext2fs_set_i_gid_high(inode, (gid >> 16) & 0xffff);
retval = ext2fs_write_new_inode(fs, *ino, &inode);
if (retval)
return retval;
ext2fs_inode_alloc_stats2(fs, *ino, +1, 0);
if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT3_FEATURE_INCOMPAT_EXTENTS))
inode.i_flags |= EXT4_EXTENTS_FL;
retval = ext2fs_fallocate(fs,
EXT2_FALLOCATE_FORCE_INIT |
EXT2_FALLOCATE_ZERO_BLOCKS,
*ino, &inode, goal, 0, num);
if (retval)
return retval;
retval = ext2fs_inode_size_set(fs, &inode, num * fs->blocksize);
if (retval)
return retval;
retval = ext2fs_write_inode(fs, *ino, &inode);
if (retval)
goto errout;
if (idx_digits)
sprintf(fn_numbuf, "%0*lu", idx_digits, idx);
else if (num_files > 1)
sprintf(fn_numbuf, "%lu", idx);
retry:
retval = ext2fs_link(fs, dir, fn_buf, *ino, EXT2_FT_REG_FILE);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, dir);
if (retval)
goto errout;
goto retry;
}
errout:
return retval;
}
int debugfs_write_new_inode(ext2_ino_t ino, struct ext2_inode * inode,
const char *cmd)
{
int retval;
retval = ext2fs_write_new_inode(current_fs, ino, inode);
if (retval) {
com_err(cmd, retval, "while creating inode %u", ino);
return 1;
}
return 0;
}
static ext2_ino_t ext2CreateFile(ext2_vd *vd, ext2_inode_t * parent, int type, const char * name)
{
errcode_t retval = -1;
ext2_ino_t newfile = 0;
ext2_ino_t existing;
if(ext2fs_namei_follow(vd->fs, vd->root, parent->ino, name, &existing) == 0) {
errno = EEXIST;
return 0;
}
retval = ext2fs_new_inode(vd->fs, parent->ino, type, 0, &newfile);
if (retval) {
errno = EFAULT;
return 0;
}
while((retval = ext2fs_link(vd->fs, parent->ino, name, newfile, EXT2_FT_REG_FILE)) == EXT2_ET_DIR_NO_SPACE)
{
if (ext2fs_expand_dir(vd->fs, parent->ino) != EXT2_ET_OK) {
errno = EMLINK;
return 0;
}
}
if (retval != EXT2_ET_OK) {
errno = EMLINK;
return 0;
}
ext2fs_inode_alloc_stats2(vd->fs, newfile, +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(0);
inode.i_links_count = 1;
inode.i_size = 0;
inode.i_uid = parent->ni.i_uid;
inode.i_gid = parent->ni.i_gid;
if (ext2fs_write_new_inode(vd->fs, newfile, &inode) != 0)
return 0;
return newfile;
}
static ext2_ino_t ext2CreateMkDir(ext2_vd *vd, ext2_inode_t * parent, int type, const char * name)
{
ext2_ino_t newentry = 0;
ext2_ino_t existing;
if(ext2fs_namei_follow(vd->fs, vd->root, parent->ino, name, &existing) == 0){
errno = EEXIST;
return 0;
}
errcode_t err = ext2fs_new_inode(vd->fs, parent->ino, type, 0, &newentry);
if(err != EXT2_ET_OK) {
errno = EFAULT;
return 0;
}
while((err = ext2fs_mkdir(vd->fs, parent->ino, newentry, name)) == EXT2_ET_DIR_NO_SPACE)
{
if(ext2fs_expand_dir(vd->fs, parent->ino) != EXT2_ET_OK) {
errno = EMLINK;
return 0;
}
}
if(err != EXT2_ET_OK) {
errno = EMLINK;
return 0;
}
struct ext2_inode inode;
if(ext2fs_read_inode(vd->fs, newentry, &inode) == EXT2_ET_OK)
{
inode.i_mode = type;
inode.i_uid = parent->ni.i_uid;
inode.i_gid = parent->ni.i_gid;
ext2fs_write_new_inode(vd->fs, newentry, &inode);
}
return newentry;
}
static void move_quota_inode(ext2_filsys fs, ext2_ino_t from_ino,
ext2_ino_t to_ino, enum quota_type qtype)
{
struct ext2_inode inode;
errcode_t retval;
char qf_name[QUOTA_NAME_LEN];
/* We need the inode bitmap to be loaded */
if (ext2fs_read_bitmaps(fs))
return;
retval = ext2fs_read_inode(fs, from_ino, &inode);
if (retval) {
com_err("ext2fs_read_inode", retval, "%s",
_("in move_quota_inode"));
return;
}
inode.i_links_count = 1;
inode.i_mode = LINUX_S_IFREG | 0600;
inode.i_flags = EXT2_IMMUTABLE_FL;
if (ext2fs_has_feature_extents(fs->super))
inode.i_flags |= EXT4_EXTENTS_FL;
retval = ext2fs_write_new_inode(fs, to_ino, &inode);
if (retval) {
com_err("ext2fs_write_new_inode", retval, "%s",
_("in move_quota_inode"));
return;
}
/* unlink the old inode */
quota_get_qf_name(qtype, QFMT_VFS_V1, qf_name);
ext2fs_unlink(fs, EXT2_ROOT_INO, qf_name, from_ino, 0);
ext2fs_inode_alloc_stats(fs, from_ino, -1);
/* Clear out the original inode in the inode-table block. */
memset(&inode, 0, sizeof(struct ext2_inode));
ext2fs_write_inode(fs, from_ino, &inode);
}
/*
* 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;
blk64_t blk;
struct ext2_inode inode;
char * block;
struct problem_context pctx;
clear_problem_context(&pctx);
if (ext2fs_test_inode_bitmap2(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_bitmap2(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_block2(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_bitmap2(ctx->block_found_map, blk);
ext2fs_mark_block_bitmap2(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_block4(fs, blk, block, 0,
EXT2_ROOT_INO);
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_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO);
ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, EXT2_ROOT_INO);
ext2fs_mark_inode_bitmap2(fs->inode_map, EXT2_ROOT_INO);
ext2fs_mark_ib_dirty(fs);
}
/*
* 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;
blk64_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_check_directory(fs, ino) == 0) {
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_block2(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_bitmap2(ctx->block_found_map, blk);
ext2fs_block_alloc_stats2(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_bitmap2(ctx->inode_used_map, ino);
ext2fs_mark_inode_bitmap2(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_block4(fs, blk, block, 0, ino);
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;
quota_data_add(ctx->qctx, &inode, ino, fs->blocksize);
quota_data_inodes(ctx->qctx, &inode, ino, +1);
#if 0
printf("/lost+found created; inode #%lu\n", ino);
#endif
return ino;
}
errcode_t ext2fs_symlink(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t ino,
const char *name, char *target)
{
ext2_extent_handle_t handle;
errcode_t retval;
struct ext2_inode inode;
ext2_ino_t scratch_ino;
blk64_t blk;
int fastlink;
unsigned int target_len;
char *block_buf = 0;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
/* The Linux kernel doesn't allow for links longer than a block */
target_len = strlen(target);
if (target_len > fs->blocksize) {
retval = EXT2_ET_INVALID_ARGUMENT;
goto cleanup;
}
/*
* Allocate a data block for slow links
*/
fastlink = (target_len < sizeof(inode.i_block));
if (!fastlink) {
retval = ext2fs_new_block2(fs, 0, 0, &blk);
if (retval)
goto cleanup;
retval = ext2fs_get_mem(fs->blocksize, &block_buf);
if (retval)
goto cleanup;
}
/*
* Allocate an inode, if necessary
*/
if (!ino) {
retval = ext2fs_new_inode(fs, parent, LINUX_S_IFLNK | 0755,
0, &ino);
if (retval)
goto cleanup;
}
/*
* Create the inode structure....
*/
memset(&inode, 0, sizeof(struct ext2_inode));
inode.i_mode = LINUX_S_IFLNK | 0777;
inode.i_uid = inode.i_gid = 0;
ext2fs_iblk_set(fs, &inode, fastlink ? 0 : 1);
inode.i_links_count = 1;
inode.i_size = target_len;
/* The time fields are set by ext2fs_write_new_inode() */
if (fastlink) {
/* Fast symlinks, target stored in inode */
strcpy((char *)&inode.i_block, target);
} else {
/* Slow symlinks, target stored in the first block */
memset(block_buf, 0, fs->blocksize);
strcpy(block_buf, target);
if (fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_EXTENTS) {
/*
* The extent bmap is setup after the inode and block
* have been written out below.
*/
inode.i_flags |= EXT4_EXTENTS_FL;
}
}
/*
* Write out the inode and inode data block. The inode generation
* number is assigned by write_new_inode, which means that the
* operations using ino must come after it.
*/
retval = ext2fs_write_new_inode(fs, ino, &inode);
if (retval)
goto cleanup;
if (!fastlink) {
retval = ext2fs_bmap2(fs, ino, &inode, NULL, BMAP_SET, 0, NULL,
&blk);
if (retval)
goto cleanup;
retval = io_channel_write_blk64(fs->io, blk, 1, block_buf);
if (retval)
goto cleanup;
}
/*
* Link the symlink into the filesystem hierarchy
*/
if (name) {
retval = ext2fs_lookup(fs, parent, name, strlen(name), 0,
&scratch_ino);
if (!retval) {
retval = EXT2_ET_FILE_EXISTS;
goto cleanup;
}
if (retval != EXT2_ET_FILE_NOT_FOUND)
goto cleanup;
retval = ext2fs_link(fs, parent, name, ino, EXT2_FT_SYMLINK);
if (retval)
goto cleanup;
}
/*
* Update accounting....
*/
if (!fastlink)
ext2fs_block_alloc_stats2(fs, blk, +1);
ext2fs_inode_alloc_stats2(fs, ino, +1, 0);
cleanup:
if (block_buf)
ext2fs_free_mem(&block_buf);
return retval;
}
/*
* This function creates a journal using direct I/O routines.
*/
static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino,
blk_t num_blocks, blk64_t goal, int flags)
{
char *buf;
errcode_t retval;
struct ext2_inode inode;
unsigned long long inode_size;
struct mkjournal_struct es;
if ((retval = ext2fs_create_journal_superblock(fs, num_blocks, flags,
&buf)))
return retval;
if ((retval = ext2fs_read_bitmaps(fs)))
goto out2;
if ((retval = ext2fs_read_inode(fs, journal_ino, &inode)))
goto out2;
if (inode.i_blocks > 0) {
retval = EEXIST;
goto out2;
}
es.num_blocks = num_blocks;
es.newblocks = 0;
es.buf = buf;
es.err = 0;
es.flags = flags;
es.zero_count = 0;
es.goal = (goal != ~0ULL) ? goal : get_midpoint_journal_block(fs);
if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) {
inode.i_flags |= EXT4_EXTENTS_FL;
if ((retval = ext2fs_write_inode(fs, journal_ino, &inode)))
goto out2;
}
retval = ext2fs_block_iterate3(fs, journal_ino, BLOCK_FLAG_APPEND,
0, mkjournal_proc, &es);
if (retval)
goto out2;
if (es.err) {
retval = es.err;
goto out2;
}
if (es.zero_count) {
retval = ext2fs_zero_blocks2(fs, es.blk_to_zero,
es.zero_count, 0, 0);
if (retval)
goto out2;
}
if ((retval = ext2fs_read_inode(fs, journal_ino, &inode)))
goto out2;
inode_size = (unsigned long long)fs->blocksize * num_blocks;
ext2fs_iblk_add_blocks(fs, &inode, es.newblocks);
inode.i_mtime = inode.i_ctime = fs->now ? fs->now : time(0);
inode.i_links_count = 1;
inode.i_mode = LINUX_S_IFREG | 0600;
retval = ext2fs_inode_size_set(fs, &inode, inode_size);
if (retval)
goto out2;
if ((retval = ext2fs_write_new_inode(fs, journal_ino, &inode)))
goto out2;
retval = 0;
memcpy(fs->super->s_jnl_blocks, inode.i_block, EXT2_N_BLOCKS*4);
fs->super->s_jnl_blocks[15] = inode.i_size_high;
fs->super->s_jnl_blocks[16] = inode.i_size;
fs->super->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS;
ext2fs_mark_super_dirty(fs);
out2:
ext2fs_free_mem(&buf);
return retval;
}
/* Make a special files (block and character devices), fifo's, and sockets */
errcode_t do_mknod_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
struct stat *st)
{
ext2_ino_t ino;
errcode_t retval;
struct ext2_inode inode;
unsigned long devmajor, devminor, mode;
int filetype;
switch(st->st_mode & S_IFMT) {
case S_IFCHR:
mode = LINUX_S_IFCHR;
filetype = EXT2_FT_CHRDEV;
break;
case S_IFBLK:
mode = LINUX_S_IFBLK;
filetype = EXT2_FT_BLKDEV;
break;
case S_IFIFO:
mode = LINUX_S_IFIFO;
filetype = EXT2_FT_FIFO;
break;
case S_IFSOCK:
mode = LINUX_S_IFSOCK;
filetype = EXT2_FT_SOCK;
break;
default:
return EXT2_ET_INVALID_ARGUMENT;
}
if (!(fs->flags & EXT2_FLAG_RW)) {
com_err(__func__, 0, "Filesystem opened read/only");
return EROFS;
}
retval = ext2fs_new_inode(fs, cwd, 010755, 0, &ino);
if (retval) {
com_err(__func__, retval, 0);
return retval;
}
#ifdef DEBUGFS
printf("Allocated inode: %u\n", ino);
#endif
retval = ext2fs_link(fs, cwd, name, ino, filetype);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, cwd);
if (retval) {
com_err(__func__, retval, "while expanding directory");
return retval;
}
retval = ext2fs_link(fs, cwd, name, ino, filetype);
}
if (retval) {
com_err(name, retval, 0);
return retval;
}
if (ext2fs_test_inode_bitmap2(fs->inode_map, ino))
com_err(__func__, 0, "Warning: inode already set");
ext2fs_inode_alloc_stats2(fs, ino, +1, 0);
memset(&inode, 0, sizeof(inode));
inode.i_mode = mode;
inode.i_atime = inode.i_ctime = inode.i_mtime =
fs->now ? fs->now : time(0);
if (filetype != S_IFIFO) {
devmajor = major(st->st_rdev);
devminor = minor(st->st_rdev);
if ((devmajor < 256) && (devminor < 256)) {
inode.i_block[0] = devmajor * 256 + devminor;
inode.i_block[1] = 0;
} else {
inode.i_block[0] = 0;
inode.i_block[1] = (devminor & 0xff) | (devmajor << 8) |
((devminor & ~0xff) << 12);
}
}
inode.i_links_count = 1;
retval = ext2fs_write_new_inode(fs, ino, &inode);
if (retval)
com_err(__func__, retval, "while creating inode %u", ino);
return retval;
}
/* Copy the native file to the fs */
errcode_t do_write_internal(ext2_filsys fs, ext2_ino_t cwd, const char *src,
const char *dest, ext2_ino_t root)
{
int fd;
struct stat statbuf;
ext2_ino_t newfile;
errcode_t retval;
struct ext2_inode inode;
int bufsize = IO_BUFSIZE;
int make_holes = 0;
fd = ext2fs_open_file(src, O_RDONLY, 0);
if (fd < 0) {
com_err(src, errno, 0);
return errno;
}
if (fstat(fd, &statbuf) < 0) {
com_err(src, errno, 0);
close(fd);
return errno;
}
retval = ext2fs_namei(fs, root, cwd, dest, &newfile);
if (retval == 0) {
close(fd);
return EXT2_ET_FILE_EXISTS;
}
retval = ext2fs_new_inode(fs, cwd, 010755, 0, &newfile);
if (retval) {
com_err(__func__, retval, 0);
close(fd);
return retval;
}
#ifdef DEBUGFS
printf("Allocated inode: %u\n", newfile);
#endif
retval = ext2fs_link(fs, cwd, dest, newfile,
EXT2_FT_REG_FILE);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, cwd);
if (retval) {
com_err(__func__, retval, "while expanding directory");
close(fd);
return retval;
}
retval = ext2fs_link(fs, cwd, dest, newfile,
EXT2_FT_REG_FILE);
}
if (retval) {
com_err(dest, retval, 0);
close(fd);
return errno;
}
if (ext2fs_test_inode_bitmap2(fs->inode_map, newfile))
com_err(__func__, 0, "Warning: inode already set");
ext2fs_inode_alloc_stats2(fs, newfile, +1, 0);
memset(&inode, 0, sizeof(inode));
inode.i_mode = (statbuf.st_mode & ~LINUX_S_IFMT) | LINUX_S_IFREG;
inode.i_atime = inode.i_ctime = inode.i_mtime =
fs->now ? fs->now : time(0);
inode.i_links_count = 1;
retval = ext2fs_inode_size_set(fs, &inode, statbuf.st_size);
if (retval) {
com_err(dest, retval, 0);
close(fd);
return retval;
}
if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT4_FEATURE_INCOMPAT_INLINE_DATA)) {
inode.i_flags |= EXT4_INLINE_DATA_FL;
} else if (fs->super->s_feature_incompat &
EXT3_FEATURE_INCOMPAT_EXTENTS) {
int i;
struct ext3_extent_header *eh;
eh = (struct ext3_extent_header *) &inode.i_block[0];
eh->eh_depth = 0;
eh->eh_entries = 0;
eh->eh_magic = ext2fs_cpu_to_le16(EXT3_EXT_MAGIC);
i = (sizeof(inode.i_block) - sizeof(*eh)) /
sizeof(struct ext3_extent);
eh->eh_max = ext2fs_cpu_to_le16(i);
inode.i_flags |= EXT4_EXTENTS_FL;
}
retval = ext2fs_write_new_inode(fs, newfile, &inode);
if (retval) {
com_err(__func__, retval, "while creating inode %u", newfile);
close(fd);
return retval;
}
if (inode.i_flags & EXT4_INLINE_DATA_FL) {
retval = ext2fs_inline_data_init(fs, newfile);
if (retval) {
com_err("copy_file", retval, 0);
close(fd);
return retval;
}
}
if (LINUX_S_ISREG(inode.i_mode)) {
if (statbuf.st_blocks < statbuf.st_size / S_BLKSIZE) {
make_holes = 1;
/*
* Use I/O blocksize as buffer size when
* copying sparse files.
*/
bufsize = statbuf.st_blksize;
}
retval = copy_file(fs, fd, newfile, bufsize, make_holes);
if (retval)
com_err("copy_file", retval, 0);
}
close(fd);
return retval;
}
errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
const char *name)
{
ext2_extent_handle_t handle;
errcode_t retval;
struct ext2_inode parent_inode, inode;
ext2_ino_t ino = inum;
ext2_ino_t scratch_ino;
blk64_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_block2(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;
ext2fs_iblk_set(fs, &inode, 1);
if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS)
inode.i_flags |= EXT4_EXTENTS_FL;
else
inode.i_block[0] = blk;
inode.i_links_count = 2;
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;
if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) {
retval = ext2fs_extent_open2(fs, ino, &inode, &handle);
if (retval)
goto cleanup;
retval = ext2fs_extent_set_bmap(handle, 0, blk, 0);
ext2fs_extent_free(handle);
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_stats2(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;
}
static errcode_t file_test(ext2_filsys fs)
{
struct ext2_inode inode;
ext2_ino_t newfile;
errcode_t retval;
size_t size;
char *buf = 0, *cmpbuf = 0;
int i;
/* create a new file */
retval = ext2fs_new_inode(fs, 2, 010755, 0, &newfile);
if (retval) {
com_err("file_test", retval, "while allocaing a new inode");
return 1;
}
memset(&inode, 0, sizeof(inode));
inode.i_flags |= EXT4_INLINE_DATA_FL;
inode.i_size = EXT4_MIN_INLINE_DATA_SIZE;
inode.i_mode = LINUX_S_IFREG;
retval = ext2fs_write_new_inode(fs, newfile, &inode);
if (retval) {
com_err("file_test", retval, "while writting a new inode");
return 1;
}
retval = ext2fs_inline_data_init(fs, newfile);
if (retval) {
com_err("file_test", retval, "while init 'system.data'");
return 1;
}
retval = ext2fs_inline_data_size(fs, newfile, &size);
if (retval) {
com_err("file_test", retval, "while getting size");
return 1;
}
if (size != EXT4_MIN_INLINE_DATA_SIZE) {
fprintf(stderr,
"tst_inline_data: size of inline data is wrong\n");
return 1;
}
ext2fs_get_mem(BUFF_SIZE, &buf);
memset(buf, 'a', BUFF_SIZE);
retval = ext2fs_inline_data_set(fs, newfile, 0, buf, BUFF_SIZE);
if (retval) {
com_err("file_test", retval,
"while setting inline data %s", buf);
goto err;
}
ext2fs_get_mem(BUFF_SIZE, &cmpbuf);
retval = ext2fs_inline_data_get(fs, newfile, 0, cmpbuf, &size);
if (retval) {
com_err("file_test", retval, "while getting inline data");
goto err;
}
if (size != BUFF_SIZE) {
fprintf(stderr,
"tst_inline_data: size %lu != buflen %u\n",
size, BUFF_SIZE);
retval = 1;
goto err;
}
if (memcmp(buf, cmpbuf, BUFF_SIZE)) {
fprintf(stderr, "tst_inline_data: buf != cmpbuf\n");
retval = 1;
goto err;
}
retval = ext2fs_punch(fs, newfile, 0, 0, 0, ~0ULL);
if (retval) {
com_err("file_test", retval, "while truncating inode");
goto err;
}
/* reload inode and check isize */
ext2fs_read_inode(fs, newfile, &inode);
if (inode.i_size != 0) {
fprintf(stderr, "tst_inline_data: i_size should be 0\n");
retval = 1;
}
err:
if (cmpbuf)
ext2fs_free_mem(&cmpbuf);
if (buf)
ext2fs_free_mem(&buf);
return retval;
}
/*
* This function creates a journal using direct I/O routines.
*/
static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino,
blk_t num_blocks, blk64_t goal, int flags)
{
char *buf;
errcode_t retval;
struct ext2_inode inode;
unsigned long long inode_size;
int falloc_flags = EXT2_FALLOCATE_FORCE_INIT;
blk64_t zblk;
if ((retval = ext2fs_create_journal_superblock(fs, num_blocks, flags,
&buf)))
return retval;
if ((retval = ext2fs_read_bitmaps(fs)))
goto out2;
if ((retval = ext2fs_read_inode(fs, journal_ino, &inode)))
goto out2;
if (inode.i_blocks > 0) {
retval = EEXIST;
goto out2;
}
if (goal == ~0ULL)
goal = get_midpoint_journal_block(fs);
if (ext2fs_has_feature_extents(fs->super))
inode.i_flags |= EXT4_EXTENTS_FL;
if (!(flags & EXT2_MKJOURNAL_LAZYINIT))
falloc_flags |= EXT2_FALLOCATE_ZERO_BLOCKS;
inode_size = (unsigned long long)fs->blocksize * num_blocks;
inode.i_mtime = inode.i_ctime = fs->now ? fs->now : time(0);
inode.i_links_count = 1;
inode.i_mode = LINUX_S_IFREG | 0600;
retval = ext2fs_inode_size_set(fs, &inode, inode_size);
if (retval)
goto out2;
retval = ext2fs_fallocate(fs, falloc_flags, journal_ino,
&inode, goal, 0, num_blocks);
if (retval)
goto out2;
if ((retval = ext2fs_write_new_inode(fs, journal_ino, &inode)))
goto out2;
retval = ext2fs_bmap2(fs, journal_ino, &inode, NULL, 0, 0, NULL, &zblk);
if (retval)
goto out2;
retval = io_channel_write_blk64(fs->io, zblk, 1, buf);
if (retval)
goto out2;
memcpy(fs->super->s_jnl_blocks, inode.i_block, EXT2_N_BLOCKS*4);
fs->super->s_jnl_blocks[15] = inode.i_size_high;
fs->super->s_jnl_blocks[16] = inode.i_size;
fs->super->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS;
ext2fs_mark_super_dirty(fs);
out2:
ext2fs_free_mem(&buf);
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;
}
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;
}
int do_create (ext2_filsys e2fs, const char *path, mode_t mode, dev_t dev, const char *fastsymlink)
{
int rt;
time_t tm;
errcode_t rc;
char *p_path;
char *r_path;
ext2_ino_t ino;
struct ext2_inode inode;
ext2_ino_t n_ino;
struct fuse_context *ctx;
debugf("enter");
debugf("path = %s, mode: 0%o", path, mode);
rt=do_check_split(path, &p_path, &r_path);
debugf("parent: %s, child: %s", p_path, r_path);
rt = do_readinode(e2fs, p_path, &ino, &inode);
if (rt) {
debugf("do_readinode(%s, &ino, &inode); failed", p_path);
free_split(p_path, r_path);
return rt;
}
rc = ext2fs_new_inode(e2fs, ino, mode, 0, &n_ino);
if (rc) {
debugf("ext2fs_new_inode(ep.fs, ino, mode, 0, &n_ino); failed");
return -ENOMEM;
}
do {
debugf("calling ext2fs_link(e2fs, %d, %s, %d, %d);", ino, r_path, n_ino, do_modetoext2lag(mode));
rc = ext2fs_link(e2fs, ino, r_path, n_ino, do_modetoext2lag(mode));
if (rc == EXT2_ET_DIR_NO_SPACE) {
debugf("calling ext2fs_expand_dir(e2fs, &d)", ino);
if (ext2fs_expand_dir(e2fs, ino)) {
debugf("error while expanding directory %s (%d)", p_path, ino);
free_split(p_path, r_path);
return -ENOSPC;
}
}
} while (rc == EXT2_ET_DIR_NO_SPACE);
if (rc) {
debugf("ext2fs_link(e2fs, %d, %s, %d, %d); failed", ino, r_path, n_ino, do_modetoext2lag(mode));
free_split(p_path, r_path);
return -EIO;
}
if (ext2fs_test_inode_bitmap(e2fs->inode_map, n_ino)) {
debugf("inode already set");
}
ext2fs_inode_alloc_stats2(e2fs, n_ino, +1, 0);
memset(&inode, 0, sizeof(inode));
tm = e2fs->now ? e2fs->now : time(NULL);
inode.i_mode = mode;
inode.i_atime = inode.i_ctime = inode.i_mtime = tm;
inode.i_links_count = 1;
inode.i_size = 0;
ctx = fuse_get_context();
if (ctx) {
inode.i_uid = ctx->uid;
inode.i_gid = ctx->gid;
}
if (S_ISCHR(mode) || S_ISBLK(mode)) {
if (old_valid_dev(dev))
inode.i_block[0]= ext2fs_cpu_to_le32(old_encode_dev(dev));
else
inode.i_block[1]= ext2fs_cpu_to_le32(new_encode_dev(dev));
}
if (S_ISLNK(mode) && fastsymlink != NULL) {
inode.i_size = strlen(fastsymlink);
strncpy((char *)&(inode.i_block[0]),fastsymlink,
(EXT2_N_BLOCKS * sizeof(inode.i_block[0])));
}
rc = ext2fs_write_new_inode(e2fs, n_ino, &inode);
if (rc) {
debugf("ext2fs_write_new_inode(e2fs, n_ino, &inode);");
free_split(p_path, r_path);
return -EIO;
}
/* update parent dir */
rt = do_readinode(e2fs, p_path, &ino, &inode);
if (rt) {
debugf("do_readinode(%s, &ino, &inode); dailed", p_path);
free_split(p_path, r_path);
return -EIO;
}
inode.i_ctime = inode.i_mtime = tm;
rc = ext2fs_write_inode(e2fs, ino, &inode);
if (rc) {
debugf("ext2fs_write_inode(e2fs, ino, &inode); failed");
free_split(p_path, r_path);
return -EIO;
}
free_split(p_path, r_path);
debugf("leave");
return 0;
}
/*
* This function creates a journal using direct I/O routines.
*/
static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino,
blk_t num_blocks, int flags)
{
char *buf;
dgrp_t group, start, end, i, log_flex;
errcode_t retval;
struct ext2_inode inode;
unsigned long long inode_size;
struct mkjournal_struct es;
if ((retval = ext2fs_create_journal_superblock(fs, num_blocks, flags,
&buf)))
return retval;
if ((retval = ext2fs_read_bitmaps(fs)))
goto out2;
if ((retval = ext2fs_read_inode(fs, journal_ino, &inode)))
goto out2;
if (inode.i_blocks > 0) {
retval = EEXIST;
goto out2;
}
es.num_blocks = num_blocks;
es.newblocks = 0;
es.buf = buf;
es.err = 0;
es.flags = flags;
es.zero_count = 0;
if (fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS) {
inode.i_flags |= EXT4_EXTENTS_FL;
if ((retval = ext2fs_write_inode(fs, journal_ino, &inode)))
goto out2;
}
/*
* Set the initial goal block to be roughly at the middle of
* the filesystem. Pick a group that has the largest number
* of free blocks.
*/
group = ext2fs_group_of_blk2(fs, (ext2fs_blocks_count(fs->super) -
fs->super->s_first_data_block) / 2);
log_flex = 1 << fs->super->s_log_groups_per_flex;
if (fs->super->s_log_groups_per_flex && (group > log_flex)) {
group = group & ~(log_flex - 1);
while ((group < fs->group_desc_count) &&
ext2fs_bg_free_blocks_count(fs, group) == 0)
group++;
if (group == fs->group_desc_count)
group = 0;
start = group;
} else
start = (group > 0) ? group-1 : group;
end = ((group+1) < fs->group_desc_count) ? group+1 : group;
group = start;
for (i=start+1; i <= end; i++)
if (ext2fs_bg_free_blocks_count(fs, i) >
ext2fs_bg_free_blocks_count(fs, group))
group = i;
es.goal = ext2fs_group_first_block2(fs, group);
retval = ext2fs_block_iterate3(fs, journal_ino, BLOCK_FLAG_APPEND,
0, mkjournal_proc, &es);
if (es.err) {
retval = es.err;
goto errout;
}
if (es.zero_count) {
retval = ext2fs_zero_blocks2(fs, es.blk_to_zero,
es.zero_count, 0, 0);
if (retval)
goto errout;
}
if ((retval = ext2fs_read_inode(fs, journal_ino, &inode)))
goto errout;
inode_size = (unsigned long long)fs->blocksize * num_blocks;
inode.i_size = inode_size & 0xFFFFFFFF;
inode.i_size_high = (inode_size >> 32) & 0xFFFFFFFF;
if (ext2fs_needs_large_file_feature(inode_size))
fs->super->s_feature_ro_compat |=
EXT2_FEATURE_RO_COMPAT_LARGE_FILE;
ext2fs_iblk_add_blocks(fs, &inode, es.newblocks);
inode.i_mtime = inode.i_ctime = fs->now ? fs->now : time(0);
inode.i_links_count = 1;
inode.i_mode = LINUX_S_IFREG | 0600;
if ((retval = ext2fs_write_new_inode(fs, journal_ino, &inode)))
goto errout;
retval = 0;
memcpy(fs->super->s_jnl_blocks, inode.i_block, EXT2_N_BLOCKS*4);
fs->super->s_jnl_blocks[15] = inode.i_size_high;
fs->super->s_jnl_blocks[16] = inode.i_size;
fs->super->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS;
ext2fs_mark_super_dirty(fs);
errout:
ext2fs_zero_blocks2(0, 0, 0, 0, 0);
out2:
ext2fs_free_mem(&buf);
return retval;
}
static errcode_t mk_hugefile(ext2_filsys fs, blk64_t num,
ext2_ino_t dir, unsigned long idx, ext2_ino_t *ino)
{
errcode_t retval;
blk64_t lblk, bend = 0;
__u64 size;
blk64_t left;
blk64_t count = 0;
struct ext2_inode inode;
ext2_extent_handle_t handle;
retval = ext2fs_new_inode(fs, 0, LINUX_S_IFREG, NULL, ino);
if (retval)
return retval;
memset(&inode, 0, sizeof(struct ext2_inode));
inode.i_mode = LINUX_S_IFREG | (0666 & ~fs->umask);
inode.i_links_count = 1;
inode.i_uid = uid & 0xFFFF;
ext2fs_set_i_uid_high(inode, (uid >> 16) & 0xffff);
inode.i_gid = gid & 0xFFFF;
ext2fs_set_i_gid_high(inode, (gid >> 16) & 0xffff);
retval = ext2fs_write_new_inode(fs, *ino, &inode);
if (retval)
return retval;
ext2fs_inode_alloc_stats2(fs, *ino, +1, 0);
retval = ext2fs_extent_open2(fs, *ino, &inode, &handle);
if (retval)
return retval;
/*
* We don't use ext2fs_fallocate() here because hugefiles are
* designed to be physically contiguous (if the block group
* descriptors are configured to be in a single block at the
* beginning of the file system, by using the
* packed_meta_blocks layout), with the extent tree blocks
* allocated near the beginning of the file system.
*/
lblk = 0;
left = num ? num : 1;
while (left) {
blk64_t pblk, end;
blk64_t n = left;
retval = ext2fs_find_first_zero_block_bitmap2(fs->block_map,
goal, ext2fs_blocks_count(fs->super) - 1, &end);
if (retval)
goto errout;
goal = end;
retval = ext2fs_find_first_set_block_bitmap2(fs->block_map, goal,
ext2fs_blocks_count(fs->super) - 1, &bend);
if (retval == ENOENT) {
bend = ext2fs_blocks_count(fs->super);
if (num == 0)
left = 0;
}
if (!num || bend - goal < left)
n = bend - goal;
pblk = goal;
if (num)
left -= n;
goal += n;
count += n;
ext2fs_block_alloc_stats_range(fs, pblk, n, +1);
if (zero_hugefile) {
blk64_t ret_blk;
retval = ext2fs_zero_blocks2(fs, pblk, n,
&ret_blk, NULL);
if (retval)
com_err(program_name, retval,
_("while zeroing block %llu "
"for hugefile"), ret_blk);
}
while (n) {
blk64_t l = n;
struct ext2fs_extent newextent;
if (l > EXT_INIT_MAX_LEN)
l = EXT_INIT_MAX_LEN;
newextent.e_len = l;
newextent.e_pblk = pblk;
newextent.e_lblk = lblk;
newextent.e_flags = 0;
retval = ext2fs_extent_insert(handle,
EXT2_EXTENT_INSERT_AFTER, &newextent);
if (retval)
return retval;
pblk += l;
lblk += l;
n -= l;
}
}
retval = ext2fs_read_inode(fs, *ino, &inode);
if (retval)
goto errout;
retval = ext2fs_iblk_add_blocks(fs, &inode,
count / EXT2FS_CLUSTER_RATIO(fs));
if (retval)
goto errout;
size = (__u64) count * fs->blocksize;
retval = ext2fs_inode_size_set(fs, &inode, size);
if (retval)
goto errout;
retval = ext2fs_write_new_inode(fs, *ino, &inode);
if (retval)
goto errout;
if (idx_digits)
sprintf(fn_numbuf, "%0*lu", idx_digits, idx);
else if (num_files > 1)
sprintf(fn_numbuf, "%lu", idx);
retry:
retval = ext2fs_link(fs, dir, fn_buf, *ino, EXT2_FT_REG_FILE);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, dir);
if (retval)
goto errout;
goto retry;
}
if (retval)
goto errout;
errout:
if (handle)
ext2fs_extent_free(handle);
return retval;
}
/*
* This code assumes that the reserved blocks have already been marked in-use
* during ext2fs_initialize(), so that they are not allocated for other
* uses before we can add them to the resize inode (which has to come
* after the creation of the inode table).
*/
errcode_t ext2fs_create_resize_inode(ext2_filsys fs)
{
errcode_t retval, retval2;
struct ext2_super_block *sb;
struct ext2_inode inode;
__u32 *dindir_buf, *gdt_buf;
unsigned long long apb, inode_size;
/* FIXME-64 - can't deal with extents */
blk_t dindir_blk, rsv_off, gdt_off, gdt_blk;
int dindir_dirty = 0, inode_dirty = 0, sb_blk = 0;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
sb = fs->super;
retval = ext2fs_get_array(2, fs->blocksize, &dindir_buf);
if (retval)
return retval;
gdt_buf = (__u32 *)((char *)dindir_buf + fs->blocksize);
retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode);
if (retval)
goto out_free;
/*
* File systems with a blocksize of 1024 and bigalloc have
* sb->s_first_data_block of 0; yet the superblock is still at
* block #1. We compensate for it here.
*/
sb_blk = sb->s_first_data_block;
if (fs->blocksize == 1024 && sb_blk == 0)
sb_blk = 1;
/* Maximum possible file size (we donly use the dindirect blocks) */
apb = EXT2_ADDR_PER_BLOCK(sb);
if ((dindir_blk = inode.i_block[EXT2_DIND_BLOCK])) {
#ifdef RES_GDT_DEBUG
printf("reading GDT dindir %u\n", dindir_blk);
#endif
retval = ext2fs_read_ind_block(fs, dindir_blk, dindir_buf);
if (retval)
goto out_inode;
} else {
blk_t goal = sb_blk + fs->desc_blocks +
sb->s_reserved_gdt_blocks + 2 +
fs->inode_blocks_per_group;
retval = ext2fs_alloc_block(fs, goal, 0, &dindir_blk);
if (retval)
goto out_free;
inode.i_mode = LINUX_S_IFREG | 0600;
inode.i_links_count = 1;
inode.i_block[EXT2_DIND_BLOCK] = dindir_blk;
ext2fs_iblk_set(fs, &inode, 1);
memset(dindir_buf, 0, fs->blocksize);
#ifdef RES_GDT_DEBUG
printf("allocated GDT dindir %u\n", dindir_blk);
#endif
dindir_dirty = inode_dirty = 1;
inode_size = apb*apb + apb + EXT2_NDIR_BLOCKS;
inode_size *= fs->blocksize;
inode.i_size = inode_size & 0xFFFFFFFF;
inode.i_size_high = (inode_size >> 32) & 0xFFFFFFFF;
if(inode.i_size_high) {
sb->s_feature_ro_compat |=
EXT2_FEATURE_RO_COMPAT_LARGE_FILE;
}
inode.i_ctime = fs->now ? fs->now : time(0);
}
for (rsv_off = 0, gdt_off = fs->desc_blocks,
gdt_blk = sb_blk + 1 + fs->desc_blocks;
rsv_off < sb->s_reserved_gdt_blocks;
rsv_off++, gdt_off++, gdt_blk++) {
unsigned int three = 1, five = 5, seven = 7;
unsigned int grp, last = 0;
int gdt_dirty = 0;
gdt_off %= apb;
if (!dindir_buf[gdt_off]) {
/* FIXME XXX XXX
blk_t new_blk;
retval = ext2fs_new_block(fs, gdt_blk, 0, &new_blk);
if (retval)
goto out_free;
if (new_blk != gdt_blk) {
// XXX free block
retval = -1; // XXX
}
*/
gdt_dirty = dindir_dirty = inode_dirty = 1;
memset(gdt_buf, 0, fs->blocksize);
dindir_buf[gdt_off] = gdt_blk;
ext2fs_iblk_add_blocks(fs, &inode, 1);
#ifdef RES_GDT_DEBUG
printf("added primary GDT block %u at %u[%u]\n",
gdt_blk, dindir_blk, gdt_off);
#endif
} else if (dindir_buf[gdt_off] == gdt_blk) {
#ifdef RES_GDT_DEBUG
printf("reading primary GDT block %u\n", gdt_blk);
#endif
retval = ext2fs_read_ind_block(fs, gdt_blk, gdt_buf);
if (retval)
goto out_dindir;
} else {
#ifdef RES_GDT_DEBUG
printf("bad primary GDT %u != %u at %u[%u]\n",
dindir_buf[gdt_off], gdt_blk,dindir_blk,gdt_off);
#endif
retval = EXT2_ET_RESIZE_INODE_CORRUPT;
goto out_dindir;
}
while ((grp = list_backups(fs, &three, &five, &seven)) <
fs->group_desc_count) {
blk_t expect = gdt_blk + grp * sb->s_blocks_per_group;
if (!gdt_buf[last]) {
#ifdef RES_GDT_DEBUG
printf("added backup GDT %u grp %u@%u[%u]\n",
expect, grp, gdt_blk, last);
#endif
gdt_buf[last] = expect;
ext2fs_iblk_add_blocks(fs, &inode, 1);
gdt_dirty = inode_dirty = 1;
} else if (gdt_buf[last] != expect) {
#ifdef RES_GDT_DEBUG
printf("bad backup GDT %u != %u at %u[%u]\n",
gdt_buf[last], expect, gdt_blk, last);
#endif
retval = EXT2_ET_RESIZE_INODE_CORRUPT;
goto out_dindir;
}
last++;
}
if (gdt_dirty) {
#ifdef RES_GDT_DEBUG
printf("writing primary GDT block %u\n", gdt_blk);
#endif
retval = ext2fs_write_ind_block(fs, gdt_blk, gdt_buf);
if (retval)
goto out_dindir;
}
}
out_dindir:
if (dindir_dirty) {
retval2 = ext2fs_write_ind_block(fs, dindir_blk, dindir_buf);
if (!retval)
retval = retval2;
}
out_inode:
#ifdef RES_GDT_DEBUG
printf("inode.i_blocks = %u, i_size = %u\n", inode.i_blocks,
inode.i_size);
#endif
if (inode_dirty) {
inode.i_atime = inode.i_mtime = fs->now ? fs->now : time(0);
retval2 = ext2fs_write_new_inode(fs, EXT2_RESIZE_INO, &inode);
if (!retval)
retval = retval2;
}
out_free:
ext2fs_free_mem(&dindir_buf);
return retval;
}
/*
* 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;
blk64_t blk;
errcode_t retval;
struct ext2_inode inode;
char * block;
static const char name[] = "lost+found";
struct problem_context pctx;
int will_rehash, flags;
if (ctx->lost_and_found)
return ctx->lost_and_found;
clear_problem_context(&pctx);
will_rehash = e2fsck_dir_will_be_rehashed(ctx, EXT2_ROOT_INO);
if (will_rehash) {
flags = ctx->fs->flags;
ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
}
retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name,
sizeof(name)-1, 0, &ino);
if (will_rehash)
ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) |
(ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS);
if (retval && !fix)
return 0;
if (!retval) {
/* Lost+found shouldn't have inline data */
retval = ext2fs_read_inode(fs, ino, &inode);
if (fix && retval)
return 0;
if (fix && (inode.i_flags & EXT4_INLINE_DATA_FL)) {
if (!fix_problem(ctx, PR_3_LPF_INLINE_DATA, &pctx))
return 0;
goto unlink;
}
if (fix && (inode.i_flags & EXT4_ENCRYPT_FL)) {
if (!fix_problem(ctx, PR_3_LPF_ENCRYPTED, &pctx))
return 0;
goto unlink;
}
if (ext2fs_check_directory(fs, ino) == 0) {
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;
unlink:
/* 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);
/*
* If the old lost+found was a directory, we've just
* disconnected it from the directory tree, which
* means we need to restart the directory tree scan.
* The simplest way to do this is restart the whole
* e2fsck operation.
*/
if (LINUX_S_ISDIR(inode.i_mode))
ctx->flags |= E2F_FLAG_RESTART;
} 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
*/
if (ctx->lnf_repair_block) {
blk = ctx->lnf_repair_block;
ctx->lnf_repair_block = 0;
goto skip_new_block;
}
retval = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk);
if (retval == EXT2_ET_BLOCK_ALLOC_FAIL &&
fix_problem(ctx, PR_3_LPF_NO_SPACE, &pctx)) {
fix_problem(ctx, PR_3_NO_SPACE_TO_RECOVER, &pctx);
ctx->lost_and_found = EXT2_ROOT_INO;
return 0;
}
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx);
return 0;
}
ext2fs_mark_block_bitmap2(ctx->block_found_map, blk);
skip_new_block:
ext2fs_block_alloc_stats2(fs, blk, +1);
/*
* Next find a free inode.
*/
retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700,
ctx->inode_used_map, &ino);
if (retval == EXT2_ET_INODE_ALLOC_FAIL &&
fix_problem(ctx, PR_3_LPF_NO_SPACE, &pctx)) {
fix_problem(ctx, PR_3_NO_SPACE_TO_RECOVER, &pctx);
ctx->lost_and_found = EXT2_ROOT_INO;
return 0;
}
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx);
return 0;
}
ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino);
ext2fs_inode_alloc_stats2(fs, ino, +1, 1);
/*
* 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;
}
/*
* Now let's create the actual data block for the inode.
* Due to metadata_csum, the directory block MUST be written
* after the inode is written to disk!
*/
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_block4(fs, blk, block, 0, ino);
ext2fs_free_mem(&block);
if (retval) {
pctx.errcode = retval;
fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx);
return 0;
}
/*
* Finally, create the directory link
*/
pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR);
if (pctx.errcode == EXT2_ET_DIR_NO_SPACE) {
pctx.errcode = ext2fs_expand_dir(fs, EXT2_ROOT_INO);
if (pctx.errcode)
goto link_error;
pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino,
EXT2_FT_DIR);
}
if (pctx.errcode) {
link_error:
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;
quota_data_add(ctx->qctx, &inode, ino, fs->blocksize);
quota_data_inodes(ctx->qctx, &inode, ino, +1);
#if 0
printf("/lost+found created; inode #%lu\n", ino);
#endif
return ino;
}
