yafs_op.h

简单模拟了操作系统文件系统的操作

  initSuperBlock.free_blocks_count --;
  initGroupDesc.free_blocks_count --;
  blockBitmap[ 18 ] = '1';

  writeBlockBitmap( blockBitmap );
  writeInodeBitmap( inodeBitmap );
  writeInode( inodeRoot, 0 );
  writeDirEntry( rootDir, 0, 18 );
  writeDirEntry( rootFather, rootDir.rec_len, 18 );
  writeSuperBlock( initSuperBlock );
  writeGroupDesc( initGroupDesc );
}

/*!
 * \brief 生成指定目录下的所有子目录
 * @param dirFather 生成的目录的根目录
 */
void createSubDir( struct dir_entry_mem *dirFather )
{
	int offset = 0;
	int block = dirFather->inode.node.i_block[0];
	struct dir_entry tmpDir = getDirEntry( offset, block );

	while ( tmpDir.rec_len != 0 )
	{
		tmpDir = getDirEntry( offset, block );
		struct dir_entry_mem *child = new dir_entry_mem();
		list<dir_entry_mem> children;
		child->father = dirFather;
		child->dir = tmpDir;
		child->children = children;
		child->inode = inode2InodeMem( getInode( tmpDir.inode ) );
		dirFather->children.insert( dirFather->children.end(), *child );
		offset += tmpDir.rec_len;
	}

	list<dir_entry_mem>::iterator iter = dirFather->children.begin();
	iter++;
	iter++;

	while ( iter != dirFather->children.end() )
	{
		if( (*iter).dir.file_type == 2 )
			createSubDir( &(*iter) );
		iter++;
	}

}


/*!
 * \brief 生成内存中的目录结构
 * @return 返回生成的目录结构的根目录的指针
 */
struct dir_entry_mem* createDirEntry()
{
	list<dir_entry_mem> children;
	struct dir_entry tmpDir = getDirEntry( 0, 18 );
	int offset = 0;

	result.father = &result;
	result.dir = tmpDir;
	memset( result.dir.name, 0, sizeof( char ) * YAFS_NAME_LEN );
	strcpy( result.dir.name, "/" );
	result.children = children;

	result.inode = inode2InodeMem( getInode( 0 ) );

	while( tmpDir.rec_len != 0 )
	{
		tmpDir = getDirEntry( offset, 18 );

		struct dir_entry_mem *tmpDirMem = new dir_entry_mem();
		tmpDirMem->father = &result;
		tmpDirMem->dir = tmpDir;
		tmpDirMem->inode = inode2InodeMem( getInode( tmpDir.inode ) );

		result.children.insert( result.children.end(), *tmpDirMem );
		offset += tmpDir.rec_len;
	}

	list<dir_entry_mem>::iterator iter = result.children.begin();
	iter ++;
	iter ++;

	while( iter != result.children.end() )
	{
		if( (*iter).dir.file_type == 2 )
			createSubDir( &(*iter) );

		iter++;
	}

	return &result;
}

/*!
 * \brief 在指定目录下新建一个文件夹
 * @param father 新建的文件夹的父目录
 * @param orgname 文件夹的名字
 */
void newDir( struct dir_entry_mem *father, const char* orgname )
{
	char name[ YAFS_NAME_LEN];
	memset( name, 0, sizeof( char ) * YAFS_NAME_LEN );
	strcpy( name, orgname );

	if( ! isValidOp( *father, name ) )
		return;

	list<dir_entry_mem> children;
	struct inode newInode;
	struct inode_mem newInodeMem;
	struct dir_entry newDir;
	struct dir_entry_mem newDirMem;
	struct dir_entry fatherDir;
	struct dir_entry selfDir;
	struct dir_entry_mem fatherDirMem;
	struct dir_entry_mem selfDirMem;
	int inodeNum = alloInodeNum();
	int blockNum = alloBlockNum();

	newInode.i_ctime = time( NULL );
	newInode.i_atime = newInode.i_ctime;
	newInode.i_mtime = newInode.i_ctime;
	memset( newInode.i_block, 0, YAFS_N_BLOCKS * sizeof( int ) );
	newInode.i_block[ 0 ] = blockNum;
	newInode.i_blocks = 1;
	newInode.i_size = 1024;

	newInodeMem.node = newInode;

	newDir.file_type = 2;
	newDir.inode = inodeNum;
	newDir.rec_len = 0;
	memset( newDir.name, 0, sizeof( char ) * YAFS_NAME_LEN );
	strcpy( newDir.name, name );

	newDirMem.father = father;
	newDirMem.dir = newDir;
	newDirMem.children = children;
	newDirMem.inode = newInodeMem;

	fatherDir = father->dir;
	memset( fatherDir.name, 0, sizeof( char ) * YAFS_NAME_LEN );
	strcpy( fatherDir.name, ".." );
	fatherDir.rec_len = 0;

	selfDir = newDir;
	selfDir.rec_len = sizeof( struct dir_entry );
	strcpy( selfDir.name, "." );

	fatherDirMem.dir = fatherDir;
	fatherDirMem.inode = father->inode;
	fatherDirMem.children = father->children;
	fatherDirMem.father = father->father;

	selfDirMem.children = newDirMem.children;
	selfDirMem.dir = selfDir;
	selfDirMem.father = father;
	selfDirMem.inode = newDirMem.inode;

	newDirMem.children.insert( newDirMem.children.end(), selfDirMem );
	newDirMem.children.insert( newDirMem.children.end(), fatherDirMem );
	newDirMem.children.front().children = newDirMem.children;

	writeDirEntry( selfDir, 0, blockNum );
	writeDirEntry( fatherDir, selfDir.rec_len, blockNum );
	writeInode( newInode, inodeNum );
	father->children.insert( father->children.end(), newDirMem );
	addDirEntry( father, newDir );
}

/*!
 * \brief 在指定目录下新建一个文件
 * @param father 新建的文件的父目录
 * @param orgname 新建的文件的文件名
 * @param len 新建的文件的大小
 */
void newFile( struct dir_entry_mem *father, const char *orgname, int len )
{
	char name[ YAFS_NAME_LEN];
	memset( name, 0, sizeof( char ) * YAFS_NAME_LEN );
	strcpy( name, orgname );

	if( ! isValidOp( *father, name ) )
		return;

	struct dir_entry newDir;
	struct dir_entry_mem newDirMem;
	struct inode newInode;
	struct inode_mem newInodeMem;
	int inodeNum = alloInodeNum();
	list<dir_entry_mem> children;

	newInode.i_ctime = time( NULL );
	newInode.i_atime = newInode.i_ctime;
	newInode.i_mtime = newInode.i_ctime;
	newInode.i_size = len;
	newInode.i_blocks = ceil( (double)len / ( double )1024 );
	memset( newInode.i_block, 0, sizeof( int ) * YAFS_N_BLOCKS );
	for ( int i = 0; i < (int)newInode.i_blocks; i ++ )
		newInode.i_block[ i ] = alloBlockNum();

	newInodeMem.node = newInode;

	newDir.file_type = 1;
	newDir.inode = inodeNum;
	newDir.rec_len = 0;
	strcpy( newDir.name, name );

	newDirMem.children = children;
	newDirMem.dir = newDir;
	newDirMem.father = father;
	newDirMem.inode = newInodeMem;

	addDirEntry( father, newDir );
	writeInode( newInode, inodeNum );
	father->children.insert( father->children.end(), newDirMem );
}

/*!
 * \brief 重命名文件或者文件夹
 * @param father 文件或者文件夹所在的目录
 * @param orgname 文件或者文件夹的原来的名字
 * @param name 文件或者文件夹的新名字
 */
void rename( struct dir_entry_mem *father, const char* orgname, const char* name )
{
	char orgName[ YAFS_NAME_LEN];
	memset( orgName, 0, sizeof( char ) * YAFS_NAME_LEN );
	strcpy( orgName, orgname );

	if( father->children.size() >= 10 )
	{
		printf( "%s", "目录下的文件和文件夹已经满了\n"  );
		return;
	}

	bool isExist = false;
	list<dir_entry_mem>::iterator iter = father->children.begin();

	while( iter != father->children.end() )
	{
		if( strcmp( (*iter).dir.name, orgName ) == 0 )
		{
			isExist = true;
			break;
		}

		iter++;
	}

	if( isExist == false )
	{
		printf( "%s", "ļûдļ\n" );
		return;
	}

	strcpy( (*iter).dir.name, name );

	FILE *file = fopen( "disk.img", "r+" );
	struct dir_entry tmpDir;
	int block = father->inode.node.i_block[ 0 ];
	int offset = 0;

	fseek( file, block * 1024, SEEK_SET );
	fread( &tmpDir, sizeof( struct dir_entry ), 1, file );

	while( tmpDir.rec_len != 0 )
	{
		fseek( file, block * 1024 + offset , SEEK_SET );
		fread( &tmpDir, sizeof( struct dir_entry ), 1, file );

		if( strcmp( tmpDir.name, orgName ) == 0 )
		{
			memset( tmpDir.name, 0, sizeof( char ) * YAFS_NAME_LEN );
			strcpy( tmpDir.name, name );
			break;
		}

		offset += tmpDir.rec_len;
	}

	fclose( file );
	writeDirEntry( tmpDir, offset, block );
}

/*!
 * \brief 删除指定目录下的文件或者文件夹
 * @param father 需要被删除的文件或者文件夹所在的目录
 * @param orgname 需要被删除的文件或者文件夹的名字
 */
void deleteFile( struct dir_entry_mem* father, const char* orgname )
{
	char name[ YAFS_NAME_LEN ];
	memset( name, 0, sizeof( char ) * YAFS_NAME_LEN );
	strcpy( name, orgname );

	list<dir_entry_mem>::iterator iter  = father->children.begin();
	bool isExist = false;

	while ( iter != father->children.end() )
	{
		if( strcmp ( (*iter).dir.name, name ) == 0  )
		{
			isExist = true;
			break;
		}

		iter ++;
	}

	if( !isExist )
	{
		printf( "%s", "不存在这样的文件或者文件夹\n" );
		return;
	}

	struct dir_entry_mem tmpDirMem = *iter;

	if( tmpDirMem.children.size() > 2 )
	{
		printf( "%s", "该文件夹下存在文件或者文件夹，不能删除\n" );
		return;
	}

	father->children.erase( iter );

	FILE *file = fopen( "disk.img", "r+" );
	int block = father->inode.node.i_block[ 0 ];
	struct dir_entry tmpDir;
	struct dir_entry preDir;

	fseek( file, block * 1024, SEEK_SET );
	fread( &preDir, sizeof( dir_entry ), 1, file );
	fseek( file, block * 1024, SEEK_SET );
	fread( &tmpDir, sizeof( dir_entry ), 1, file );
	int offset = 0;

	while( tmpDir.rec_len != 0 )
	{
		fread( &tmpDir, sizeof( dir_entry ), 1, file );

		if( strcmp( tmpDir.name, name ) == 0 )
			break;

		offset += preDir.rec_len;
		preDir = tmpDir;
		fseek( file, block * 1024 + offset + tmpDir.rec_len, SEEK_SET );
	}

	if( tmpDir.rec_len == 0 )
		preDir.rec_len = 0;
	else
		preDir.rec_len += tmpDir.rec_len;

	writeDirEntry( preDir, offset, block );
	fclose( file );

	int i = 0;

	while ( tmpDirMem.inode.node.i_block[ i ] !=  0 )
	{
		updateBlockBitmap( tmpDirMem.inode.node.i_block[ i ], '0' );
		initSuperBlock.free_blocks_count++;
		initGroupDesc.free_blocks_count++;
		i++;
	}

	updateInodeBitmap( tmpDirMem.dir.inode, '0' );
	initSuperBlock.free_inodes_count++;
	initGroupDesc.free_inodes_count++;

	writeSuperBlock( initSuperBlock );
	writeGroupDesc( initGroupDesc );
}

/*!
 * \brief 系统启动的初始化操作
 * @return 返回目录结构的根目录指针
 */
struct dir_entry_mem* init()
{
	getSuperBlock();
	getGroupDesc();

	return createDirEntry();
}