static void write_tables(void) {
unsigned long imaps = get_nimaps();
unsigned long zmaps = get_nzmaps();
size_t buffsz = get_inode_buffer_size();
/* Mark the super block valid. */
super_set_state();
if (lseek(DEV, 0, SEEK_SET))
err(MKFS_EX_ERROR, _("%s: seek to boot block failed "
" in write_tables"), device_name);
if (write_all(DEV, boot_block_buffer, 512))
err(MKFS_EX_ERROR, _("%s: unable to clear boot sector"), device_name);
if (MINIX_BLOCK_SIZE != lseek(DEV, MINIX_BLOCK_SIZE, SEEK_SET))
err(MKFS_EX_ERROR, _("%s: seek failed in write_tables"), device_name);
if (write_all(DEV, super_block_buffer, MINIX_BLOCK_SIZE))
err(MKFS_EX_ERROR, _("%s: unable to write super-block"), device_name);
if (write_all(DEV, inode_map, imaps * MINIX_BLOCK_SIZE))
err(MKFS_EX_ERROR, _("%s: unable to write inode map"), device_name);
if (write_all(DEV, zone_map, zmaps * MINIX_BLOCK_SIZE))
err(MKFS_EX_ERROR, _("%s: unable to write zone map"), device_name);
if (write_all(DEV, inode_buffer, buffsz))
err(MKFS_EX_ERROR, _("%s: unable to write inodes"), device_name);
}
static void super_set_map_blocks(unsigned long inodes)
{
switch (fs_version) {
case 3:
Super3.s_imap_blocks = UPPER(inodes + 1, BITS_PER_BLOCK);
Super3.s_zmap_blocks = UPPER(BLOCKS - (1+get_nimaps()+inode_blocks()),
BITS_PER_BLOCK+1);
Super3.s_firstdatazone = first_zone_data();
break;
default:
Super.s_imap_blocks = UPPER(inodes + 1, BITS_PER_BLOCK);
Super.s_zmap_blocks = UPPER(BLOCKS - (1+get_nimaps()+inode_blocks()),
BITS_PER_BLOCK+1);
Super.s_firstdatazone = first_zone_data();
break;
}
}
extern void readbitmap(char* device, image_head image_hdr, unsigned long* bitmap, int pui){
unsigned long zones = get_nzones();
unsigned long imaps = get_nimaps();
unsigned long zmaps = get_nzmaps();
char * inode_map;
char * zone_map;
ssize_t rc;
unsigned long test_block = 0, test_zone = 0;
fs_open(device);
unsigned long block_size = get_block_size();
if (fs_version == 3){
if (lseek(dev, block_size*2, SEEK_SET) != 8192)
log_mesg(0, 1, 1, fs_opt.debug, "%s: seek failed", __FILE__);
}
inode_map = malloc(imaps * block_size);
if (!inode_map)
log_mesg(0, 1, 1, fs_opt.debug, "%s: Unable to allocate buffer for inode map", __FILE__);
zone_map = malloc(zmaps * block_size);
if (!inode_map)
log_mesg(0, 1, 1, fs_opt.debug, "%s: Unable to allocate buffer for zone map", __FILE__);
memset(inode_map,0,sizeof(inode_map));
memset(zone_map,0,sizeof(zone_map));
memset(bitmap,0,sizeof(unsigned long)*LONGS(image_hdr.totalblock));
rc = read(dev, inode_map, imaps * block_size);
if (rc < 0 || imaps * block_size != (size_t) rc)
log_mesg(0, 1, 1, fs_opt.debug, "%s: Unable to read inode map", __FILE__);
rc = read(dev, zone_map, zmaps * block_size);
if (rc < 0 || zmaps * block_size != (size_t) rc)
log_mesg(0, 1, 1, fs_opt.debug, "%s: Unable to read zone map", __FILE__);
log_mesg(0, 0, 0, fs_opt.debug, "%s: %ld blocks\n", __FILE__, zones);
log_mesg(0, 0, 0, fs_opt.debug, "%s: log2 block/zone: %lu\n", __FILE__, get_zone_size());
log_mesg(0, 0, 0, fs_opt.debug, "%s: Zonesize=%d\n", __FILE__,block_size<<get_zone_size());
log_mesg(0, 0, 0, fs_opt.debug, "%s: Maxsize=%ld\n", __FILE__, get_max_size());
for (test_block = 0; test_block < zones; test_block++){
test_zone = test_block - get_first_zone()+1;
if ((test_zone < 0) || (test_zone > zones+get_first_zone()))
test_zone = 0;
if(isset(zone_map,test_zone)){
log_mesg(3, 0, 0, fs_opt.debug, "%s: test_block %lu in use\n", __FILE__, test_block);
pc_set_bit(test_block, bitmap);
}else{
log_mesg(3, 0, 0, fs_opt.debug, "%s: test_block %lu not use\n", __FILE__, test_block);
}
}
fs_close();
}
static unsigned long count_used_block(){
unsigned long zones = get_nzones();
unsigned long imaps = get_nimaps();
unsigned long zmaps = get_nzmaps();
char * inode_map;
char * zone_map;
ssize_t rc;
unsigned long test_block = 0, test_zone = 0;
unsigned long used_block = 0;
unsigned long block_size = get_block_size();
if (fs_version == 3){
if (lseek(dev, block_size*2, SEEK_SET) != 8192)
log_mesg(0, 1, 1, fs_opt.debug, "%s: seek failed", __FILE__);
}
inode_map = malloc(imaps * block_size);
if (!inode_map)
log_mesg(0, 1, 1, fs_opt.debug, "%s: Unable to allocate buffer for inode map", __FILE__);
zone_map = malloc(zmaps * block_size);
if (!inode_map)
log_mesg(0, 1, 1, fs_opt.debug, "%s: Unable to allocate buffer for zone map", __FILE__);
memset(inode_map,0,sizeof(inode_map));
memset(zone_map,0,sizeof(zone_map));
rc = read(dev, inode_map, imaps * block_size);
if (rc < 0 || imaps * block_size != (size_t) rc)
log_mesg(0, 1, 1, fs_opt.debug, "%s: Unable to read inode map", __FILE__);
rc = read(dev, zone_map, zmaps * block_size);
if (rc < 0 || zmaps * block_size != (size_t) rc)
log_mesg(0, 1, 1, fs_opt.debug, "%s: Unable to read zone map", __FILE__);
for (test_block = 0; test_block < zones; test_block++){
test_zone = test_block - get_first_zone()+1;
if ((test_zone < 0) || (test_zone > zones+get_first_zone()))
test_zone = 0;
if(isset(zone_map,test_zone)){
log_mesg(3, 0, 0, fs_opt.debug, "%s: test_block %lu in use\n", __FILE__, test_block);
used_block++;
}else{
log_mesg(3, 0, 0, fs_opt.debug, "%s: test_block %lu not use\n", __FILE__, test_block);
}
}
return used_block;
}
static void setup_tables(void) {
unsigned long inodes, zmaps, imaps, zones, i;
super_block_buffer = calloc(1, MINIX_BLOCK_SIZE);
if (!super_block_buffer)
err(MKFS_EX_ERROR, _("%s: unable to allocate buffer for superblock"),
device_name);
memset(boot_block_buffer,0,512);
super_set_magic();
if (fs_version == 3) {
Super3.s_log_zone_size = 0;
Super3.s_blocksize = MINIX_BLOCK_SIZE;
}
else {
Super.s_log_zone_size = 0;
}
super_init_maxsize();
super_set_nzones();
zones = get_nzones();
/* some magic nrs: 1 inode / 3 blocks */
if ( req_nr_inodes == 0 )
inodes = BLOCKS/3;
else
inodes = req_nr_inodes;
/* Round up inode count to fill block size */
if (fs_version == 2 || fs_version == 3)
inodes = ((inodes + MINIX2_INODES_PER_BLOCK - 1) &
~(MINIX2_INODES_PER_BLOCK - 1));
else
inodes = ((inodes + MINIX_INODES_PER_BLOCK - 1) &
~(MINIX_INODES_PER_BLOCK - 1));
if (fs_version == 3)
Super3.s_ninodes = inodes;
else {
Super.s_ninodes = inodes;
if (inodes > MINIX_MAX_INODES)
inodes = MINIX_MAX_INODES;
}
super_set_map_blocks(inodes);
imaps = get_nimaps();
zmaps = get_nzmaps();
inode_map = malloc(imaps * MINIX_BLOCK_SIZE);
zone_map = malloc(zmaps * MINIX_BLOCK_SIZE);
if (!inode_map || !zone_map)
err(MKFS_EX_ERROR, _("%s: unable to allocate buffers for maps"),
device_name);
memset(inode_map,0xff,imaps * MINIX_BLOCK_SIZE);
memset(zone_map,0xff,zmaps * MINIX_BLOCK_SIZE);
for (i = get_first_zone() ; i<zones ; i++)
unmark_zone(i);
for (i = MINIX_ROOT_INO ; i<=inodes; i++)
unmark_inode(i);
inode_buffer = malloc(get_inode_buffer_size());
if (!inode_buffer)
err(MKFS_EX_ERROR, _("%s: unable to allocate buffer for inodes"),
device_name);
memset(inode_buffer,0, get_inode_buffer_size());
printf(P_("%lu inode\n", "%lu inodes\n", inodes), inodes);
printf(P_("%lu block\n", "%lu blocks\n", zones), zones);
printf(_("Firstdatazone=%jd (%jd)\n"), get_first_zone(), first_zone_data());
printf(_("Zonesize=%zu\n"), (size_t) MINIX_BLOCK_SIZE << get_zone_size());
printf(_("Maxsize=%zu\n\n"),get_max_size());
}
static void setup_tables(const struct fs_control *ctl) {
unsigned long inodes, zmaps, imaps, zones, i;
super_block_buffer = xcalloc(1, MINIX_BLOCK_SIZE);
memset(boot_block_buffer,0,512);
super_set_magic(ctl);
if (fs_version == 3) {
Super3.s_log_zone_size = 0;
Super3.s_blocksize = MINIX_BLOCK_SIZE;
}
else {
Super.s_log_zone_size = 0;
}
super_init_maxsize();
super_set_nzones(ctl);
zones = get_nzones();
/* some magic nrs: 1 inode / 3 blocks for smaller filesystems,
* for one inode / 16 blocks for large ones. mkfs will eventually
* crab about too far when getting close to the maximum size. */
if (ctl->fs_inodes == 0)
if (2048 * 1024 < ctl->fs_blocks) /* 2GB */
inodes = ctl->fs_blocks / 16;
else if (512 * 1024 < ctl->fs_blocks) /* 0.5GB */
inodes = ctl->fs_blocks / 8;
else
inodes = ctl->fs_blocks / 3;
else
inodes = ctl->fs_inodes;
/* Round up inode count to fill block size */
if (fs_version == 2 || fs_version == 3)
inodes = ((inodes + MINIX2_INODES_PER_BLOCK - 1) &
~(MINIX2_INODES_PER_BLOCK - 1));
else
inodes = ((inodes + MINIX_INODES_PER_BLOCK - 1) &
~(MINIX_INODES_PER_BLOCK - 1));
if (fs_version == 3)
Super3.s_ninodes = inodes;
else {
Super.s_ninodes = inodes;
if (inodes > MINIX_MAX_INODES)
inodes = MINIX_MAX_INODES;
}
super_set_map_blocks(ctl, inodes);
if (MINIX_MAX_INODES < first_zone_data())
errx(MKFS_EX_ERROR,
_("First data block at %jd, which is too far (max %d).\n"
"Try specifying fewer inodes by passing --inodes <num>"),
first_zone_data(),
MINIX_MAX_INODES);
imaps = get_nimaps();
zmaps = get_nzmaps();
inode_map = xmalloc(imaps * MINIX_BLOCK_SIZE);
zone_map = xmalloc(zmaps * MINIX_BLOCK_SIZE);
memset(inode_map,0xff,imaps * MINIX_BLOCK_SIZE);
memset(zone_map,0xff,zmaps * MINIX_BLOCK_SIZE);
for (i = get_first_zone() ; i<zones ; i++)
unmark_zone(i);
for (i = MINIX_ROOT_INO ; i<=inodes; i++)
unmark_inode(i);
inode_buffer = xmalloc(get_inode_buffer_size());
memset(inode_buffer,0, get_inode_buffer_size());
printf(P_("%lu inode\n", "%lu inodes\n", inodes), inodes);
printf(P_("%lu block\n", "%lu blocks\n", zones), zones);
printf(_("Firstdatazone=%jd (%jd)\n"), get_first_zone(), first_zone_data());
printf(_("Zonesize=%zu\n"), (size_t) MINIX_BLOCK_SIZE << get_zone_size());
printf(_("Maxsize=%zu\n\n"),get_max_size());
}