自学教程：C++ EXT2_BLOCKS_PER_GROUP函数代码示例

/* * Stupid algorithm --- we now just search forward starting from the * goal.  Should put in a smarter one someday.... */errcode_t ext2fs_new_block2(ext2_filsys fs, blk64_t goal,			   ext2fs_block_bitmap map, blk64_t *ret){	blk64_t	i;	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);	if (!map)		map = fs->block_map;	if (!map)		return EXT2_ET_NO_BLOCK_BITMAP;	if (!goal || (goal >= fs->super->s_blocks_count))		goal = fs->super->s_first_data_block;	i = goal;	check_block_uninit(fs, map,			   (i - fs->super->s_first_data_block) /			   EXT2_BLOCKS_PER_GROUP(fs->super));	do {		if (((i - fs->super->s_first_data_block) %		     EXT2_BLOCKS_PER_GROUP(fs->super)) == 0)			check_block_uninit(fs, map,					   (i - fs->super->s_first_data_block) /					   EXT2_BLOCKS_PER_GROUP(fs->super));		if (!ext2fs_fast_test_block_bitmap2(map, i)) {			*ret = i;			return 0;		}		i++;		if (i >= fs->super->s_blocks_count)			i = fs->super->s_first_data_block;	} while (i != goal);	return EXT2_ET_BLOCK_ALLOC_FAIL;}

/* * Initialize an ext2 partition starting at offset P_OFFSET; this is * sort-of the same idea as "mounting" it.  Read in the relevant * control structures and make them available to the user.  Returns 0 * if successful, -1 on failure. */static int ext2_mount(long cons_dev, long p_offset, long quiet){	long sb_block = 1;	long sb_offset;	int i;	dev = cons_dev;	partition_offset = p_offset;	/* initialize the inode table */	for (i = 0; i < MAX_OPEN_FILES; i++) {		inode_table[i].free = 1;		inode_table[i].inumber = 0;	}	/* clear the root inode pointer (very important!) */	root_inode = NULL;		/* read in the first superblock */	sb_offset = sb_block * EXT2_MIN_BLOCK_SIZE;	if (cons_read(dev, &sb, sizeof(sb), partition_offset + sb_offset)	    != sizeof(sb))	{		printf("ext2 sb read failed/n");		return -1;	}		if (sb.s_magic != EXT2_SUPER_MAGIC) {		if (!quiet) {			printf("ext2_init: bad magic 0x%x/n", sb.s_magic);		}		return -1;	}	ngroups = (sb.s_blocks_count -		   sb.s_first_data_block +		   EXT2_BLOCKS_PER_GROUP(&sb) - 1)		/ EXT2_BLOCKS_PER_GROUP(&sb);	gds = (struct ext2_group_desc *)	          malloc((size_t)(ngroups * sizeof(struct ext2_group_desc)));	ext2fs.blocksize = EXT2_BLOCK_SIZE(&sb);	/* read in the group descriptors (immediately follows superblock) */	cons_read(dev, gds, ngroups * sizeof(struct ext2_group_desc),		  partition_offset +                  ext2fs.blocksize * (EXT2_MIN_BLOCK_SIZE/ext2fs.blocksize + 1));	/*	 * Calculate direct/indirect block limits for this file system	 * (blocksize dependent):	 */	ext2fs.blocksize = EXT2_BLOCK_SIZE(&sb);	directlim = EXT2_NDIR_BLOCKS - 1;	ptrs_per_blk = ext2fs.blocksize/sizeof(unsigned int);	ind1lim = ptrs_per_blk + directlim;	ind2lim = (ptrs_per_blk * ptrs_per_blk) + directlim;	return 0;}

 static inline int load_block_bitmap(struct vnode *vnode ,unsigned int blk_group) {	struct bcache tmp_bitmap ,*block_bitmap; ;	unsigned int totblkgroup ,tmp;	int i ,k ;	struct ext2_super_block *sblock	sb = vnode->vfsp->ext2sb;	totblkgroup = sb->s_blocks_count - sb->s_first_data_block +	EXT2_BLOCKS_PER_GROUP(sb) - 1 / EXT2_BLOCKS_PER_GROUP(sb);	if(blk_group > totblkgroup)		printf("out of limit");	if(index_block_group[0] == blk_group)			return 0;	if(totblkgroup <= EXT_BITMAP_CACHE)	{	  if(block_bitmap[blk_group])		{			if(index_block_group[blk_group] == blk_group)				{						return blk_group;				}			else				printf("error");		}	 else		{			read_block_bitmap(vnode,blk_group ,blk_group)			return blk_group;		}	}		/* If the known block group number is within the given array of index_block_group		 * then the known block group is removed from the location  of array and place		 * to the front of the array		 *		 */	for(i = 0; index_block_group[i] != blk_group;i++);	  if(index_block_group[i] == blk_group)	   {			  tmp  = index_block_group[i];			  tmp_bitmap  =  block_bitmap [i];		for( k = i ;k > 0 k--)			{			  index_block_group [k] = index_block_group[k-1];			  block_bitmap[k] =  block_bitmap[k-1];			}			block_bitmap[0] = tmp_bitmap ;			index_block_group[0] = tmp;			brelse(&tmp_bitmap);	  }

errcode_t ext2fs_write_block_bitmap (ext2_filsys fs){	dgrp_t		i;	unsigned int	j;	int		nbytes;	unsigned int	nbits;	errcode_t	retval;	char * block_bitmap = fs->block_map->bitmap;	char * bitmap_block = NULL;	blk_t		blk;	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);	if (!(fs->flags & EXT2_FLAG_RW))		return EXT2_ET_RO_FILSYS;	if (!block_bitmap)		return 0;	nbytes = EXT2_BLOCKS_PER_GROUP(fs->super) / 8;	bitmap_block = memalign(getpagesize(), fs->blocksize);	memset(bitmap_block, 0xff, fs->blocksize);        retval = io_channel_reopen(fs->io, O_RDWR | O_DIRECT);        if (retval)            return retval;        	for (i = 0; i < fs->group_desc_count; i++) {		memcpy(bitmap_block, block_bitmap, nbytes);		if (i == fs->group_desc_count - 1) {			/* Force bitmap padding for the last group */			nbits = ((fs->super->s_blocks_count				  - fs->super->s_first_data_block)				 % EXT2_BLOCKS_PER_GROUP(fs->super));			if (nbits)				for (j = nbits; j < fs->blocksize * 8; j++)					ext2fs_set_bit(j, bitmap_block);		}		blk = fs->group_desc[i].bg_block_bitmap;		if (blk) {#ifdef EXT2_BIG_ENDIAN_BITMAPS			if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||			      (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)))				ext2fs_swap_bitmap(fs, bitmap_block, nbytes);#endif			retval = io_channel_write_blk(fs->io, blk, 1,						      bitmap_block);			if (retval)				return EXT2_ET_BLOCK_BITMAP_WRITE;		}		block_bitmap += nbytes;	}        io_channel_reopen(fs->io, O_RDWR);	fs->flags &= ~EXT2_FLAG_BB_DIRTY;	free(bitmap_block);	return 0;}

/* * init. the fs meta data, return the block size bits. */static int ext2_fs_init(struct fs_info *fs){    struct disk *disk = fs->fs_dev->disk;    struct ext2_sb_info *sbi;    struct ext2_super_block sb;    struct cache *cs;    /* read the super block */    disk->rdwr_sectors(disk, &sb, 2, 2, 0);    /* check if it is ext2, since we also support btrfs now */    if (sb.s_magic != EXT2_SUPER_MAGIC)	return -1;    sbi = malloc(sizeof(*sbi));    if (!sbi) {	malloc_error("ext2_sb_info structure");	return -1;    }    fs->fs_info = sbi;    if (sb.s_magic != EXT2_SUPER_MAGIC) {	printf("ext2 mount error: it's not a EXT2/3/4 file system!/n");	return 0;    }    fs->sector_shift = disk->sector_shift;    fs->block_shift  = sb.s_log_block_size + 10;    fs->sector_size  = 1 << fs->sector_shift;    fs->block_size   = 1 << fs->block_shift;    sbi->s_inodes_per_group = sb.s_inodes_per_group;    sbi->s_blocks_per_group = sb.s_blocks_per_group;    sbi->s_inodes_per_block = BLOCK_SIZE(fs) / sb.s_inode_size;    if (sb.s_desc_size < sizeof(struct ext2_group_desc))	sb.s_desc_size = sizeof(struct ext2_group_desc);    sbi->s_desc_per_block   = BLOCK_SIZE(fs) / sb.s_desc_size;    sbi->s_groups_count     = (sb.s_blocks_count - sb.s_first_data_block			       + EXT2_BLOCKS_PER_GROUP(fs) - 1)	                      / EXT2_BLOCKS_PER_GROUP(fs);    sbi->s_first_data_block = sb.s_first_data_block;    sbi->s_inode_size = sb.s_inode_size;    /* Volume UUID */    memcpy(sbi->s_uuid, sb.s_uuid, sizeof(sbi->s_uuid));    /* Initialize the cache, and force block zero to all zero */    cache_init(fs->fs_dev, fs->block_shift);    cs = _get_cache_block(fs->fs_dev, 0);    memset(cs->data, 0, fs->block_size);    cache_lock_block(cs);    return fs->block_shift;}

static int ext2_check_descriptors (struct super_block * sb){	int i;	int desc_block = 0;	struct ext2_sb_info *sbi = EXT2_SB(sb);	unsigned long first_block = le32_to_cpu(sbi->s_es->s_first_data_block);	unsigned long last_block;	struct ext2_group_desc * gdp = NULL;	ext2_debug ("Checking group descriptors");	for (i = 0; i < sbi->s_groups_count; i++)	{		if (i == sbi->s_groups_count - 1)			last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;		else			last_block = first_block +				(EXT2_BLOCKS_PER_GROUP(sb) - 1);		if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)			gdp = (struct ext2_group_desc *) sbi->s_group_desc[desc_block++]->b_data;		if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||		    le32_to_cpu(gdp->bg_block_bitmap) > last_block)		{			ext2_error (sb, "ext2_check_descriptors",				    "Block bitmap for group %d"				    " not in group (block %lu)!",				    i, (unsigned long) le32_to_cpu(gdp->bg_block_bitmap));			return 0;		}		if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||		    le32_to_cpu(gdp->bg_inode_bitmap) > last_block)		{			ext2_error (sb, "ext2_check_descriptors",				    "Inode bitmap for group %d"				    " not in group (block %lu)!",				    i, (unsigned long) le32_to_cpu(gdp->bg_inode_bitmap));			return 0;		}		if (le32_to_cpu(gdp->bg_inode_table) < first_block ||		    le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group - 1 >		    last_block)		{			ext2_error (sb, "ext2_check_descriptors",				    "Inode table for group %d"				    " not in group (block %lu)!",				    i, (unsigned long) le32_to_cpu(gdp->bg_inode_table));			return 0;		}		first_block += EXT2_BLOCKS_PER_GROUP(sb);		gdp++;	}	return 1;}

/* * Checks that the data in the descriptor blocks make sense. */intext2_check_descriptors(struct ext2_sb_info *sb){        int i;        int desc_block = 0;        unsigned long block = sb->s_es->s_first_data_block;        struct ext2_group_desc *gdp = NULL;        /* ext2_debug ("Checking group descriptors"); */        for (i = 0; i < sb->s_groups_count; i++)        {		/* examine next descriptor block */                if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)                        gdp = (struct ext2_group_desc *)				sb->s_group_desc[desc_block++]->b_data;                if (gdp->bg_block_bitmap < block ||                    gdp->bg_block_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))                {                        kprintf ("ext2_check_descriptors: "                                    "Block bitmap for group %d"                                    " not in group (block %lu)!/n",                                    i, (unsigned long) gdp->bg_block_bitmap);                        return 0;                }                if (gdp->bg_inode_bitmap < block ||                    gdp->bg_inode_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))                {                        kprintf ("ext2_check_descriptors: "                                    "Inode bitmap for group %d"                                    " not in group (block %lu)!/n",                                    i, (unsigned long) gdp->bg_inode_bitmap);                        return 0;                }                if (gdp->bg_inode_table < block ||                    gdp->bg_inode_table + sb->s_itb_per_group >=                    block + EXT2_BLOCKS_PER_GROUP(sb))                {                        kprintf ("ext2_check_descriptors: "                                    "Inode table for group %d"                                    " not in group (block %lu)!/n",                                    i, (unsigned long) gdp->bg_inode_table);                        return 0;                }                block += EXT2_BLOCKS_PER_GROUP(sb);                gdp++;        }        return 1;}

errcode_t ext2fs_image_bitmap_write(ext2_filsys fs, int fd, int flags){	char		*ptr;	int		c, size;	char		zero_buf[1024];	ssize_t		actual;	errcode_t	retval;	if (flags & IMAGER_FLAG_INODEMAP) {		if (!fs->inode_map) {			retval = ext2fs_read_inode_bitmap(fs);			if (retval)				return retval;		}		ptr = fs->inode_map->bitmap;		size = (EXT2_INODES_PER_GROUP(fs->super) / 8);	} else {		if (!fs->block_map) {			retval = ext2fs_read_block_bitmap(fs);			if (retval)				return retval;		}		ptr = fs->block_map->bitmap;		size = EXT2_BLOCKS_PER_GROUP(fs->super) / 8;	}	size = size * fs->group_desc_count;	actual = write(fd, ptr, size);	if (actual == -1) {		retval = errno;		goto errout;	}	if (actual != size) {		retval = EXT2_ET_SHORT_WRITE;		goto errout;	}	size = size % fs->blocksize;	memset(zero_buf, 0, sizeof(zero_buf));	if (size) {		size = fs->blocksize - size;		while (size) {			c = size;			if (c > (int) sizeof(zero_buf))				c = sizeof(zero_buf);			actual = write(fd, zero_buf, c);			if (actual == -1) {				retval = errno;				goto errout;			}			if (actual != c) {				retval = EXT2_ET_SHORT_WRITE;				goto errout;			}			size -= c;		}	}	retval = 0;errout:	return (retval);}

errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,				       const char *descr,				       ext2fs_block_bitmap *ret){	__u64		start, end, real_end;	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);	fs->write_bitmaps = ext2fs_write_bitmaps;	start = fs->super->s_first_data_block;	end = ext2fs_blocks_count(fs->super)-1;	real_end = ((__u64) EXT2_BLOCKS_PER_GROUP(fs->super)		    * (__u64) fs->group_desc_count)-1 + start;	if (fs->flags & EXT2_FLAG_64BITS)		return (ext2fs_alloc_generic_bmap(fs,				  EXT2_ET_MAGIC_BLOCK_BITMAP64,				  EXT2FS_BMAP64_BITARRAY,				  start, end, real_end, descr, ret));	if ((end > ~0U) || (real_end > ~0U))		return EXT2_ET_CANT_USE_LEGACY_BITMAPS;	return (ext2fs_make_generic_bitmap(EXT2_ET_MAGIC_BLOCK_BITMAP, fs,					   start, end, real_end,					   descr, 0,					   (ext2fs_generic_bitmap *) ret));}

/* * ext2fs_allocate_block_bitmap() really allocates a per-cluster * bitmap for backwards compatibility.  This function allocates a * block bitmap which is truly per-block, even if clusters/bigalloc * are enabled.  mke2fs and e2fsck need this for tracking the * allocation of the file system metadata blocks. */errcode_t ext2fs_allocate_subcluster_bitmap(ext2_filsys fs,					    const char *descr,					    ext2fs_block_bitmap *ret){	__u64			start, end, real_end;	ext2fs_generic_bitmap	bmap;	errcode_t		retval;	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);	fs->write_bitmaps = ext2fs_write_bitmaps;	if (!fs->cluster_ratio_bits)		return ext2fs_allocate_block_bitmap(fs, descr, ret);	if ((fs->flags & EXT2_FLAG_64BITS) == 0)		return EXT2_ET_CANT_USE_LEGACY_BITMAPS;	start = fs->super->s_first_data_block;	end = ext2fs_blocks_count(fs->super)-1;	real_end = ((__u64) EXT2_BLOCKS_PER_GROUP(fs->super)		    * (__u64) fs->group_desc_count)-1 + start;	retval = ext2fs_alloc_generic_bmap(fs, EXT2_ET_MAGIC_BLOCK_BITMAP64,					   fs->default_bitmap_type, start,					   end, real_end, descr, &bmap);	if (retval)		return retval;	bmap->cluster_bits = 0;	*ret = bmap;	return 0;}

errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,				       const char *descr,				       ext2fs_block_bitmap *ret){	ext2fs_block_bitmap bitmap;	errcode_t	retval;	__u32		start, end, real_end;	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);	fs->write_bitmaps = ext2fs_write_bitmaps;	start = fs->super->s_first_data_block;	end = fs->super->s_blocks_count-1;	real_end = (EXT2_BLOCKS_PER_GROUP(fs->super)		    * fs->group_desc_count)-1 + start;	retval = ext2fs_allocate_generic_bitmap(start, end, real_end,						descr, &bitmap);	if (retval)		return retval;	bitmap->magic = EXT2_ET_MAGIC_BLOCK_BITMAP;	bitmap->fs = fs;	bitmap->base_error_code = EXT2_ET_BAD_BLOCK_MARK;	*ret = bitmap;	return 0;}

static int ext2_check_descriptors (struct super_block * sb){	int i;	int desc_block = 0;	unsigned long block = sb->u.ext2_sb.s_es->s_first_data_block;	struct ext2_group_desc * gdp = NULL;	ext2_debug ("Checking group descriptors");	for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++)	{		if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)			gdp = (struct ext2_group_desc *) sb->u.ext2_sb.s_group_desc[desc_block++]->b_data;		if (gdp->bg_block_bitmap < block ||		    gdp->bg_block_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))		{			ext2_error (sb, "ext2_check_desciptors",				    "Block bitmap for group %d"				    " not in group (block %lu)!",				    i, gdp->bg_block_bitmap);			return 0;		}		if (gdp->bg_inode_bitmap < block ||		    gdp->bg_inode_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))		{			ext2_error (sb, "ext2_check_desciptors",				    "Inode bitmap for group %d"				    " not in group (block %lu)!",				    i, gdp->bg_inode_bitmap);			return 0;		}		if (gdp->bg_inode_table < block ||		    gdp->bg_inode_table + sb->u.ext2_sb.s_itb_per_group >=		    block + EXT2_BLOCKS_PER_GROUP(sb))		{			ext2_error (sb, "ext2_check_desciptors",				    "Inode table for group %d"				    " not in group (block %lu)!",				    i, gdp->bg_inode_table);			return 0;		}		block += EXT2_BLOCKS_PER_GROUP(sb);		gdp++;	}	return 1;}

int Ext2Partition::mount(){    EXT2_SUPER_BLOCK sblock;    int gSizes, gSizeb;		/* Size of total group desc in sectors */    char *tmpbuf;    read_disk(handle, &sblock, relative_sect + 2, 2, sect_size);	/* read superBlock of root */    if(sblock.s_magic != EXT2_SUPER_MAGIC)    {        LOG("Bad Super Block. The drive %s is not ext2 formatted./n", linux_name.c_str());        return -1;    }    if(sblock.s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)    {        LOG("File system compression is used which is not supported./n");    }    blocksize = EXT2_BLOCK_SIZE(&sblock);    inodes_per_group = EXT2_INODES_PER_GROUP(&sblock);    inode_size = EXT2_INODE_SIZE(&sblock);    LOG("Block size %d, inp %d, inodesize %d/n", blocksize, inodes_per_group, inode_size);    totalGroups = (sblock.s_blocks_count)/EXT2_BLOCKS_PER_GROUP(&sblock);    gSizeb = (sizeof(EXT2_GROUP_DESC) * totalGroups);    gSizes = (gSizeb / sect_size)+1;    desc = (EXT2_GROUP_DESC *) calloc(totalGroups, sizeof(EXT2_GROUP_DESC));    if(desc == NULL)    {        LOG("Not enough Memory: mount: desc: Exiting/n");        exit(1);    }    if((tmpbuf = (char *) malloc(gSizes * sect_size)) == NULL)    {        LOG("Not enough Memory: mount: tmpbuf: Exiting/n");        exit(1);    }    /* Read all Group descriptors and store in buffer */    /* I really dont know the official start location of Group Descriptor array */    if((blocksize/sect_size) <= 2)        read_disk(handle, tmpbuf, relative_sect + ((blocksize/sect_size) + 2), gSizes, sect_size);    else        read_disk(handle, tmpbuf, relative_sect + (blocksize/sect_size), gSizes, sect_size);    memcpy(desc, tmpbuf, gSizeb);    free(tmpbuf);    return 0;}

static int ext2_setup_super (struct super_block * sb,                             struct ext2_super_block * es,                             int read_only){    int res = 0;    struct ext2_sb_info *sbi = EXT2_SB(sb);    if (le32_to_cpu(es->s_rev_level) > EXT2_MAX_SUPP_REV) {        ext2_msg(sb, KERN_ERR,                 "error: revision level too high, "                 "forcing read-only mode");        res = MS_RDONLY;    }    if (read_only)        return res;#ifndef MY_ABC_HERE    if (!(sbi->s_mount_state & EXT2_VALID_FS))        ext2_msg(sb, KERN_WARNING,                 "warning: mounting unchecked fs, "                 "running e2fsck is recommended");    else if ((sbi->s_mount_state & EXT2_ERROR_FS))        ext2_msg(sb, KERN_WARNING,                 "warning: mounting fs with errors, "                 "running e2fsck is recommended");    else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&             le16_to_cpu(es->s_mnt_count) >=             (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))        ext2_msg(sb, KERN_WARNING,                 "warning: maximal mount count reached, "                 "running e2fsck is recommended");    else if (le32_to_cpu(es->s_checkinterval) &&             (le32_to_cpu(es->s_lastcheck) +              le32_to_cpu(es->s_checkinterval) <= get_seconds()))        ext2_msg(sb, KERN_WARNING,                 "warning: checktime reached, "                 "running e2fsck is recommended");#endif    if (!le16_to_cpu(es->s_max_mnt_count))        es->s_max_mnt_count = cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);    le16_add_cpu(&es->s_mnt_count, 1);    if (test_opt (sb, DEBUG))        ext2_msg(sb, KERN_INFO, "%s, %s, bs=%lu, fs=%lu, gc=%lu, "                 "bpg=%lu, ipg=%lu, mo=%04lx]",                 EXT2FS_VERSION, EXT2FS_DATE, sb->s_blocksize,                 sbi->s_frag_size,                 sbi->s_groups_count,                 EXT2_BLOCKS_PER_GROUP(sb),                 EXT2_INODES_PER_GROUP(sb),                 sbi->s_mount_opt);    return res;}

/* * Stupid algorithm --- we now just search forward starting from the * goal.  Should put in a smarter one someday.... */errcode_t ext2fs_new_block2(ext2_filsys fs, blk64_t goal,			   ext2fs_block_bitmap map, blk64_t *ret){	blk64_t	i;	int	c_ratio;	EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);	if (!map)		map = fs->block_map;	if (!map)		return EXT2_ET_NO_BLOCK_BITMAP;	if (!goal || (goal >= ext2fs_blocks_count(fs->super)))		goal = fs->super->s_first_data_block;	i = goal;	c_ratio = 1 << ext2fs_get_bitmap_granularity(map);	if (c_ratio > 1)		goal &= ~EXT2FS_CLUSTER_MASK(fs);	check_block_uninit(fs, map,			   (i - fs->super->s_first_data_block) /			   EXT2_BLOCKS_PER_GROUP(fs->super));	do {		if (((i - fs->super->s_first_data_block) %		     EXT2_BLOCKS_PER_GROUP(fs->super)) == 0)			check_block_uninit(fs, map,					   (i - fs->super->s_first_data_block) /					   EXT2_BLOCKS_PER_GROUP(fs->super));		if (!ext2fs_fast_test_block_bitmap2(map, i)) {			*ret = i;			return 0;		}		i = (i + c_ratio) & ~(c_ratio - 1);		if (i >= ext2fs_blocks_count(fs->super))			i = fs->super->s_first_data_block;	} while (i != goal);	return EXT2_ET_BLOCK_ALLOC_FAIL;}

int Partition::Mount(){    EXT2_SUPER_BLOCK sblock;    int gSizes, gSizeb;    char *tmpbuf;    ReadDisk(handle, &sblock, relative_sect + 2, 2, sect_size);    if(sblock.s_magic != EXT2_SUPER_MAGIC)    {        LOG("Bad Super Block. The drive %s is not ext2 formatted./n", linux_name.c_str());        return -1;    }    if(sblock.s_feature_incompat & EXT2_FEATURE_INCOMPAT_COMPRESSION)    {        LOG("File system compression is used which is not supported./n");    }    blocksize = EXT2_BLOCK_SIZE(&sblock);    inodes_per_group = EXT2_INODES_PER_GROUP(&sblock);    inode_size = EXT2_INODE_SIZE(&sblock);    LOG("    Розм
C++ EXT2_BLOCK_SIZE函数代码示例
C++ EXPR_LOCATION函数代码示例