TFS文件系统数据服务器启动加载分析

TFS文件系统数据服务器启动加载分析

   TFS文件系统的数据服务器在启动时会有加载超级块,加载文件块的操作,可以对照代码,

做下分析.

   (1). 启动加载

int BlockFileManager::bootstrap(const SysParam::FileSystemParam& fs_param)         {             //装载超级块             int ret = load_super_blk(fs_param);             if (TFS_SUCCESS != ret){                 return ret;             }             //装载块文件             return load_block_file();         }

  (2). 装载超级块

//加载超级块         int BlockFileManager::load_super_blk(const SysParam::FileSystemParam& fs_param)         {             bool fs_init_status = true;             //reserve:储备,mount:安装             TBSYS_LOG(INFO, "read super block. mount name: %s, offset: %d/n", fs_param.mount_name_.c_str(),fs_param.super_block_reserve_offset_);             //会去读取超级块存成的文件             super_block_impl_ = new SuperBlockImpl(fs_param.mount_name_, fs_param.super_block_reserve_offset_);             int ret = super_block_impl_->read_super_blk(super_block_);             if (TFS_SUCCESS != ret)             {                 TBSYS_LOG(ERROR, "read super block error. ret: %d, desc: %s/n", ret, strerror(errno));                 return ret;             }             //在检查超级块的状态:是否是DEV_TAG="TAOBAO"             if (!super_block_impl_->check_status(DEV_TAG, super_block_))             {                 fs_init_status = false;             }             //接上面的判断是否进行了文件系统格式化             if (!fs_init_status)             {                 TBSYS_LOG(ERROR, "file system not inited. please format it first./n");                 return EXIT_FS_NOTINIT_ERROR;             }             //假定主块是,扩展块是,在接着依据这个条件展开             //计算项目个数=主块数+扩展块数+1=9+3+1=13             unsigned item_count = super_block_.main_block_count_ + super_block_.extend_block_count_ + 1;             TBSYS_LOG(INFO, "file system bitmap size: %u/n", item_count);             normal_bit_map_ = new BitMap(item_count);             error_bit_map_ = new BitMap(item_count);             //那么这个时候bit_map_size_=2             bit_map_size_ = normal_bit_map_->get_slot_count();             //假定分配个字节的缓冲             char* tmp_bit_map_buf = new char[4 * bit_map_size_];             memset(tmp_bit_map_buf, 0, 4 * bit_map_size_);             ret = super_block_impl_->read_bit_map(tmp_bit_map_buf, 4 * bit_map_size_);             if (TFS_SUCCESS != ret)             {                 tbsys::gDeleteA(tmp_bit_map_buf);                 return ret;             }             // 连续对前面四个小段进行比较:因为是* bit_map_size_             // 先比较前面两个,在比较后面两个             if (memcmp(tmp_bit_map_buf, tmp_bit_map_buf + bit_map_size_, bit_map_size_) != 0)             {                 tbsys::gDeleteA(tmp_bit_map_buf);                 TBSYS_LOG(ERROR, "normal bitmap conflict");  //位图有冲突                 return EXIT_BITMAP_CONFLICT_ERROR;             }             if (memcmp(tmp_bit_map_buf + 2 * bit_map_size_, tmp_bit_map_buf + 3 * bit_map_size_, bit_map_size_) != 0)             {                 tbsys::gDeleteA(tmp_bit_map_buf);                 TBSYS_LOG(ERROR, "error bitmap conflict");                 return EXIT_BITMAP_CONFLICT_ERROR;             }             //在装载位图:bit_map_size_=2  tmp_bit_map_buf=4*2=8,分两段,前面一段是普通位图,后面一段是错误位图             normal_bit_map_->copy(bit_map_size_, tmp_bit_map_buf);             error_bit_map_->copy(bit_map_size_, tmp_bit_map_buf + 2 * bit_map_size_);             //计算位图使用的个数             TBSYS_LOG(DEBUG, "bitmap used count: %u, error: %u", normal_bit_map_->get_set_count(),error_bit_map_->get_set_count());             tbsys::gDeleteA(tmp_bit_map_buf);             return TFS_SUCCESS; }

（3）SuperBlockImpl类

//flag默认值是true,slave:附件         SuperBlockImpl::SuperBlockImpl(const std::string& mount_name, const int32_t super_start_offset, const bool flag) :         super_reserve_offset_(super_start_offset)         {             //dir             if (true == flag)             {                 //比如mount_name=/data/tfs1,那么super_block_file_=/data/tfs1/fs_super                 super_block_file_ = mount_name + SUPERBLOCK_NAME;  ///SUPERBLOCK_NAME: /fs_super             }             else             {                 super_block_file_ = mount_name;             }             //bitmap起始偏移量=超级快存储偏移量+2个超级块大小+一个整形大小             bitmap_start_offset_ = super_reserve_offset_ + 2 * sizeof(SuperBlock) + sizeof(int);             //superblock file is already exist             //已经确定了超级块的文件名             file_op_ = new FileOperation(super_block_file_, O_RDWR | O_SYNC);             if (NULL == file_op_)             {                 assert(false);             } }

int SuperBlockImpl::read_super_blk(SuperBlock& super_block) const {             memset(&super_block, 0, sizeof(SuperBlock));             //super_reserve_offset_:读位置的偏移量             return file_op_->pread_file((char*) (&super_block), sizeof(SuperBlock), super_reserve_offset_); }

int SuperBlockImpl::write_super_blk(const SuperBlock& super_block)         {             //内存拷贝两个超级块             char* tmp_buf = new char[2 * sizeof(SuperBlock)];             memcpy(tmp_buf, &super_block, sizeof(SuperBlock));             memcpy(tmp_buf + sizeof(SuperBlock), &super_block, sizeof(SuperBlock));             int ret = file_op_->pwrite_file(tmp_buf, 2 * sizeof(SuperBlock), super_reserve_offset_);             tbsys::gDeleteA(tmp_buf);             if (ret)             {                 TBSYS_LOG(ERROR, "write super block error. ret: %d, desc: %s", ret, strerror(errno));                 return ret;             }             return TFS_SUCCESS; }

(3). 装载块文件

//加载块文件 int BlockFileManager::load_block_file() {             //construct logic block and corresponding physicblock list according to bitmap             PhysicalBlockMapIter pit;             bool conflict_flag = false;             PhysicalBlock* t_physical_block = NULL;             PhysicalBlock* ext_physical_block = NULL;             LogicBlock* t_logic_block = NULL;             int ret = TFS_SUCCESS;             //从pos=1开始做循环             for (uint32_t pos = 1; pos <= static_cast<uint32_t> (super_block_.main_block_count_); ++pos)             {                 //init every loop                 t_physical_block = NULL;                 t_logic_block = NULL;                 ext_physical_block = NULL;                 //如果在普通位图里面找到                 if (normal_bit_map_->test(pos))                 {                     t_physical_block = new PhysicalBlock(pos, super_block_.mount_point_, super_block_.main_block_size_,C_MAIN_BLOCK);                     //从块文件中读取物理块前缀                     ret = t_physical_block->load_block_prefix();                     if (TFS_SUCCESS != ret)                     {                         TBSYS_LOG(ERROR, "init physical block fail. fatal error! pos: %d, file: %s", pos, super_block_.mount_point_);                         break;                     }                     BlockPrefix block_prefix;                     t_physical_block->get_block_prefix(block_prefix);                     // not inited, error                     if (0 == block_prefix.logic_blockid_)                     {                         tbsys::gDelete(t_physical_block);                         TBSYS_LOG(ERROR, "block prefix illegal! logic blockid: %u, physical pos: %u.", block_prefix.logic_blockid_,                             pos);                         normal_bit_map_->reset(pos);                         super_block_impl_->write_bit_map(normal_bit_map_, error_bit_map_);                         continue;                     }                     //在生成逻辑块,并且打开/data/tfs1/index/逻辑块blockid映射文件                     t_logic_block = new LogicBlock(block_prefix.logic_blockid_, pos, super_block_.mount_point_);                     t_logic_block->add_physic_block(t_physical_block);                     //record physical block id                     uint32_t logic_block_id = block_prefix.logic_blockid_;                     TBSYS_LOG(                         DEBUG,                         "load logic block. per block size: %u, logic block id: %u, physic prev blockid: %u, physic next blockid: %u, physical blockid: %u.",                         super_block_.main_block_size_, logic_block_id, block_prefix.prev_physic_blockid_,                         block_prefix.next_physic_blockid_, pos);                       //先判断是否已经在physcial_blocks_中了                     pit = physcial_blocks_.find(pos);                     if (pit != physcial_blocks_.end())                     {                         ret = EXIT_PHYSIC_UNEXPECT_FOUND_ERROR;                         TBSYS_LOG(ERROR, "logic blockid: %u, physical blockid: %u is repetitive. fatal error! ret: %d",                             logic_block_id, pos, EXIT_PHYSIC_UNEXPECT_FOUND_ERROR);                         break;                     }                     LogicBlockMapIter mit = logic_blocks_.find(logic_block_id);                     if (mit != logic_blocks_.end())                     {                         TBSYS_LOG(INFO, "logic blockid: %u, map blockid: %u already exist", logic_block_id, mit->first);                         mit = compact_logic_blocks_.find(logic_block_id);                         if (mit != compact_logic_blocks_.end())                         {                             TBSYS_LOG(INFO, "logic blockid: %u already exist in compact block map", logic_block_id);                             ret = del_block(logic_block_id, C_COMPACT_BLOCK);                             if (TFS_SUCCESS != ret)                             {                                 break;                             }                         }                         compact_logic_blocks_.insert(LogicBlockMap::value_type(logic_block_id, t_logic_block));                     }                     else                     {                         //将逻辑块号,逻辑块对象指针插入到logic_blocks_这个map中                         logic_blocks_.insert(LogicBlockMap::value_type(logic_block_id, t_logic_block));                     }                     //将位置,物理块指针插入到physcial_blocks_这个map中                     physcial_blocks_.insert(PhysicalBlockMap::value_type(pos, t_physical_block));                     uint32_t ext_pos = pos;                     //在加入扩展逻辑块                     while (0 != block_prefix.next_physic_blockid_)                     {                         ext_physical_block = NULL;                         //将物理块位置设置为前一个块id                         uint32_t prev_block_id = ext_pos;                         //把扩展块位置赋值为下一个物理块设置                         ext_pos = block_prefix.next_physic_blockid_;                         //bitmap is not set                         //program exit                         if (!normal_bit_map_->test(ext_pos))                         {                             TBSYS_LOG(ERROR, "ext next physicblock and bitmap conflicted! logic blockid: %u, physical blockid: %u.",                                 logic_block_id, ext_pos);                             ret = EXIT_BLOCKID_CONFLICT_ERROR;                             break;                         }                         //新生成扩展物理块                         PhysicalBlock* ext_physical_block = new PhysicalBlock(ext_pos, super_block_.mount_point_,super_block_.extend_block_size_, C_EXT_BLOCK);                         ret = ext_physical_block->load_block_prefix();                         if (TFS_SUCCESS != ret)                         {                             TBSYS_LOG(ERROR, "init physical block fail. fatal error! pos: %u, mount point: %s", pos,                                 super_block_.mount_point_);                             break;                         }                         memset(&block_prefix, 0, sizeof(BlockPrefix));                         ext_physical_block->get_block_prefix(block_prefix);                         if (prev_block_id != block_prefix.prev_physic_blockid_)                         {                             TBSYS_LOG(ERROR, "read prev blockid conflict! prev blockid: %u. block prefix's physic prev blockid: %u",                                 prev_block_id, block_prefix.prev_physic_blockid_);                             //release                             normal_bit_map_->reset(pos);                             super_block_impl_->write_bit_map(normal_bit_map_, error_bit_map_);                             conflict_flag = true;                             break;                         }                           TBSYS_LOG(                             DEBUG,                             "read blockprefix! ext physical blockid pos: %u. prev blockid: %u. blockprefix's physic prev blockid: %u, next physic blockid: %u, logic blockid :%u",                             ext_pos, prev_block_id, block_prefix.prev_physic_blockid_, block_prefix.next_physic_blockid_,                             block_prefix.logic_blockid_);                         pit = physcial_blocks_.find(ext_pos);                         if (pit != physcial_blocks_.end())                         {                             ret = EXIT_PHYSIC_UNEXPECT_FOUND_ERROR;                             TBSYS_LOG(ERROR, "logic blockid: %u, physical blockid: %u is repetitive. fatal error!", logic_block_id,                                 ext_pos);                             break;                         }                         //同样将扩展物理块加入到逻辑块列表中                         t_logic_block->add_physic_block(ext_physical_block);                         physcial_blocks_.insert(PhysicalBlockMap::value_type(ext_pos, ext_physical_block));                     }                     if (TFS_SUCCESS != ret)                     {                         break;                     }                     if (conflict_flag)                     {                         TBSYS_LOG(ERROR, "delete load conflict block. logic blockid: %u", logic_block_id);                         del_block(logic_block_id, C_CONFUSE_BLOCK);                         continue;                     }                     //逻辑块加载块文件                     ret = t_logic_block->load_block_file(super_block_.hash_slot_size_, super_block_.mmap_option_);                     //if these error happened when load block, program should exit                     if (TFS_SUCCESS != ret && EXIT_COMPACT_BLOCK_ERROR != ret && EXIT_BLOCKID_ZERO_ERROR != ret)                     {                         TBSYS_LOG(ERROR, "logicblock load error! logic blockid: %u. ret: %d", logic_block_id, ret);                         break;                     }                     else if (TFS_SUCCESS != ret) // ret == EXIT_COMPACT_BLOCK_ERROR || ret == EXIT_BLOCKID_ZERO_ERROR                     {                         //roll back                         //can not make sure the type of this block, so add to confuse type                         del_block(logic_block_id, C_CONFUSE_BLOCK);                         ret = TFS_SUCCESS;                     }                 }                 conflict_flag = false;             }               if (TFS_SUCCESS != ret)             {                 tbsys::gDelete(t_physical_block);                 tbsys::gDelete(t_logic_block);                 tbsys::gDelete(ext_physical_block);             }             return ret; }

（4）.涉及到的IndexHandle类的方法:

IndexHandle::IndexHandle(const std::string& base_path, const uint32_t main_block_id) {             //create file_op handle             std::stringstream tmp_stream;             //tmp_stream=/data/tfs1/index/物理块blockid             tmp_stream << base_path << INDEX_DIR_PREFIX << main_block_id;             std::string index_path;             tmp_stream >> index_path;             //创建一个映射到文件的指针             file_op_ = new MMapFileOperation(index_path, O_RDWR | O_LARGEFILE | O_CREAT);             is_load_ = false; }

//创建索引,并且映射到文件中         //在t_logic_block->init_block_file()里被调用         int IndexHandle::create(const uint32_t logic_block_id, const int32_t cfg_bucket_size, const MMapOption map_option,             const DirtyFlag dirty_flag)         {             TBSYS_LOG(                 DEBUG,                 "index create block: %u index. bucket size: %d, max mmap size: %d, first mmap size: %d, per mmap size: %d, dirty flag: %d",                 logic_block_id, cfg_bucket_size, map_option.max_mmap_size_, map_option.first_mmap_size_,                 map_option.per_mmap_size_, dirty_flag);             if (is_load_)             {                 return EXIT_INDEX_ALREADY_LOADED_ERROR;             }             int ret = TFS_SUCCESS;             int64_t file_size = file_op_->get_file_size();             if (file_size < 0)             {                 return TFS_ERROR;             }             else if (file_size == 0) // empty file             {                 IndexHeader i_header;                 i_header.block_info_.block_id_ = logic_block_id;                 i_header.block_info_.seq_no_ = 1;                 //cfg_bucket_size: 每个Block中hash槽(桶)的个数                 i_header.index_file_size_ = sizeof(IndexHeader) + cfg_bucket_size * sizeof(int32_t);                 i_header.bucket_size_ = cfg_bucket_size;                 i_header.flag_ = dirty_flag;                 // index header + total buckets 索引头结构+总的桶尺寸大小                 char* init_data = new char[i_header.index_file_size_];                 memcpy(init_data, &i_header, sizeof(IndexHeader));                 memset(init_data + sizeof(IndexHeader), 0, i_header.index_file_size_ - sizeof(IndexHeader));                 //写入索引头结构以及桶结构数组到文件,这个时候还并没有映射到文件,因此是直接写文件                 ret = file_op_->pwrite_file(init_data, i_header.index_file_size_, 0);                 delete[] init_data;                 init_data = NULL;                 if (TFS_SUCCESS != ret)                     return ret;             }             else //file size > 0, index already exist             {                 return EXIT_INDEX_UNEXPECT_EXIST_ERROR;             }             //在进行映射文件操作             ret = file_op_->mmap_file(map_option);             if (TFS_SUCCESS != ret) //mmap fail                 return ret;               is_load_ = true;             TBSYS_LOG(                 INFO,                 "init blockid: %u index successful. data file size: %d, index file size: %d, bucket size: %d, free head offset: %d, seqno: %d, size: %d, filecount: %d, del_size: %d, del_file_count: %d version: %d",                 logic_block_id, index_header()->data_file_offset_, index_header()->index_file_size_,                 index_header()->bucket_size_, index_header()->free_head_offset_, block_info()->seq_no_, block_info()->size_,                 block_info()->file_count_, block_info()->del_size_, block_info()->del_file_count_, block_info()->version_);             return TFS_SUCCESS; }

int IndexHandle::load(const uint32_t logic_block_id, const int32_t cfg_bucket_size, const MMapOption map_option)         {             if (is_load_)             {                 return EXIT_INDEX_ALREADY_LOADED_ERROR;             }             int ret = TFS_SUCCESS;             int file_size = file_op_->get_file_size();             if (file_size < 0)             {                 return file_size;             }             else if (file_size == 0) // empty file             {                 return EXIT_INDEX_EMPTY_ERROR;             }             //重新设置内存映射文件大小             MMapOption tmp_map_option = map_option;             if (file_size > tmp_map_option.first_mmap_size_ && file_size <= tmp_map_option.max_mmap_size_)             {                 tmp_map_option.first_mmap_size_ = file_size;             }             //进行内存文件映射             ret = file_op_->mmap_file(tmp_map_option);             if (TFS_SUCCESS != ret)                 return ret;             //从内存映射文件中取值,比较桶大小             if (cfg_bucket_size != bucket_size())             {                 TBSYS_LOG(ERROR, "Index configure error. old bucket size: %u, new bucket size: %d", bucket_size(),                     cfg_bucket_size);                 return EXIT_BUCKET_CONFIGURE_ERROR;             }             // check block_id             if (logic_block_id != block_info()->block_id_)             {                 TBSYS_LOG(ERROR, "block id conflict. blockid: %d, index blockid: %d", logic_block_id, block_info()->block_id_);                 return EXIT_BLOCKID_CONFLICT_ERROR;             }             // check flag             if (C_DATA_COMPACT == index_header()->flag_)             {                 //unfinish compact block                 TBSYS_LOG(ERROR, "It is a unfinish compact block. blockid: %d", logic_block_id);                 return EXIT_COMPACT_BLOCK_ERROR;             }             if (C_DATA_CLEAN == index_header()->flag_)             {                 //do nothing             }             is_load_ = true;             TBSYS_LOG(                 INFO,                 "load blockid: %u index successful. data file offset: %d, index file size: %d, bucket size: %d, free head offset: %d, seqno: %d, size: %d, filecount: %d, del size: %d, del file count: %d version: %d",                 logic_block_id, index_header()->data_file_offset_, index_header()->index_file_size_, bucket_size(),                 index_header()->free_head_offset_, block_info()->seq_no_, block_info()->size_, block_info()->file_count_,                 block_info()->del_size_, block_info()->del_file_count_, block_info()->version_);             return TFS_SUCCESS; }

//生成文件内部id号(key值)         int IndexHandle::find_avail_key(uint64_t& key)         {             if (0 == key)             {                 key = block_info()->seq_no_;             } // continue test               int32_t offset = 0, slot = 0;             int ret = TFS_SUCCESS;             MetaInfo meta_info;             int retry_times = MAX_RETRY_TIMES;             bool found = false;             do             {                 slot = static_cast<uint32_t> (key) % bucket_size();                 //首先找到第一个元文件结点                 offset = bucket_slot()[slot];                 //如果是,说明还没有该桶的第一个元文件存在,直接返回,key值取: key = block_info()->seq_no_                 if (0 == offset)                 {                     found = true;                     break;                 }                 //从桶列表里面去查找                 for (; offset != 0;)                 {                     ret = file_op_->pread_file(reinterpret_cast<char*> (&meta_info), META_INFO_SIZE, offset);                     if (TFS_SUCCESS != ret)                         return ret;                     // 如果发现有相同的key值,那么++key,退出循环,否则找下一个元数据文件                     if (static_cast<uint32_t> (key) == static_cast<uint32_t> (meta_info.get_key()))                     {                         ++key;                         break;                     }                     offset = meta_info.get_next_meta_offset();                 }                 if (0 == offset)                 {                     found = true;                     break;                 }             }             while (retry_times--);             //更新seq_no_值,给下一个桶生成key做准备             block_info()->seq_no_ = key + 1;             if (!found)             {                 TBSYS_LOG(ERROR, "blockid: %u, find avail key fail. new key: %" PRI64_PREFIX "u", block_info()->block_id_, key);                 return EXIT_CREATE_FILEID_ERROR;             }             TBSYS_LOG(DEBUG, "blockid: %u, get key: %" PRI64_PREFIX "u, seqno: %u", block_info()->block_id_, key,                 block_info()->seq_no_);             return TFS_SUCCESS; }

//将元数据写入段 int IndexHandle::write_segment_meta(const uint64_t key, const RawMeta& meta) {             int32_t current_offset = 0, previous_offset = 0;             int ret = hash_find(key, current_offset, previous_offset);             if (TFS_SUCCESS == ret) // check not exists             {                 return EXIT_META_UNEXPECT_FOUND_ERROR;             }             else if (EXIT_META_NOT_FOUND_ERROR != ret)             {                 return ret;             }             //查找不到,哈希插入操作             int32_t slot = static_cast<uint32_t> (key) % bucket_size();             return hash_insert(slot, previous_offset, meta); }

//参数:内部文件id号 int IndexHandle::read_segment_meta(const uint64_t key, RawMeta& meta)         {             //find             int32_t current_offset = 0, previous_offset = 0;             int ret = hash_find(key, current_offset, previous_offset);             if (TFS_SUCCESS == ret) //exist             {                 //如果查找成功,从当前偏移量开始读取                 ret = file_op_->pread_file(reinterpret_cast<char*> (&meta), RAW_META_SIZE, current_offset);                 if (TFS_SUCCESS != ret)                     return ret;             }             else             {                 return ret;             }               return TFS_SUCCESS; }

//在块中查找内部文件号key int IndexHandle::hash_find(const uint64_t key, int32_t& current_offset, int32_t& previous_offset)         {             //首先确定槽             int32_t slot = static_cast<uint32_t> (key) % bucket_size(); //取余数             previous_offset = 0;             MetaInfo meta_info;             int ret = TFS_SUCCESS;             //首先查询桶列表数组,初始写入文件时全是,因此需要在此判断不为             for (int32_t pos = bucket_slot()[slot]; pos != 0;)             {                 ret = file_op_->pread_file(reinterpret_cast<char*> (&meta_info), META_INFO_SIZE, pos);                 if (TFS_SUCCESS != ret)                     return ret;                 if (hash_compare(key, meta_info.get_key()))                 {                     current_offset = pos;                     return TFS_SUCCESS;                 }                 previous_offset = pos;                 //取下一偏移量位置                 pos = meta_info.get_next_meta_offset();             }             return EXIT_META_NOT_FOUND_ERROR; }

//插入元数据到桶的链表尾部         //索引文件的格式: IndexHeader(头结构)+桶的偏移数组(记录桶中第一个元素的地址)+实际的元数据结构偏移量         int IndexHandle::hash_insert(const int32_t slot, const int32_t previous_offset, const RawMeta& meta)         {             int ret = TFS_SUCCESS;             MetaInfo tmp_meta_info;             int32_t current_offset = 0;             //插入操作时首先取空闲的index_header()->free_head_offset_             if (0 != index_header()->free_head_offset_)             {                 ret = file_op_->pread_file(reinterpret_cast<char*> (&tmp_meta_info), META_INFO_SIZE,index_header()->free_head_offset_);                 if (TFS_SUCCESS != ret)                     return ret;                 //得到这个空闲的偏移量位置                 current_offset = index_header()->free_head_offset_;                 //得到下一个空闲元素的位置作为空闲头部偏移量                 //只是占用写入已经被释放元数据的位置,跟key值映射到相同的桶里面没有关系,桶链表还是                 //具有相同桶值的链表                 index_header()->free_head_offset_ = tmp_meta_info.get_next_meta_offset();             }             else             {                 //初始插入时free_head_offset_=0                 current_offset = index_header()->index_file_size_;                 index_header()->index_file_size_ += META_INFO_SIZE;             }             MetaInfo meta_info(meta);             ret = file_op_->pwrite_file(reinterpret_cast<const char*> (&meta_info), META_INFO_SIZE, current_offset);             if (TFS_SUCCESS != ret)                 return ret;             //构造current_offset,previous_offset形成这样的关系,元数据构成偏移量的这种关系             if (0 != previous_offset)             {                 //先读出前面的元素,修改它的next_meta_offset_属性,指向当前元素,在保存                 ret = file_op_->pread_file(reinterpret_cast<char*> (&tmp_meta_info), META_INFO_SIZE, previous_offset);                 if (TFS_SUCCESS != ret)                     return ret;                 tmp_meta_info.set_next_meta_offset(current_offset);                 ret = file_op_->pwrite_file(reinterpret_cast<const char*> (&tmp_meta_info), META_INFO_SIZE, previous_offset);                 if (TFS_SUCCESS != ret)                     return ret;             }             else             {                 //如果是桶的第一个元素,previous_offset=0时,那么将当前偏移量直接赋值给桶的第一个元素                 bucket_slot()[slot] = current_offset;             }             return TFS_SUCCESS; }

//删除指定key值的索引         int IndexHandle::delete_segment_meta(const uint64_t key)         {             //首先定位key值的current_offset,previous_offset             int32_t current_offset = 0, previous_offset = 0;             int ret = hash_find(key, current_offset, previous_offset);             if (TFS_SUCCESS != ret)                 return ret;             //通过current_offset在索引文件中取出meta_info             MetaInfo meta_info;             ret = file_op_->pread_file(reinterpret_cast<char*> (&meta_info), META_INFO_SIZE, current_offset);             if (TFS_SUCCESS != ret)                 return ret;             //得到该值的下一个元数据的位置偏移量             int32_t tmp_pos = meta_info.get_next_meta_offset();             int32_t slot = static_cast<uint32_t> (key) % bucket_size();             //相当于对链表进行删除结点的操作             if (0 == previous_offset)             {                 //如果是首节点,那么指向该节点的下一个结点                 bucket_slot()[slot] = tmp_pos;             }             else             {                 //否者更新前一个结点的next_meta_offset,指向删除结点的下一个结点的位置                 MetaInfo pre_meta_info;                 ret = file_op_->pread_file(reinterpret_cast<char*> (&pre_meta_info), META_INFO_SIZE, previous_offset);                 if (TFS_SUCCESS != ret)                     return ret;                 pre_meta_info.set_next_meta_offset(tmp_pos);                 ret = file_op_->pwrite_file(reinterpret_cast<const char*> (&pre_meta_info), META_INFO_SIZE, previous_offset);                 if (TFS_SUCCESS != ret)                     return ret;             }             //并不是删除该节点,而是设置下一个结点是index_header()->free_head_offset_             meta_info.set_next_meta_offset(index_header()->free_head_offset_);             ret = file_op_->pwrite_file(reinterpret_cast<const char*> (&meta_info), META_INFO_SIZE, current_offset);             if (TFS_SUCCESS != ret)                 return ret;             //释放的头结点的偏移指向current_offset             //可以看出,这里形成了一个构造删除结点的链表             index_header()->free_head_offset_ = current_offset;             return TFS_SUCCESS; }