static struct ext2_group_desc * get_group_desc (struct super_block * sb,
unsigned int block_group,
struct buffer_head ** bh)
{
unsigned long group_desc;
unsigned long desc;
struct ext2_group_desc * gdp;
if (block_group >= sb->u.ext2_sb.s_groups_count)
ext2_panic (sb, "get_group_desc",
"block_group >= groups_count - "
"block_group = %d, groups_count = %lu",
block_group, sb->u.ext2_sb.s_groups_count);
group_desc = block_group / EXT2_DESC_PER_BLOCK(sb);
desc = block_group % EXT2_DESC_PER_BLOCK(sb);
if (!sb->u.ext2_sb.s_group_desc[group_desc])
ext2_panic (sb, "get_group_desc",
"Group descriptor not loaded - "
"block_group = %d, group_desc = %lu, desc = %lu",
block_group, group_desc, desc);
gdp = (struct ext2_group_desc *)
sb->u.ext2_sb.s_group_desc[group_desc]->b_data;
if (bh)
*bh = sb->u.ext2_sb.s_group_desc[group_desc];
return gdp + desc;
}
/*
* load_inode_bitmap loads the inode bitmap for a blocks group
*
* It maintains a cache for the last bitmaps loaded. This cache is managed
* with a LRU algorithm.
*
* Notes:
* 1/ There is one cache per mounted file system.
* 2/ If the file system contains less than EXT2_MAX_GROUP_LOADED groups,
* this function reads the bitmap without maintaining a LRU cache.
*
* Return the buffer_head of the bitmap or the ERR_PTR(error)
*/
static struct buffer_head *load_inode_bitmap (struct super_block * sb,
unsigned int block_group)
{
int i, slot = 0;
struct ext2_sb_info *sbi = &sb->u.ext2_sb;
struct buffer_head *bh = sbi->s_inode_bitmap[0];
if (block_group >= sbi->s_groups_count)
ext2_panic (sb, "load_inode_bitmap",
"block_group >= groups_count - "
"block_group = %d, groups_count = %lu",
block_group, sbi->s_groups_count);
if (sbi->s_loaded_inode_bitmaps > 0 &&
sbi->s_inode_bitmap_number[0] == block_group && bh)
goto found;
if (sbi->s_groups_count <= EXT2_MAX_GROUP_LOADED) {
slot = block_group;
bh = sbi->s_inode_bitmap[slot];
if (!bh)
goto read_it;
if (sbi->s_inode_bitmap_number[slot] == slot)
goto found;
ext2_panic (sb, "load_inode_bitmap",
"block_group != inode_bitmap_number");
}
bh = NULL;
for (i = 0; i < sbi->s_loaded_inode_bitmaps &&
sbi->s_inode_bitmap_number[i] != block_group;
i++)
;
if (i < sbi->s_loaded_inode_bitmaps)
bh = sbi->s_inode_bitmap[i];
else if (sbi->s_loaded_inode_bitmaps < EXT2_MAX_GROUP_LOADED)
sbi->s_loaded_inode_bitmaps++;
else
brelse (sbi->s_inode_bitmap[--i]);
while (i--) {
sbi->s_inode_bitmap_number[i+1] = sbi->s_inode_bitmap_number[i];
sbi->s_inode_bitmap[i+1] = sbi->s_inode_bitmap[i];
}
read_it:
if (!bh)
bh = read_inode_bitmap (sb, block_group);
sbi->s_inode_bitmap_number[slot] = block_group;
sbi->s_inode_bitmap[slot] = bh;
if (!bh)
return ERR_PTR(-EIO);
found:
return bh;
}
int
main (int argc, char **argv)
{
error_t err;
mach_port_t bootstrap;
/* Initialize the diskfs library, parse arguments, and open the store.
This starts the first diskfs thread for us. */
store = diskfs_init_main (&startup_argp, argc, argv,
&store_parsed, &bootstrap);
if (store->size < SBLOCK_OFFS + SBLOCK_SIZE)
ext2_panic ("device too small for superblock (%Ld bytes)", store->size);
if (store->log2_blocks_per_page < 0)
ext2_panic ("device block size (%zu) greater than page size (%zd)",
store->block_size, vm_page_size);
/* Map the entire disk. */
create_disk_pager ();
pokel_init (&global_pokel, diskfs_disk_pager, disk_cache);
map_hypermetadata ();
/* Set diskfs_root_node to the root inode. */
err = diskfs_cached_lookup (EXT2_ROOT_INO, &diskfs_root_node);
if (err)
ext2_panic ("can't get root: %s", strerror (err));
else if ((diskfs_root_node->dn_stat.st_mode & S_IFMT) == 0)
ext2_panic ("no root node!");
pthread_mutex_unlock (&diskfs_root_node->lock);
/* Now that we are all set up to handle requests, and diskfs_root_node is
set properly, it is safe to export our fsys control port to the
outside world. */
diskfs_startup_diskfs (bootstrap, 0);
/* and so we die, leaving others to do the real work. */
pthread_exit (NULL);
/* NOTREACHED */
return 0;
}
/*
* load_inode_bitmap loads the inode bitmap for a blocks group
*
* It maintains a cache for the last bitmaps loaded. This cache is managed
* with a LRU algorithm.
*
* Notes:
* 1/ There is one cache per mounted file system.
* 2/ If the file system contains less than EXT2_MAX_GROUP_LOADED groups,
* this function reads the bitmap without maintaining a LRU cache.
*
* Return the slot used to store the bitmap, or a -ve error code.
*/
static int load_inode_bitmap (struct super_block * sb,
unsigned int block_group)
{
int i, j, retval = 0;
unsigned long inode_bitmap_number;
struct buffer_head * inode_bitmap;
if (block_group >= sb->u.ext2_sb.s_groups_count)
ext2_panic (sb, "load_inode_bitmap",
"block_group >= groups_count - "
"block_group = %d, groups_count = %lu",
block_group, sb->u.ext2_sb.s_groups_count);
if (sb->u.ext2_sb.s_loaded_inode_bitmaps > 0 &&
sb->u.ext2_sb.s_inode_bitmap_number[0] == block_group &&
sb->u.ext2_sb.s_inode_bitmap[0] != NULL)
return 0;
if (sb->u.ext2_sb.s_groups_count <= EXT2_MAX_GROUP_LOADED) {
if (sb->u.ext2_sb.s_inode_bitmap[block_group]) {
if (sb->u.ext2_sb.s_inode_bitmap_number[block_group] != block_group)
ext2_panic (sb, "load_inode_bitmap",
"block_group != inode_bitmap_number");
else
return block_group;
} else {
retval = read_inode_bitmap (sb, block_group,
block_group);
if (retval < 0)
return retval;
return block_group;
}
}
for (i = 0; i < sb->u.ext2_sb.s_loaded_inode_bitmaps &&
sb->u.ext2_sb.s_inode_bitmap_number[i] != block_group;
i++)
;
if (i < sb->u.ext2_sb.s_loaded_inode_bitmaps &&
sb->u.ext2_sb.s_inode_bitmap_number[i] == block_group) {
inode_bitmap_number = sb->u.ext2_sb.s_inode_bitmap_number[i];
inode_bitmap = sb->u.ext2_sb.s_inode_bitmap[i];
for (j = i; j > 0; j--) {
sb->u.ext2_sb.s_inode_bitmap_number[j] =
sb->u.ext2_sb.s_inode_bitmap_number[j - 1];
sb->u.ext2_sb.s_inode_bitmap[j] =
sb->u.ext2_sb.s_inode_bitmap[j - 1];
}
sb->u.ext2_sb.s_inode_bitmap_number[0] = inode_bitmap_number;
sb->u.ext2_sb.s_inode_bitmap[0] = inode_bitmap;
/*
* There's still one special case here --- if inode_bitmap == 0
* then our last attempt to read the bitmap failed and we have
* just ended up caching that failure. Try again to read it.
*/
if (!inode_bitmap)
retval = read_inode_bitmap (sb, block_group, 0);
} else {
if (sb->u.ext2_sb.s_loaded_inode_bitmaps < EXT2_MAX_GROUP_LOADED)
sb->u.ext2_sb.s_loaded_inode_bitmaps++;
else
brelse (sb->u.ext2_sb.s_inode_bitmap[EXT2_MAX_GROUP_LOADED - 1]);
for (j = sb->u.ext2_sb.s_loaded_inode_bitmaps - 1; j > 0; j--) {
sb->u.ext2_sb.s_inode_bitmap_number[j] =
sb->u.ext2_sb.s_inode_bitmap_number[j - 1];
sb->u.ext2_sb.s_inode_bitmap[j] =
sb->u.ext2_sb.s_inode_bitmap[j - 1];
}
retval = read_inode_bitmap (sb, block_group, 0);
}
return retval;
}
