淘宝分布式文件存储系统( 三 ) -TFS

淘宝分布式文件存储系统( 三 ) ->>TFS

目录 :

• 文件重新映射的接口介绍
• 文件映射 mmap_file.cpp的实现
• 进行测试

文件重新映射 (增加 或者 减少 文件映射区域的大小)

mremap() 函数的原型如下

#include

void *mremap( void * old_address , size_t old_size , size_t new_size , int flags );

参数说明 ：

• old_address：指向原映射区域的起始地址。
• old_size：原映射区域的大小，以字节为单位。
• new_size：新映射区域的大小，以字节为单位。
• flags：标志参数，用于指定映射操作的行为。常用的标志是 MREMAP_MAYMOVE，表示允许系统将映射区域移动到新的位置。

返回值 :

• 成功时，返回新映射区域的起始地址。
• 失败时，返回 MAP_FAILED，并设置 errno 错误码来指示具体错误。
  注意 :
  在使用 mremap() 函数前，需要通过 mmap() 函数创建原始的内存映射区域，并确保该内存映射区域是有效的。另外，mremap() 函数只能用于修改已存在的内存映射区域，无法在不同的文件描述符之间创建新的映射。

文件映射 mmap_file.cpp的实现 :

#include"mmap_file.h"
#include

int static Debug=1 ; 

namespace qiniu
{
	namespace largefile
	{
     //构造函数
	 MMapFile::MMapFile():
	 size_(0),fd_(-1),data_(NULL)
	 {
		
	 }
	 MMapFile::MMapFile(const int fd):
	 size_(0),fd_(fd),data_(NULL)
	 {
				
	 }
	MMapFile::MMapFile(const MMapOption& mmp_option, const int fd):
	size_(0),fd_(fd),data_(0)
	{
	mmap_file_option_.max_mmap_size_=mmp_option.max_mmap_size_;
	mmap_file_option_.frist_mmap_size_=mmp_option.frist_mmap_size_;
	mmap_file_option_.pri_mmap_size_=mmp_option.pri_mmap_size_;
	}
	//析构函数
	MMapFile::~MMapFile()
	{
		if(data_){   //映射内容不为空,说明映射成功
		   if(Debug)   printf("file information size : %d ,fd : %d , data : %p\n",size_,fd_,data_);
				     
			 msync(data_, size_, MS_SYNC);      //当我们的数据发生改变,同步信号,更新完成后一起返回
		    //解除文件映射
		     munmap(data_ , size_ );
	  
			size_=0;
			fd_=-1;
			data_=NULL;
				   
			mmap_file_option_.max_mmap_size_=0;
			mmap_file_option_.frist_mmap_size_=0;
			mmap_file_option_.pri_mmap_size_=0;
			}
	}
	//同步文件		
	bool MMapFile::sync_file()   
	{
		if(data_!=NULL && size_>0){  //如果data_为空,或者 映射的大小<0 ,则说明没有映射
			if( msync(data_ , size_ , MS_SYNC)<0){  //同步失败
			   fprintf( stderr, "file sync falied %s \n", strerror(errno));
			    return false;
			}
				return true;
		 }
				return false;
	}
	 //文件映射		
	bool MMapFile::map_file(const bool write)  
	{
		int flags=PROT_READ;
		if(write){
			flags |= PROT_WRITE;     //同时设置为可读
		}
			if(fd_ < 0){        
				return false ;
			}
				
			if(size_ > mmap_file_option_.max_mmap_size_){  //如果初始化的大小,比我们设定的最大的映射大小还要大
				size_=mmap_file_option_.max_mmap_size_;  
			}
				
			if(size_< mmap_file_option_.frist_mmap_size_){ //如果size_ 的大小,小于我们第一次分配的大小
				size_=mmap_file_option_.frist_mmap_size_ ;
			}
				
			if(!ensure_flie_size(size_)){        //调整大小
				fprintf(stderr , "ensure_flie_size falied: %d\n", size_);
				return false;
			}
			data_=mmap(NULL, size_  , flags, MAP_SHARED , fd_ , 0);  //文件映射
			
			if( MAP_FAILED==data_ ){   //内存映射失败,返回 MAP_FAILED
				fprintf(stderr, "file failed :%s\n",strerror(errno));
					
				fd_=-1;
				data_=NULL;
				size_=0;
				return false;
			}
			if(Debug){
				printf("file map succeed  : size_ : %d ,fd : %d , data : %p\n",size_,fd_,data_);
			}
				return true;
	}
	//获取映射内存的首地址		
	void* MMapFile::get_data()const
	{
		return data_;     //返回映射内存的起始地址
	}
	//获取映射内存的大小		
	int32_t MMapFile::get_size()const
	{
		return size_;    //返回映射内存的大小
	}
			
	bool MMapFile::munmap_file()  
	{
		if(munmap(data_ , size_)==-1){    //解除文件映射失败
			fprintf(stderr , "remove file map falied :%s \n",strerror(errno));
			return false;
		}
			return true;
	}
	//解除映射		
	bool MMapFile::ensure_flie_size(const int32_t size)
	{
		struct stat s;         //存放文件状态(这个是系统提供的)
		if(fstat(fd_ , &s) < 0 ){					//获取文件状态
			fprintf(stderr , "fstat falied :%s \n",strerror(errno));
			return false;
		}
				
		if(s.st_size<size){        //设置文件大小
			int res=ftruncate(fd_ , size); //对大小进行调整  
			if(res<0){             //在 linux系统中,大多数情况返回值<0 表示失败
				fprintf(stderr , "resize failed :%s \n",strerror(errno));
				return false;
			}
		}
			return true;
	}
			
	/*
		重新执行映射  (追加，减少内存)
		mremap()
	*/
	//重新映射
	bool MMapFile::remap_file()    
	{	
	//防御性编程
		if(data_==NULL || size_<0 || fd_< 0){//判断是否存在映射区域
			fprintf(stderr, "not map file\n");
			return false;
		}
				 
		if(size_==mmap_file_option_.max_mmap_size_){//当前映射区域的大小,已经达到我们设置的最大值
			fprintf(stderr,"size is already max\n");
			return false;
	    }
				 
	   int32_t new_size=size_+mmap_file_option_.pri_mmap_size_;   //新的映射区域的大小
			if(new_size>mmap_file_option_.max_mmap_size_){//如果新的大小大于我们的最大值
				new_size=mmap_file_option_.max_mmap_size_;
		    }
		//调整文件大小
		if(!ensure_flie_size(new_size)){        //调整大小
			fprintf(stderr , "ensure_flie_size falied: %d\n", size_);
			return false;
		}
		if(Debug)  printf("file map succeed  : %d ,fd : %d , data : %p\n",size_,fd_,data_);
			//最后进行重新映射
		void *new_data=mremap(data_ , size_ , size_+ mmap_file_option_.pri_mmap_size_,MREMAP_MAYMOVE);//调整映射区域
		if(new_data==MAP_FAILED){
			fprintf(stderr , "remap_file failed :%s \n",strerror(errno));
			return false;
		}
		//赋值
		data_=new_data;
		size_=new_size;
		return true;
	 }
   }
}

• 补充：
  这里呢,给大家分享一些方法,当我们在写一些大型项目的时候,我们一般会将标准化的头文件,函数调用需要的头文件,放到一个 .h的文件中,我这里演示的也是这样操作的 :

#ifndef _COMMON_H_
#define _COMMON_H_

#include
#include     
#include
#include
#include
#include
#include 
#include
#include
#include 
#include

#endif  /*_COMMON_H_*/     //这样注释起来更加清晰 , 因为我们可能不止包含一个

技巧提示：
如果不知道,我们所写的函数需要什么头文件 ,可以这样操作 man APi

演示 :
man mmap

对代码的可行性进行测试 :

提示: 整个测试我们需要综合我的上一篇内容, 结合 mmap_file.h 头文件一起 .

#include"mmap_file.h"
#include"common.h"

using namespace std;
using namespace qiniu;

static const mode_t OPEN_MODE=0644;       //文件的权限
const static largefile::MMapOption mmp_option={10240000,4096 ,4096};  //设置内存映射参数

int open_file(string file_name, int open_flags)
{    
    //OPEN_MODE   如果文件不存在，则创建
     int fd=open( file_name.c_str(), open_flags, OPEN_MODE); //成功返回值一定>0
	 if( fd<0 ){
		 return -errno;
	 }
	 return fd;
}

int main(){
	const char* file_name="./mapfile_test.txt";
	//打开一个文件,获取文件的句柄
	int fd=open_file(file_name , O_RDWR | O_CREAT | O_LARGEFILE );
	if( fd <0 ){     //返回的文件句柄不合法
		fprintf(stderr ," open file failed : %s  error desc : %s\n",file_name , strerror(-fd));
		return -1;
	}
	
	printf("%d\n",fd);
	
	largefile::MMapFile *map_file=new largefile::MMapFile(mmp_option,fd);
	
	bool is_mmap=map_file->map_file(true);                        //文件映射到内存
	//printf("文件映射的起始地址: %p\n", map_file->get_data());
	//printf("映射内存的大小 : %d\n", map_file->get_size());
	
	printf(" is_mmap: %d\n",is_mmap);
	if(is_mmap){
		memset(map_file->get_data(),'8',map_file->get_size());    //将映射的内存全部置为'8'
		map_file->sync_file();                                    //同步文件
		
		//解除映射
		map_file->munmap_file();
	}else{
		fprintf(stderr,"map file failed \n");
	}
	
	close(fd);	
	return 0;
}
 

测试结果:

size: 文件映射到内存的大小。

data: 文件映射到内存的起始地址。

fd: 文件的句柄。

对测试结果进行说明：

• 测试程序成功将文件映射到内存，然后将文件映射到内存的起始地址、映射的大小、文件的句柄，打印了出来。当我们对文件mapfile_test.txt进行查看的时候，文件的内容全是8，说明，映射内存的改变，会同时导致我们源文件的改变(t同步的，当然我们也可以对其进行设置，文件只是共享，映射内存改变不会影响到我们的源文件)。
• 文件映射大概就是这样 , 后续我会给大家介绍 文件映射操作的实战,还会讲一些大神级别的写法 .

最后给大家分享一个liunx函数帮助文档:
函数帮助文档
*提取码: * 0307