TFS文件系统写文件分析

TFS文件系统写入文件分析

对TFS文件系统的写入文件的关键代码做下分析.

(1). 写文件消息包函数

int DataManagement::write_data(const WriteDataInfo& write_info, const int32_t lease_id, int32_t& version,

            const char* data_buffer, UpdateBlockType& repair)

        {

            TBSYS_LOG(DEBUG,

                "write data. blockid: %u, fileid: %" PRI64_PREFIX "u, filenumber: %" PRI64_PREFIX "u, lease: %d",

                write_info.block_id_, write_info.file_id_, write_info.file_number_, lease_id);

            //if the first fragment, check version

            if (0 == write_info.offset_)

            {

                //如果是初始,首先获得逻辑块

                LogicBlock* logic_block = BlockFileManager::get_instance()->get_logic_block(write_info.block_id_);

                if (NULL == logic_block)

                {

                    TBSYS_LOG(ERROR, "blockid: %u is not exist.", write_info.block_id_);

                    return EXIT_NO_LOGICBLOCK_ERROR;

                }

                int ret = logic_block->check_block_version(version, repair);

                if (TFS_SUCCESS != ret)

                {

                    TBSYS_LOG(DEBUG, "check_block_version error. blockid: %u, ret: %d", write_info.block_id_, ret);

                    return ret;

                }

            }

            //通过文件号从data_file_map_中进行查找

            data_file_mutex_.lock();

            DataFileMapIter bit = data_file_map_.find(write_info.file_number_);

            DataFile* datafile = NULL;

            if (bit != data_file_map_.end())

            {

                datafile = bit->second;

            }

            else

            {

                //control datafile size

                if (data_file_map_.size() >= static_cast<uint32_t> (SYSPARAM_DATASERVER.max_datafile_nums_))

                {

                    TBSYS_LOG(ERROR, "blockid: %u, datafile nums: %u is large than default.", write_info.block_id_,data_file_map_.size());

                    data_file_mutex_.unlock();

                    return EXIT_DATAFILE_OVERLOAD;

                }

                //找不到的话,插入到data_file_map_中

                datafile = new DataFile(write_info.file_number_);

                data_file_map_.insert(DataFileMap::value_type(write_info.file_number_, datafile));

            }

            if (NULL == datafile)

            {

                TBSYS_LOG(ERROR, "datafile is null. blockid: %u, fileid: %" PRI64_PREFIX "u, filenumber: %" PRI64_PREFIX "u",

                    write_info.block_id_, write_info.file_id_, write_info.file_number_);

                data_file_mutex_.unlock();

                return EXIT_DATA_FILE_ERROR;

            }

            //设置数据文件最后更新时间

            datafile->set_last_update();

            data_file_mutex_.unlock();

            //写入到数据文件中,参数:写入的数据长度,偏移量

            int32_t write_len = datafile->set_data(data_buffer, write_info.length_, write_info.offset_);

            if (write_len != write_info.length_)

            {

                TBSYS_LOG(

                    ERROR,

                    "Datafile write error. blockid: %u, fileid: %" PRI64_PREFIX "u, filenumber: %" PRI64_PREFIX "u, req writelen: %d, actual writelen: %d",

                    write_info.block_id_, write_info.file_id_, write_info.file_number_, write_info.length_, write_len);

                erase_data_file(write_info.file_number_);

                return EXIT_DATA_FILE_ERROR;

            }

            return TFS_SUCCESS;

}

当将文件分消息包写入时,具体的过程是写入一个临时文件中:

int DataFile::set_data(const char *data, const int32_t len, const int32_t offset)

        {

            if (len <= 0)

            {

                return TFS_SUCCESS;

            }

            //相当于累计写入的字节数

            int32_t length = offset + len;

            //WRITE_DATA_TMPBUF_SIZE=2M,以这个大小作为写入文件的缓冲区

            if (length > WRITE_DATA_TMPBUF_SIZE) // write to file if length is large then max_read_size

            {

                if (fd_ == -1)

                {

                    fd_ = open(tmp_file_name_, O_RDWR | O_CREAT | O_TRUNC, 0600);

                    if (fd_ == -1)

                    {

                        TBSYS_LOG(ERROR, "open file fail: %s, %s", tmp_file_name_, strerror(errno));

                        return TFS_ERROR;

                    }

                    //先将之前的内容写完

                    if (write(fd_, data_, length_) != length_)

                    {

                        TBSYS_LOG(ERROR, "write file fail: %s, length_: %d, error:%s", tmp_file_name_, length_, strerror(errno));

                        return TFS_ERROR;

                    }

                }

                if (lseek(fd_, offset, SEEK_SET) == -1)

                {

                    TBSYS_LOG(ERROR, "lseek file fail: %s, offset: %d", tmp_file_name_, offset);

                    return TFS_ERROR;

                }

                if (write(fd_, data, len) != len)

                {

                    TBSYS_LOG(ERROR, "write file fail: %s, len: %d", tmp_file_name_, len);

                    return TFS_ERROR;

                }

            }

            else

            {

                memcpy(data_ + offset, data, len);

            }

            // 记录前一次写入的长度

            if (length > length_)

            {

                length_ = length;

            }

            return len;

}

(2).写文件消息包完毕后,在执行关闭写操作,这个时候文件才实际从临时文件写入到数据块中

//写文件完毕后关闭操作

int DataManagement::close_write_file(const CloseFileInfo& closefileInfo, int32_t& write_file_size)

        {

            uint32_t block_id = closefileInfo.block_id_;

            uint64_t file_id = closefileInfo.file_id_;

            uint64_t file_number = closefileInfo.file_number_;

            uint32_t crc = closefileInfo.crc_;

            TBSYS_LOG(DEBUG,

                "close write file, blockid: %u, fileid: %" PRI64_PREFIX "u, filenumber: %" PRI64_PREFIX "u, crc: %u",

                block_id, file_id, file_number, crc);

            //find datafile

            DataFile* datafile = NULL;

            data_file_mutex_.lock();

            DataFileMapIter bit = data_file_map_.find(file_number);

            if (bit != data_file_map_.end())

            {

                datafile = bit->second;

            }

            //lease expire

            if (NULL == datafile)

            {

                TBSYS_LOG(ERROR, "Datafile is null. blockid: %u, fileid: %" PRI64_PREFIX "u, filenumber: %" PRI64_PREFIX "u",

                    block_id, file_id, file_number);

                data_file_mutex_.unlock();

                return EXIT_DATAFILE_EXPIRE_ERROR;

            }

            datafile->set_last_update();

            datafile->add_ref();

            data_file_mutex_.unlock();

            //比较循环校验码

            uint32_t datafile_crc = datafile->get_crc();

            if (crc != datafile_crc)

            {

                TBSYS_LOG(

                    ERROR,

                    "Datafile crc error. blockid: %u, fileid: %" PRI64_PREFIX "u, filenumber: %" PRI64_PREFIX "u, local crc: %u, msg crc: %u",

                    block_id, file_id, file_number, datafile_crc, crc);

                datafile->sub_ref();

                erase_data_file(file_number);

                return EXIT_DATA_FILE_ERROR;

            }

            write_file_size = datafile->get_length();

            //先查找逻辑块

            LogicBlock* logic_block = BlockFileManager::get_instance()->get_logic_block(block_id);

            if (NULL == logic_block)

            {

                datafile->sub_ref();

                erase_data_file(file_number);

                TBSYS_LOG(ERROR, "blockid: %u is not exist.", block_id);

                return EXIT_NO_LOGICBLOCK_ERROR;

            }

            int64_t time_start = tbsys::CTimeUtil::getTime();

            //逻辑块关闭写文件

            int ret = logic_block->close_write_file(file_id, datafile, datafile_crc);

            if (TFS_SUCCESS != ret)

            {

                datafile->sub_ref();

                erase_data_file(file_number);

                return ret;

            }

 

            int64_t time_end = tbsys::CTimeUtil::getTime();

            //记录写超时日志

            if (time_end - time_start > SYSPARAM_DATASERVER.max_io_warn_time_)

            {

                TBSYS_LOG(WARN, "write file cost time: blockid: %u, fileid: %" PRI64_PREFIX "u, cost time: %" PRI64_PREFIX "d",

                    block_id, file_id, time_end - time_start);

            }

            // success, gc datafile

            // close tmp file, release opened file handle

            // datafile , bit->second point to same thing, once delete

            // bit->second, datafile will be obseleted immediately.

            // 删除文件号对应的迭代器,删除临时文件

            datafile->sub_ref();

            erase_data_file(file_number);

            return TFS_SUCCESS;

}

(3). 逻辑块关闭写文件

//逻辑块关闭写文件操作

        int LogicBlock::close_write_file(const uint64_t inner_file_id, DataFile* datafile, const uint32_t crc)

        {

            ScopedRWLock scoped_lock(rw_lock_, WRITE_LOCKER);

            RawMeta file_meta;

            //首先根据文件号判断是否已经写入

            int ret = index_handle_->read_segment_meta(inner_file_id, file_meta);

            if (TFS_SUCCESS == ret)

            {

                TBSYS_LOG(INFO, "file exist, update! blockid: %u, fileid: %" PRI64_PREFIX "u", logic_block_id_, inner_file_id);

            }

            RawMeta bak_file_meta(file_meta);

            //获得要写入的文件长度

            int32_t file_size = datafile->get_length();

            FileInfo tfs_file_info, old_file_info;

            tfs_file_info.id_ = inner_file_id;

            tfs_file_info.size_ = file_size + sizeof(FileInfo);

            tfs_file_info.flag_ = 0;

            tfs_file_info.modify_time_ = time(NULL);

            tfs_file_info.create_time_ = time(NULL);

            tfs_file_info.crc_ = crc;

            bool need_update_meta = true, commit_offset = true;

            //commit

            OperType oper_type = C_OPER_UPDATE;

            int32_t old_size = 0, block_offset = 0;

            //如果是第一次写文件,显然不满足条件,index_handle_->read_segment_meta(inner_file_id, file_meta)取不到值的

            //第二次对同一文件作修改操作,index_handle_->read_segment_meta(inner_file_id, file_meta)就能取到值

            if (file_meta.get_file_id() == inner_file_id)

            {

                TBSYS_LOG(INFO, "write file. fileid equal. blockid: %u, fileid: %" PRI64_PREFIX "u", logic_block_id_,

                    inner_file_id);

                //取得旧文件的FileInfo old_file_info信息

                ret = data_handle_->read_segment_info(&old_file_info, file_meta.get_offset());

                if (TFS_SUCCESS != ret)

                {

                    TBSYS_LOG(ERROR, "read FileInfo fail, blockid: %u, fileid: %" PRI64_PREFIX "u, ret: %d", logic_block_id_,

                        inner_file_id, ret);

                }

                else //read successful

                {

                    //获得旧文件的创建时间来作为重新写入文件的创建时间

                    tfs_file_info.create_time_ = old_file_info.create_time_;

                    //获得重新写入文件需要写入的尺寸

                    int32_t require_size = file_size + sizeof(FileInfo);

                    if (require_size > old_file_info.usize_)

                    {

                        old_size = old_file_info.usize_;

                        //如果新尺寸大于旧文件的尺寸,那么重新写入的文件在索引文件偏移量设置为最后,追加写入

                        block_offset = index_handle_->get_block_data_offset();

                        TBSYS_LOG(

                            INFO,

                            "update file. require size: %d > origin size: %d. need reallocate, blockid: %u, fileid: %" PRI64_PREFIX "u, offset: %d",

                            require_size, old_size, logic_block_id_, inner_file_id, block_offset);

                        tfs_file_info.offset_ = block_offset;

                        tfs_file_info.usize_ = require_size;

                        file_meta.set_offset(block_offset); //偏移量设置在索引中追加最后写入

                    }

                    else

                    {

                        commit_offset = false;  //索引文件的偏移量不必更新

                        //如果小于旧文件的尺寸,重新写入文件的偏移量沿用旧文件的偏移量

                        tfs_file_info.offset_ = file_meta.get_offset();

                        tfs_file_info.usize_ = old_file_info.usize_;

                    }

                    //modify meta size

                    file_meta.set_size(require_size);

                    index_handle_->update_segment_meta(file_meta.get_key(), file_meta);

                }

            }

            //写入第一个文件是oper_type = C_OPER_INSERT

            //更新文件是两者是相等的

            if (file_meta.get_file_id() != inner_file_id || ret)

            {

                need_update_meta = false;

                oper_type = C_OPER_INSERT;

                old_size = 0;

                tfs_file_info.usize_ = file_size + sizeof(FileInfo);

                //得到索引块的偏移量:初始新增文件时块偏移位置是

                block_offset = index_handle_->get_block_data_offset();

                tfs_file_info.offset_ = block_offset;

                file_meta.set_key(inner_file_id);

                file_meta.set_size(file_size + sizeof(FileInfo));

                file_meta.set_offset(block_offset);

                //索引文件中写入元数据

                ret = index_handle_->write_segment_meta(file_meta.get_key(), file_meta);

                if (TFS_SUCCESS != ret)

                {

                    return ret;

                }

            }

            char* tmp_data_buffer = NULL;

            int32_t read_len = 0, read_offset = 0;

            int32_t write_len = 0, write_offset = 0;

            do

            {

                //参数:源文件大小+sizeof(FileInfo),在块中的偏移量

                //块的组织形式: 物理主块+多个物理扩展块

                //从而形成块前缀的这种关系:

                //uint32_t logic_blockid_;        //逻辑块id

                //uint32_t prev_physic_blockid_;  //前一个物理块id

                //uint32_t next_physic_blockid_;  //后一个物理块id

                ret = extend_block(file_meta.get_size(), file_meta.get_offset());

                if (TFS_SUCCESS != ret)

                    break;

                //从临时数据文件读取数据

                while ((tmp_data_buffer = datafile->get_data(NULL, &read_len, read_offset)) != NULL)

                {

                    if (read_len < 0 || (read_len + read_offset) > file_size)

                    {

                        TBSYS_LOG(ERROR, "getdata fail, blockid: %u, fileid: %" PRI64_PREFIX "u, size: %d, offset: %d, rlen: %d",

                            logic_block_id_, inner_file_id, file_size, read_offset, read_len);

                        ret = TFS_ERROR;

                        break;

                    }

                    if (0 == read_len)

                    {

                        break;

                    }

                    write_len = read_len;

                    if (0 == read_offset)

                    {

                        write_len += sizeof(FileInfo);

                    }

                    if (write_offset + write_len > file_meta.get_size())

                    {

                        ret = EXIT_WRITE_OFFSET_ERROR;

                        break;

                    }

                    //先写FileInfo结构信息

                    //file_meta.get_offset():第一次写入为，第二次写入值是第一次的file_size + sizeof(FileInfo),

                    //第三次写入又是累计第一次+第二次的值作为偏移量

                    if (0 == read_offset)

                    {

                        char* tmp_write_buffer = new char[write_len];

                        memcpy(tmp_write_buffer, &tfs_file_info, sizeof(FileInfo));

                        memcpy(tmp_write_buffer + sizeof(FileInfo), tmp_data_buffer, read_len);

                        ret = data_handle_->write_segment_data(tmp_write_buffer, write_len, file_meta.get_offset() + write_offset);

                        delete[] tmp_write_buffer;

                    }

                    else

                    {

                        //在写实际的数据文件

                        ret = data_handle_->write_segment_data(tmp_data_buffer, write_len, file_meta.get_offset() + write_offset);

                    }

                    //check ret(if disk error)

                    if (TFS_SUCCESS != ret)

                    {

                        TBSYS_LOG(

                            ERROR,

                            "blockid: %u write data error, fileid: %" PRI64_PREFIX "u, size: %d offset: %d, rlen: %d, oldsize: %d, ret: %d",

                            logic_block_id_, inner_file_id, file_size, read_offset, read_len, old_size, ret);

                        break;

                    }

                    read_offset += read_len;

                    write_offset += write_len;

                }

                if (TFS_SUCCESS != ret)

                    break;

                if (oper_type == C_OPER_INSERT)

                {

                    ret = index_handle_->update_block_info(C_OPER_INSERT, file_meta.get_size());

                    if (TFS_SUCCESS != ret)

                        break;

                }

                else if (oper_type == C_OPER_UPDATE)

                {

                    //如果是重新写入文件,那么就是先做一个删除的操作,在做一个更新的操作

                    //(1).如果重新写入的文件比之前的旧文件要小,那么将在旧文件哪里重新写;

                    //(2).如果重新写入的文件比之前的旧文件要小,那么将在物理块后面追加重新写;

                    // 但是在索引文件里面,设置的偏移量,尺寸已经变为新文件写入的信息了,因此查找时也是找到的重新写过的新文件

                    if (0 != old_size)

                    {

                        ret = index_handle_->update_block_info(C_OPER_DELETE, old_size);

                        if (TFS_SUCCESS != ret)

                            break;

                        ret = index_handle_->update_block_info(C_OPER_UPDATE, file_meta.get_size());

                        if (TFS_SUCCESS != ret)

                            break;

                    }

                    else

                    {

                        ret = index_handle_->update_block_info(C_OPER_UPDATE, 0);

                        if (TFS_SUCCESS != ret)

                            break;

                    }

                }

            }

            while (0);

            TBSYS_LOG(DEBUG, "close write file, blockid: %u, fileid: %" PRI64_PREFIX "u, ret: %d", logic_block_id_,

                inner_file_id, ret);

            if (TFS_SUCCESS != ret) //error occur

            {

                if (need_update_meta)

                {

                    //rollback

                    index_handle_->update_segment_meta(bak_file_meta.get_key(), bak_file_meta);

                }

            }

            else

            {

                if (commit_offset)

                {

                    //块数据的偏移量:第一次写入文件为,第二次作为元数据file_meta.set_offset(block_offset)的起始偏移

                    //第三时是累计第一次+第二次的值作为偏移量,次以此类推

                    index_handle_->commit_block_data_offset(file_size + sizeof(FileInfo));

                }

            }

            //flush index

            index_handle_->flush();

            return ret;

}

(4).在TFS中数据块的组织形式是: 一个物理主块+多个物理扩展块

//扩展块

        int LogicBlock::extend_block(const int32_t size, const int32_t offset)

        {

            int32_t retry_times = MAX_EXTEND_TIMES;

            //extend retry_times extend block in one call

            while (retry_times)

            {

                //如果超过了avail_data_size_,新生成扩展块

                if (offset + size > avail_data_size_) //need extend block

                {

                    TBSYS_LOG(INFO,

                        "blockid: %u need ext block. offset: %d, datalen: %d, availsize: %d, data curr offset: %d, retry: %d",

                        logic_block_id_, offset, size, avail_data_size_, index_handle_->get_block_data_offset(), retry_times);

 

                    uint32_t physical_ext_blockid = 0;

                    uint32_t physical_blockid = 0;

                    // get the last prev block id of this logic block

                    std::list<PhysicalBlock*>* physcial_blk_list = &physical_block_list_;

                    if (0 == physcial_blk_list->size())

                    {

                        TBSYS_LOG(ERROR, "blockid: %u physical block list is empty!", logic_block_id_);

                        return EXIT_PHYSICALBLOCK_NUM_ERROR;

                    }

                    //可见是直接取的列表的最后一个元素,来形成这种块前缀的关系

                    physical_blockid = physcial_blk_list->back()->get_physic_block_id();

                    // new one ext block

                    PhysicalBlock* tmp_physic_block = NULL;

                    int ret = BlockFileManager::get_instance()->new_ext_block(logic_block_id_, physical_blockid,

                        physical_ext_blockid, &tmp_physic_block);

                    if (TFS_SUCCESS != ret)

                        return ret;

                    //然后又将新生成的插入physical_block_list_中去,这样新生成的就是最后一个元素了,

                    //再次进行扩展时就会取到它本身

                    physical_block_list_.push_back(tmp_physic_block);

                    avail_data_size_ += tmp_physic_block->get_total_data_len();

                }

                else

                {

                    break;

                }

                --retry_times;

            }

 

            if (0 == retry_times)

            {

                TBSYS_LOG(ERROR, "blockid: %u extend block too much!", logic_block_id_);

                return EXIT_PHYSICALBLOCK_NUM_ERROR;

            }

            return TFS_SUCCESS;

}

(5). 新生成扩展块

//新生成扩展块

        int BlockFileManager::new_ext_block(const uint32_t logic_block_id, const uint32_t physical_block_id,

            uint32_t& ext_physical_block_id, PhysicalBlock **physic_block)

        {

            ScopedRWLock scoped_lock(rw_lock_, WRITE_LOCKER);

            int ret = TFS_SUCCESS;

            BlockType block_type;

            if (0 != physical_block_id)

            {

                block_type = C_EXT_BLOCK;

            }

            else

            {

                return EXIT_NO_LOGICBLOCK_ERROR;

            }

 

            LogicBlockMapIter mit = logic_blocks_.find(logic_block_id);

            if (mit == logic_blocks_.end())

            {

                return EXIT_NO_LOGICBLOCK_ERROR;

            }

            //找到一个没有被占用的扩展块号

            ret = find_avail_block(ext_physical_block_id, block_type);

            if (TFS_SUCCESS != ret)

                return ret;

 

            PhysicalBlockMapIter pmit = physcial_blocks_.find(ext_physical_block_id);

            if (pmit != physcial_blocks_.end())

            {

                TBSYS_LOG(ERROR, "physical block conflict. fatal error! ext physical blockid: %u", ext_physical_block_id);

                assert(false);

            }

            //make sure physical_block_id is exist

            pmit = physcial_blocks_.find(physical_block_id);

            if (pmit == physcial_blocks_.end())

            {

                TBSYS_LOG(ERROR, "can not find physical blockid: %u", physical_block_id);

                assert(false);

            }

 

            if (NULL == pmit->second)

            {

                TBSYS_LOG(ERROR, "physical blockid: %u point null", physical_block_id);

                assert(false);

            }

            normal_bit_map_->set(ext_physical_block_id);

            PhysicalBlock* tmp_physical_block = new PhysicalBlock(ext_physical_block_id, super_block_.mount_point_,

                super_block_.extend_block_size_, C_EXT_BLOCK);

            //设置新生成的扩展块的块前缀:填写前一个物理块号

            tmp_physical_block->set_block_prefix(logic_block_id, physical_block_id, 0);

            TBSYS_LOG(INFO, "new ext block. logic blockid: %u, prev physical blockid: %u, now physical blockid: %u",

                logic_block_id, physical_block_id, ext_physical_block_id);

            do

            {

                //write physical block info to disk

                ret = tmp_physical_block->dump_block_prefix();

                if (TFS_SUCCESS != ret)

                    break;

                //取前面的物理块,设置块前缀:填写后一个物理块号

                //构造prev_physic_block,ext_physic_blockid_这种关系,在将block_prefix这种关系写入磁盘

                PhysicalBlock* prev_physic_block = pmit->second;

                prev_physic_block->set_next_block(ext_physical_block_id);

                //write prev block info to disk

                ret = prev_physic_block->dump_block_prefix();

                if (TFS_SUCCESS != ret)

                    break;

                ret = super_block_impl_->write_bit_map(normal_bit_map_, error_bit_map_);

                if (TFS_SUCCESS != ret)

                    break;

                //update superblock info

                ++super_block_.used_extend_block_count_;

                ret = super_block_impl_->write_super_blk(super_block_);

                if (TFS_SUCCESS != ret)

                    break;

                //sync to disk

                ret = super_block_impl_->flush_file();

                if (TFS_SUCCESS != ret)

                    break;

                physcial_blocks_.insert(PhysicalBlockMap::value_type(ext_physical_block_id, tmp_physical_block));

                (*physic_block) = tmp_physical_block;

            }

            while (0);

 

            if (TFS_SUCCESS != ret)

            {

                TBSYS_LOG(ERROR, "new ext block error! logic blockid: %u. ret: %d", logic_block_id, ret);

                tbsys::gDelete(tmp_physical_block);

            }

            return ret;

        }

(6). 找到一个没有被占用的扩展块号

//查找可用的块

        int BlockFileManager::find_avail_block(uint32_t& ext_physical_block_id, const BlockType block_type)

        {

            int32_t i = 1;

            int32_t size = super_block_.main_block_count_;

            //如果是扩展块类型,起始小标需要跳过前面的主块

            if (C_EXT_BLOCK == block_type)

            {

                i = super_block_.main_block_count_ + 1;

                size += super_block_.extend_block_count_;

            }

            bool hit_block = false;

            for (; i <= size; ++i)

            {

                //查找得到一个未使用的块

                if (!normal_bit_map_->test(i))

                {

                    //并且不会在错误的位图中出现

                    if (error_bit_map_->test(i)) //skip error block

                    {

                        continue;

                    }

                    hit_block = true;

                    break;

                }

            }

            // find nothing

            if (!hit_block)

            {

                TBSYS_LOG(ERROR, "block is exhausted! blocktype: %d/n", block_type);

                return EXIT_BLOCK_EXHAUST_ERROR;

            }

            TBSYS_LOG(DEBUG, "find avail blockid: %u/n", i);

            ext_physical_block_id = i;

            return TFS_SUCCESS;

}

(7).实际写物理块DataHandle类的方法:

int DataHandle::write_segment_data(const char* buf, const int32_t nbytes, const int32_t offset)

{

            if (NULL == buf)

            {

                return EXIT_POINTER_NULL;

            }

            PhysicalBlock* tmp_physical_block = NULL;

            int32_t inner_offset = 0;

            int32_t written_len = 0, writting_len = 0;

            int ret = TFS_SUCCESS;

            while (written_len < nbytes)

            {

                //尝试一次性写完

                writting_len = nbytes - written_len;

                //offset + written_len= 偏移量+累计写入的字节数

                ret = choose_physic_block(&tmp_physical_block, offset + written_len, inner_offset, writting_len);

                if (TFS_SUCCESS != ret)

                    return ret;

                //参数:写入缓冲,写入的自己数,物理块内部的偏移量

                ret = tmp_physical_block->pwrite_data(buf + written_len, writting_len, inner_offset);

                if (TFS_SUCCESS != ret)

                    return ret;

                written_len += writting_len;

            }

            return ret;

}

//读取实际的文件数据过程

int DataHandle::read_segment_data(char* buf, const int32_t nbytes, const int32_t offset)

        {

            if (NULL == buf)

            {

                return EXIT_POINTER_NULL;

            }

            PhysicalBlock* tmp_physical_block = NULL;

            int32_t inner_offset = 0;

            int32_t has_read_len = 0, reading_len = 0;

            int ret = TFS_SUCCESS;

            while (has_read_len < nbytes)

            {

                //每次都尝试一次性读取完剩余的字节数

                reading_len = nbytes - has_read_len;

                //根据offset + has_read_len偏移量,选取一个物理块,并且确定实际读取是在这个物理块内部的偏移量

                ret = choose_physic_block(&tmp_physical_block, offset + has_read_len, inner_offset, reading_len);

                if (TFS_SUCCESS != ret)

                    return ret;

                //从选中的物理块中从内部偏移inner_offset开始读取reading_len字节的数据,拷贝到输出buf + has_read_len缓冲中

                ret = tmp_physical_block->pread_data(buf + has_read_len, reading_len, inner_offset);

                if (TFS_SUCCESS != ret)

                    return ret;

                has_read_len += reading_len;

            }

 

            return ret;

}

//选择一个可写的物理块

int DataHandle::choose_physic_block(PhysicalBlock** tmp_physical_block, const int32_t offset,

            int32_t& inner_offset, int32_t& inner_len)

{

            std::list<PhysicalBlock*>* physic_block_list = logic_block_->get_physic_block_list();

            std::list<PhysicalBlock*>::iterator lit = physic_block_list->begin();

            int32_t sum_offset = 0;

            int32_t prev_sum_offset = 0;

            int32_t data_len = 0;

            for (; lit != physic_block_list->end(); ++lit)

            {

                data_len = (*lit)->get_total_data_len();

                //累加各个物理块的数据长度

                sum_offset += data_len;

                //一个文件可能分布在:一个物理主块+多个扩展块

                //offset= 偏移量(写入的起始位置)+累计写入的字节数,确定写入的开始位置

                if (offset < sum_offset)

                {

                    //取这一个物理块

                    *tmp_physical_block = (*lit);

                    //计算这个物理块的内部偏移量,比如说一个逻辑块对应一个物理主块,两个物理扩展块

                    //写文件时,前两个物理块被写满,到第三个,这里确定第三个物理块内部的偏移量

                    inner_offset = offset - prev_sum_offset;

                    //比如初始写入时:offset + written_len =offset+0,inner_len=writting_len=尝试一次性写完的字节数,

                    //如果大于数据长度,那么writting_len值就会改变,取实际能够写入的字节数

                    if ((offset + inner_len) > sum_offset)

                    {

                        inner_len = sum_offset - offset;

                    }

                    break;

                }

                prev_sum_offset += data_len;

            }

            //can not find

            if (lit == physic_block_list->end())

            {

                return EXIT_PHYSIC_BLOCK_OFFSET_ERROR;

            }

 

            return TFS_SUCCESS;

}