readext2fs.c

本人写的读取ext2文件系统的程序。可以很大的帮助你理解ext2文件系统的物理布局。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <time.h>
#include <linux/ext2_fs.h>

#include "readext2fs.h"

#define BUFFER_SIZE 4096
#define CMD_LEN     255

struct ext2_base_info ebi;
char device[64];
//char entry_dir[512];

/****************************************************************************
//read and display ext2 filesystem information;
****************************************************************************/
//==========================================================================
int show_block(int fd,unsigned int block,char* pblock)
{

	int i,j;
	
	if(block < 0 || block > ebi.blocks_count)
	{
		fprintf(stderr,"block %u error: maximum block %lu\n",
			block,ebi.blocks_count);
		return -1;
	}

	memset(pblock,0,BUFFER_SIZE);
	if(lseek64(fd,(ull)ebi.block_size*(ull)block,SEEK_SET) < 0)
	{
		fprintf(stderr,"seek error:%s\n",strerror(errno));
		return -1;
	}
	read(fd,pblock,BUFFER_SIZE);
	
	printf("hex display of block %u\n",block);
	for(i = 0; i< BUFFER_SIZE;i+= 16)
	{
		printf("\n%04d\t",i);
		for(j = 0;j<16;j++)
			printf("%02x ",(unsigned char)pblock[i + j]);
		printf("\t");
		for(j = 0;j<16;j++)
			if(pblock[i+j] > 32 && pblock[i+j] < 127)
				printf("%c",pblock[i+j]);
			else
				printf(".");
	}
	printf("\n");
	return 0;
}
//===========================================================================
int show_super_info(int fd,char* pblock)
{
	struct ext2_super_block* sb = NULL;
	
	memset(pblock,0,BUFFER_SIZE);
	lseek(fd,1024,SEEK_SET);
	read(fd,pblock,1024);
	sb = (struct ext2_super_block*)pblock;

	printf("Magic signature           :%x\n",sb->s_magic);
	printf("Volume Name               :%s\n",sb->s_volume_name);
	printf("Size of The device        :%luM\n",ebi.device_size);
	printf("Partion State             :%u\n",sb->s_state);
	printf("\n");	

	printf("Block Size                :%lu\n",ebi.block_size);
	printf("Blocks Count              :%lu\n",ebi.blocks_count);
	printf("Reserved Blocks Count     :%u\n",sb->s_r_blocks_count);
	printf("Free Block Count          :%u\n",sb->s_free_blocks_count);
	printf("First Data Block          :%u\n",sb->s_first_data_block);
	printf("\n");	

	printf("Fragment Size             :%u\n",1<<(sb->s_log_frag_size + 10));
	printf("\n");	


	printf("Block Group Infomation\n");
	printf("Blocks per Group          :%u\n",sb->s_blocks_per_group);
	printf("Size of a Group           :%luM\n",ebi.group_size);
	printf("groups count		  :%lu\n",ebi.groups_count);
	printf("Fragment per Group        :%u\n",sb->s_frags_per_group);
	printf("Inodes per Group          :%u\n",sb->s_inodes_per_group);
	printf("\n");	

	printf("Inodes Count              :%u\n",sb->s_inodes_count);
	printf("Free Inode Count          :%u\n",sb->s_free_inodes_count);
	printf("First non-reserved inode  :%u\n",sb->s_first_ino);
	printf("Size of Inode structrue   :%u\n",sb->s_inode_size);
	printf("\n");	

	printf("Mount Time                :%s",ctime((time_t*)&(sb->s_mtime))); 
	printf("Write Time                :%s",ctime((time_t*)&(sb->s_wtime))); 
	printf("\n");	

	printf("Directory where last mounted :%s\n",sb->s_last_mounted);
	printf("Mount Count               :%u\n",sb->s_mnt_count);
	printf("Maximum Mount Count       :%d\n",sb->s_max_mnt_count);
	printf("\n");	

	printf("Block Group # of this superblock: %u\n",sb->s_block_group_nr);	
	printf("\n");	

	return 0;
}
//===========================================================================
int read_group_desc_table(int fd,char* pblock)
{
	unsigned int seek;
	
	memset(pblock,0,BUFFER_SIZE);
	seek = (ebi.first_data_block + 1)*ebi.block_size;
	lseek(fd,seek,SEEK_SET);
	read(fd,pblock,ebi.block_size);

	return 0;
}

int show_group_desc_table(int fd,char* pblk)
{
	struct ext2_group_desc* desc = NULL;
	int i = 1,max_group_num;	

	read_group_desc_table(fd,pblk);
	desc = (struct ext2_group_desc*)pblk;

	max_group_num = ebi.block_size/sizeof(struct ext2_group_desc);


	printf("group number:%d\n",max_group_num);
	while(i <= max_group_num)
	{
		if(desc->bg_block_bitmap == 0)
			break;
		printf("\ngroup %03d\t",i);
		printf("block bitmap block: %-6u\t",desc->bg_block_bitmap);
		printf("inode bitmap block: %-6u\t",desc->bg_inode_bitmap);
		printf("inode table  block: %-6u\t",desc->bg_inode_table);
		desc++;
		i++;
	}
	printf("\n");
	
	return 0;
}

int show_group_desc(int fd,int num,char* pblk)
{
	struct ext2_group_desc* desc = NULL;
	int max_group_num;	
	
	if(num < 1 || num > ebi.groups_count)
	{
		fprintf(stderr,"error: invalid group %d\n",num);
		return -1;
	}

	read_group_desc_table(fd,pblk);
	desc = (struct ext2_group_desc*)pblk;

	max_group_num = ebi.block_size/sizeof(struct ext2_group_desc);


	desc += (num - 1);
	printf("item %d in group description table:\n",num);
	printf("block bitmap block	:%u\n",desc->bg_block_bitmap);
	printf("inode bitmap block	:%u\n",desc->bg_inode_bitmap);
	printf("inode table  block	:%u\n",desc->bg_inode_table);
	printf("free block count	:%u\n",desc->bg_free_blocks_count);
	printf("free inode count	:%u\n",desc->bg_free_inodes_count);
	printf("directories count	:%u\n",desc->bg_used_dirs_count);
	printf("\n");
					
	
	return 0;

}

//===========================================================================
int show_inode_table(int fd,int num,int off,char* pblock)
{
	struct ext2_inode* inode = NULL,*cur;
	int inodes_per_block,i,j;
	unsigned int inode_block = 0,inode_blocks,inode_num;

	if(num < 1 || num > ebi.groups_count || off < 0 || off > ebi.inode_blocks_per_group)
	{
		fprintf(stderr,"The number:%d or %d error!\n",num,off);
		return -1;
	}
	if(off > 0)
		printf("显示组 %d(从1开始计数)的i节点表的第%d个块:\n",num,off);

	inodes_per_block = ebi.block_size/sizeof(struct ext2_inode);
	inode_block = (num - 1)*ebi.blocks_per_group + ebi.first_data_block + 4;
	if(off > 0)
	{
		inode_block += (off - 1);
		inode_num   = (num - 1)*ebi.inodes_per_group + (off - 1)*inodes_per_block;
		inode_blocks = 1;
	}
	else
	{
		inode_num   = (num - 1)*ebi.inodes_per_group;
		inode_blocks = ebi.inode_blocks_per_group;
	}	

	for(j = 0;j < inode_blocks; j++)
	{
		memset(pblock,0,BUFFER_SIZE);
		if(lseek64(fd,(ull)inode_block*(ull)ebi.block_size,SEEK_SET) < 0)
		{
			fprintf(stderr,"seek error:%s\n",strerror(errno));
			return -1;
		}
		read(fd,pblock,BUFFER_SIZE);

		inode = (struct ext2_inode*)pblock;
	
		for(i = 0;i < inodes_per_block;i++)
		{
			cur = inode + i;
			if(cur->i_size== 0)
				continue;
			printf("block %d item:%d\tinode%d\tmode:%o\tsize:%u\tfirst block:%u\n",
				inode_block + j,i + 1,inode_num + i + 1,cur->i_mode,cur->i_size,cur->i_block[0]);
		}
		inode_block++;
		inode_num += inodes_per_block;
	}
	return 0;
}

//===========================================================================
int show_block_bitmap(int fd,int num,char* pblock)
{
	unsigned int bitmap_block;
	
	if(num < 1 || num > ebi.groups_count)
	{
		fprintf(stderr,"group %d error!\n",num);
		return -1;
	}

	bitmap_block = (num-1)*ebi.blocks_per_group + ebi.first_data_block + 2;
	printf("group %d\t block bitmap %u\n",num,bitmap_block);
	show_block(fd,bitmap_block,pblock);

	return 0;
}

//===========================================================================
int show_inode_bitmap(int fd,int num,char* pblock)
{
	unsigned int bitmap_block;
	
	if(num < 1 || num > ebi.groups_count)
	{
		fprintf(stderr,"group %d error!\n",num);
		return -1;
	}

	bitmap_block = (num-1)*ebi.blocks_per_group + ebi.first_data_block + 3;
	printf("group %d\t block bitmap %u\n",num,bitmap_block);
	show_block(fd,bitmap_block,pblock);

	return 0;
}

//===========================================================================
int ls(struct ext2_inode* inode,int fd,char* pblock)
{
	struct ext2_dir_entry_2* dir;
	int count = 0;
	char name[255];

	if(lseek64(fd,(ull)(inode->i_block[0])*(ull)ebi.block_size,SEEK_SET) < 0)
	{
		fprintf(stderr,"seek error:%s\n",strerror(errno));
		return -1;
	}
	memset(pblock,0,BUFFER_SIZE);
	read(fd,pblock,BUFFER_SIZE);
	dir = (struct ext2_dir_entry_2*)pblock;

	while(count < ebi.block_size)
	{
		memset(name,0,255);
		strncpy(name,dir->name,dir->name_len);
		printf("inode:%7u\tname:%s\n",dir->inode,name);
//		printf("name:%16s\t inode:%u\tentry length: %d\t name len: %d\tcount len:%d\n",
//			name,dir->inode,dir->rec_len,dir->name_len,count);
		count += dir->rec_len;
		dir = (struct ext2_dir_entry_2*)(pblock + count); 		
		
	}

	return 0;
}

unsigned long long locate_inum(unsigned long inum)
{
	unsigned long group,block,offset;
	unsigned long long seek;
	int inodes_per_block;

	group  = (inum - 1)/ebi.inodes_per_group;
	block  = group * ebi.blocks_per_group + ebi.first_data_block + 4;

	offset = (inum - 1)%ebi.inodes_per_group;
	inodes_per_block = ebi.block_size/sizeof(struct ext2_inode);
	block += offset/inodes_per_block;
	offset = offset%inodes_per_block;
	seek = (ull)block * (ull)ebi.block_size + (ull)offset * sizeof(struct ext2_inode);

//	printf(";;;;;;;;;;;;;;;group %lu\t,block %lu\toffset%lu\n",group,block,offset);
//	printf(";;;;;;;;;;;;;;;;;;seek 0x%llx\n",seek);

	return seek;
}

int read_inode(int fd,unsigned long inum,struct ext2_inode* pinode)
{
	unsigned long long seek;

	memset(pinode,0,sizeof(struct ext2_inode));
	seek = locate_inum(inum);
	if(lseek64(fd,seek,SEEK_SET) < 0)
	{
		fprintf(stderr,"seek error:%s\n",strerror(errno));
		return -1;
	}
	read(fd,pinode,sizeof(struct ext2_inode));

	return 0;
}

int show_inode_data_block(struct ext2_inode* inode)
{
	int i,num ;
	if(inode->i_size <= 12*ebi.block_size)
	{
		num = inode->i_size/ebi.block_size;
		if(inode->i_size%ebi.block_size)
			num++;
		printf("data block:\t");
		for(i = 0;i < num; i++)
			printf("%u\t",inode->i_block[i]);
		printf("\n");
	}
	return 0;
}

int show_inode_info(unsigned int inum,char* name,struct ext2_inode* inode)
{
	if(inode->i_size == 0)
	{
		printf("Invalid inode!\n");
		return -1;