/* Writes everything from NP's inode to the disk image, and returns a pointer
to it, or NULL if nothing need be done. */
static struct ext2_inode *
write_node (struct node *np)
{
error_t err;
struct stat *st = &np->dn_stat;
struct ext2_inode *di;
ext2_debug ("(%llu)", np->cache_id);
if (diskfs_node_disknode (np)->info.i_prealloc_count)
ext2_discard_prealloc (np);
if (np->dn_stat_dirty)
{
struct ext2_inode_info *info = &diskfs_node_disknode (np)->info;
assert (!diskfs_readonly);
ext2_debug ("writing inode %d to disk", np->cache_id);
err = diskfs_catch_exception ();
if (err)
return NULL;
di = dino_ref (np->cache_id);
di->i_generation = st->st_gen;
/* We happen to know that the stat mode bits are the same
as the ext2fs mode bits. */
/* XXX? */
/* Only the low 16 bits of these fields are standard across all ext2
implementations. */
di->i_mode = st->st_mode & 0xFFFF & ~S_ITRANS;
di->i_uid = st->st_uid & 0xFFFF;
di->i_gid = st->st_gid & 0xFFFF;
if (sblock->s_creator_os == EXT2_OS_HURD)
/* If this is a hurd-compatible filesystem, write the high bits too. */
{
di->i_mode_high = (st->st_mode >> 16) & 0xffff & ~S_ITRANS;
di->i_uid_high = st->st_uid >> 16;
di->i_gid_high = st->st_gid >> 16;
di->i_author = st->st_author;
}
else
/* No hurd extensions should be turned on. */
{
/*
* There are two policies for allocating an inode. If the new inode is
* a directory, then a forward search is made for a block group with both
* free space and a low directory-to-inode ratio; if that fails, then of
* the groups with above-average free space, that group with the fewest
* directories already is chosen.
*
* For other inodes, search forward from the parent directory\'s block
* group to find a free inode.
*/
ino_t
ext2_alloc_inode (ino_t dir_inum, mode_t mode)
{
char *bh = NULL;
int i, j, avefreei;
ino_t inum;
struct ext2_group_desc *gdp;
struct ext2_group_desc *tmp;
pthread_spin_lock (&global_lock);
repeat:
assert (bh == NULL);
gdp = NULL;
i = 0;
if (S_ISDIR (mode))
{
avefreei = sblock->s_free_inodes_count / groups_count;
/* I am not yet convinced that this next bit is necessary.
i = inode_group_num(dir_inum);
for (j = 0; j < groups_count; j++)
{
tmp = group_desc (i);
if ((tmp->bg_used_dirs_count << 8) < tmp->bg_free_inodes_count)
{
gdp = tmp;
break;
}
else
i = ++i % groups_count;
}
*/
if (!gdp)
{
for (j = 0; j < groups_count; j++)
{
tmp = group_desc (j);
if (tmp->bg_free_inodes_count
&& tmp->bg_free_inodes_count >= avefreei)
{
if (!gdp ||
(tmp->bg_free_blocks_count > gdp->bg_free_blocks_count))
{
i = j;
gdp = tmp;
}
}
}
}
}
else
{
/*
* Try to place the inode in its parent directory
*/
i = inode_group_num(dir_inum);
tmp = group_desc (i);
if (tmp->bg_free_inodes_count)
gdp = tmp;
else
{
/*
* Use a quadratic hash to find a group with a
* free inode
*/
for (j = 1; j < groups_count; j <<= 1)
{
i += j;
if (i >= groups_count)
i -= groups_count;
tmp = group_desc (i);
if (tmp->bg_free_inodes_count)
{
gdp = tmp;
break;
}
}
}
if (!gdp)
{
/*
* That failed: try linear search for a free inode
*/
i = inode_group_num(dir_inum) + 1;
for (j = 2; j < groups_count; j++)
{
if (++i >= groups_count)
i = 0;
tmp = group_desc (i);
if (tmp->bg_free_inodes_count)
{
gdp = tmp;
break;
}
}
}
}
if (!gdp)
{
pthread_spin_unlock (&global_lock);
return 0;
}
bh = disk_cache_block_ref (gdp->bg_inode_bitmap);
if ((inum =
find_first_zero_bit ((unsigned long *) bh, sblock->s_inodes_per_group))
< sblock->s_inodes_per_group)
{
if (set_bit (inum, bh))
{
ext2_warning ("bit already set for inode %d", inum);
disk_cache_block_deref (bh);
bh = NULL;
goto repeat;
}
record_global_poke (bh);
bh = NULL;
}
else
{
disk_cache_block_deref (bh);
bh = NULL;
if (gdp->bg_free_inodes_count != 0)
{
ext2_error ("free inodes count corrupted in group %d", i);
inum = 0;
goto sync_out;
}
goto repeat;
}
inum += i * sblock->s_inodes_per_group + 1;
if (inum < EXT2_FIRST_INO (sblock) || inum > sblock->s_inodes_count)
{
ext2_error ("reserved inode or inode > inodes count - "
"block_group = %d,inode=%d", i, inum);
inum = 0;
goto sync_out;
}
gdp->bg_free_inodes_count--;
if (S_ISDIR (mode))
gdp->bg_used_dirs_count++;
disk_cache_block_ref_ptr (gdp);
record_global_poke (gdp);
sblock->s_free_inodes_count--;
sblock_dirty = 1;
sync_out:
assert (bh == NULL);
pthread_spin_unlock (&global_lock);
alloc_sync (0);
/* Make sure the coming read_node won't complain about bad
fields. */
{
struct ext2_inode *di = dino_ref (inum);
memset (di, 0, sizeof *di);
dino_deref (di);
}
return inum;
}
/* The user must define this function if she wants to use the node
cache. Read stat information out of the on-disk node. */
error_t
diskfs_user_read_node (struct node *np, struct lookup_context *ctx)
{
error_t err;
struct stat *st = &np->dn_stat;
struct disknode *dn = diskfs_node_disknode (np);
struct ext2_inode *di;
struct ext2_inode_info *info = &dn->info;
ext2_debug ("(%llu)", np->cache_id);
err = diskfs_catch_exception ();
if (err)
return err;
di = dino_ref (np->cache_id);
st->st_fstype = FSTYPE_EXT2FS;
st->st_fsid = getpid (); /* This call is very cheap. */
st->st_ino = np->cache_id;
st->st_blksize = vm_page_size * 2;
st->st_nlink = di->i_links_count;
st->st_size = di->i_size;
st->st_gen = di->i_generation;
st->st_atim.tv_sec = di->i_atime;
#ifdef not_yet
/* ``struct ext2_inode'' doesn't do better than sec. precision yet. */
#else
st->st_atim.tv_nsec = 0;
#endif
st->st_mtim.tv_sec = di->i_mtime;
#ifdef not_yet
/* ``struct ext2_inode'' doesn't do better than sec. precision yet. */
#else
st->st_mtim.tv_nsec = 0;
#endif
st->st_ctim.tv_sec = di->i_ctime;
#ifdef not_yet
/* ``struct ext2_inode'' doesn't do better than sec. precision yet. */
#else
st->st_ctim.tv_nsec = 0;
#endif
st->st_blocks = di->i_blocks;
st->st_flags = 0;
if (di->i_flags & EXT2_APPEND_FL)
st->st_flags |= UF_APPEND;
if (di->i_flags & EXT2_NODUMP_FL)
st->st_flags |= UF_NODUMP;
if (di->i_flags & EXT2_IMMUTABLE_FL)
st->st_flags |= UF_IMMUTABLE;
if (sblock->s_creator_os == EXT2_OS_HURD)
{
st->st_mode = di->i_mode | (di->i_mode_high << 16);
st->st_mode &= ~S_ITRANS;
if (di->i_translator)
st->st_mode |= S_IPTRANS;
st->st_uid = di->i_uid | (di->i_uid_high << 16);
st->st_gid = di->i_gid | (di->i_gid_high << 16);
st->st_author = di->i_author;
if (st->st_author == -1)
st->st_author = st->st_uid;
}
else
{
st->st_mode = di->i_mode & ~S_ITRANS;
st->st_uid = di->i_uid;
st->st_gid = di->i_gid;
st->st_author = st->st_uid;
np->author_tracks_uid = 1;
}
/* Setup the ext2fs auxiliary inode info. */
info->i_dtime = di->i_dtime;
info->i_flags = di->i_flags;
info->i_faddr = di->i_faddr;
info->i_frag_no = di->i_frag;
info->i_frag_size = di->i_fsize;
info->i_osync = 0;
info->i_file_acl = di->i_file_acl;
if (S_ISDIR (st->st_mode))
info->i_dir_acl = di->i_dir_acl;
else
{
info->i_dir_acl = 0;
info->i_high_size = di->i_size_high;
if (info->i_high_size) /* XXX */
{
dino_deref (di);
ext2_warning ("cannot handle large file inode %Ld", np->cache_id);
diskfs_end_catch_exception ();
return EFBIG;
}
}
info->i_block_group = inode_group_num (np->cache_id);
info->i_next_alloc_block = 0;
info->i_next_alloc_goal = 0;
info->i_prealloc_count = 0;
/* Set to a conservative value. */
dn->last_page_partially_writable = 0;
if (S_ISCHR (st->st_mode) || S_ISBLK (st->st_mode))
st->st_rdev = di->i_block[0];
else
{
memcpy (info->i_data, di->i_block,
EXT2_N_BLOCKS * sizeof info->i_data[0]);
st->st_rdev = 0;
}
dn->info_i_translator = di->i_translator;
dino_deref (di);
diskfs_end_catch_exception ();
if (S_ISREG (st->st_mode) || S_ISDIR (st->st_mode)
|| (S_ISLNK (st->st_mode) && st->st_blocks))
{
unsigned offset;
np->allocsize = np->dn_stat.st_size;
/* Round up to a block multiple. */
offset = np->allocsize & ((1 << log2_block_size) - 1);
if (offset > 0)
np->allocsize += block_size - offset;
}
else
/* Allocsize should be zero for anything except directories, files, and
long symlinks. These are the only things allowed to have any blocks
allocated as well, although st_size may be zero for any type (cases
where st_blocks=0 and st_size>0 include fast symlinks, and, under
linux, some devices). */
np->allocsize = 0;
if (!diskfs_check_readonly () && !np->dn_stat.st_gen)
{
pthread_spin_lock (&generation_lock);
if (++next_generation < diskfs_mtime->seconds)
next_generation = diskfs_mtime->seconds;
np->dn_stat.st_gen = next_generation;
pthread_spin_unlock (&generation_lock);
np->dn_set_ctime = 1;
}
return 0;
}
