文件系统核心存储引擎_实现(二)

最新推荐文章于 2024-06-01 18:28:10 发布
最新推荐文章于 2024-06-01 18:28:10 发布
阅读量173 收藏
点赞数
分类专栏： 文件系统大文件存储结构 文章标签： c++ linux 指针 buffer

内存映射实战之文件操作父类头文件定义

在这里插入图片描述

#ifndef QINIU_LARGE_FILE_OP_H_
#define QINIU_LARGE_FILE_OP_H_

#include "common.h"

namespace qiniu
{
    namespace largefile
    {
        class FileOperation
        {
            public:
            FileOperation(const std::string &file_name, const int open_fags = O_RDWR | O_LARGEFILE);
            ~FileOperation();

            int open_file();
            void close_file();

            int flush_file(); /* 把文件立即写入到磁盘 */

            int unlink_file();

            int pread_file(char *buf, const int32_t nbytes, const int64_t offset);
            int pwrite_file(const char *buf, const int32_t nbytes, const int64_t offset);

            int write_file(const char *buf, const int32_t nbytes);

            int64_t get_file_size();

            int ftruncate_file(const int64_t length);
            int seek_file(const int64_t offset);

            int get_fd() const
            {
                return fd_;
            }

            protected:
            int fd_;
            int open_fags_;
            char *file_name_;

            protected:
            int check_file();

            protected:
            static const mode_t OPEN_MODE = 0644; /* 0: 八进制 */
            static const int MAX_DISK_TIMES = 5;
        };
    }
}
#endif /* */

内存映射实战之文件操作CPP实现(上)

在这里插入图片描述

#include "file_op.h"
#include "common.h"

namespace qiniu
{
    namespace largefile
    {
        FileOperation::FileOperation(const std::string &file_name, const int open_fags):
        fd_(-1), open_fags_(open_fags)
        {
            file_name_ = strdup(file_name.c_str()); /* strdup() 动态内存分配记得要释放 */
        }

        FileOperation::~FileOperation()
        {
            if (fd_ > 0)
            {
                ::close(fd_);
            }

            if (NULL != file_name_)
            {
                free(file_name_); /* 释放第11行strdup()的动态内存分配 */
                file_name_ = NULL;
            }
        }

        int FileOperation::open_file()
        {
            if (fd_ > 0)
            {
                close(fd_);
                fd_ = -1;
            }

            fd_ = ::open(file_name_, open_fags_, OPEN_MODE);
            if (fd_ < 0)
            {
                return -errno;
            }

            return fd_;
        }

        void FileOperation::close_file()
        {
            if (fd_ < 0)
            {
                return;
            }

            ::close(fd_);
            fd_ = -1;
        }

        int64_t FileOperation::get_file_size() /* 获取文件的大小 */
        {
            int fd = check_file();

            if (fd < 0)
            {
                return -1;
            }

            struct stat statbuf;
            if (fstat(fd, &statbuf) != 0)
            {
                return -1;
            }

            return statbuf.st_size;
        }

        int FileOperation::check_file()
        {
            if (fd_ < 0)
            {
                fd_ = open_file();
            }

            return fd_;
        }

        int FileOperation::ftruncate_file(const int64_t length)
        {
            int fd = check_file();

            if (fd < 0)
            {
                return -fd;
            }

            return ftruncate(fd, length);
        }

        int FileOperation::seek_file(const int64_t offset)
        {
            int fd = check_file();

            if (fd < 0)
            {
                return fd;
            }

            return lseek(fd, offset, SEEK_SET);
        }

        int FileOperation::flush_file() /* 把文件立即写入到磁盘 */
        {
            if (open_fags_ & O_SYNC) /* O_SYNC 同步 */
            {
                return 0;
            }

            int fd = check_file();
            if (fd < 0)
            {
                return fd;
            }

            return fsync(fd);
        }

        int FileOperation::unlink_file()
        {
            close_file();
            return ::unlink(file_name_);
        }

        int FileOperation::pread_file(char *buf, const int32_t nbytes, const int64_t offset)
        {
            int32_t left = nbytes;
            int64_t read_offset = offset;
            int32_t read_len = 0;
            char *p_tmp = buf;

            int i = 0;

            while (left > 0)
            {
                ++i;

                if (i >= MAX_DISK_TIMES)
                {
                    break;
                }

                if (check_file() < 0)
                {
                    return -errno;
                }

                read_len = ::pread64(fd_, p_tmp, left, read_offset);

                if (read_len < 0)
                {
                    read_len = -errno;

                    if (-read_len == EINTR || EAGAIN == -read_len)
                    {
                        continue;
                    }
                    else if (EBADF == -read_len)
                    {
                        fd_ = -1;
                        continue;
                    }
                    else if (EBADF == -read_len)
                    {
                        fd_ = -1;
                        return read_len;
                    }else
                    {
                        return read_len;
                    }
                }
                else if (0 == read_len)
                {
                    break;
                }
                left -= read_len;
                p_tmp += read_len;
                read_offset += read_len;

                if (0 != left)
                {
                    return EXIT_DISK_OPER_INCOMPLETE;
                }

                return TFS_SUCCESS;
            }  
        }

        int FileOperation::pwrite_file(const char *buf, const int32_t nbytes, const int64_t offset)
        {
            int32_t left = nbytes;
            int64_t write_offset = offset;
            int32_t written_len = 0;
            const char *p_tmp = buf;

            int i = 0;

            while (left > 0)
            {
                ++i;

                if (i >= MAX_DISK_TIMES)
                {
                    break;
                }

                if (check_file() < 0)
                {
                    return -errno;
                }

                written_len = ::pwrite64(fd_, p_tmp, left, write_offset);

                if (written_len < 0)
                {
                    written_len = -errno;

                    if (-written_len == EINTR || EAGAIN == -written_len)
                    {
                        continue;
                    }
                    else if (EBADF == -written_len)
                    {
                        fd_ = -1;
                        continue;
                    }
                    else
                    {
                        return written_len;
                    } 
                }
                else if (0 == written_len)
                {
                    break;
                }

                left -= written_len;
                p_tmp += written_len;
                write_offset += written_len;

                if (0 != left)
                {
                    return EXIT_DISK_OPER_INCOMPLETE;
                }

                return TFS_SUCCESS;
            }  
        }

        int FileOperation::write_file(const char *buf, const int32_t nbytes)
        {
            int32_t left = nbytes;
            int32_t written_len = 0;
            const char *p_tmp = buf;

            int i = 0;

            while (left > 0)
            {
                ++i;

                if (i >= MAX_DISK_TIMES)
                {
                    break;
                }

                if (check_file() < 0)
                {
                    return -errno;
                }

                written_len = ::write(fd_, p_tmp, left);

                if (written_len < 0)
                {
                    written_len = -errno;

                    if (-written_len == EINTR || EAGAIN == -written_len)
                    {
                        continue;
                    }
                    else if (EBADF == -written_len)
                    {
                        fd_ = -1;
                        return written_len;
                    }
                    else
                    {
                        return written_len;
                    }   
                }
                else if (0 == written_len)
                {
                    break;
                }

                left -= written_len;
                p_tmp += written_len;
            }
        }
    }
}

内存映射实战之文件操作CPP实现(中)

在这里插入图片描述

#ifndef _COMMON_H_INCLUDED_
#define _COMMON_H_INCLUDED_

#include <iostream>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdlib.h>

namespace qiniu
{
    namespace largefile
    {
        const int32_t TFS_SUCCESS = 0;
        const int32_t EXIT_DISK_OPER_INCOMPLETE = -8012; /* read or write length is less than required */
    }
}

#endif /* _COMMON_H_INCLUDED_ */

在这里插入图片描述

#include "file_op.h"
#include "common.h"

using namespace std;
using namespace qiniu;

int main(void)
{
    const char *filename = "file_op.txt";
    largefile::FileOperation *fileOP = new largefile::FileOperation(filename, O_CREAT | O_RDWR | O_LARGEFILE);

    int fd = fileOP->open_file();
    if (fd < 0)
    {
        fprintf(stderr, "open file %s failed. reason: %s \n", filename, strerror(-fd));
        exit(1);
    }

    char buffer[4096];
    memset(buffer, '6', 4096);
    int ret = fileOP->pwrite_file(buffer, 4096, 1024);
    if (ret < 0)
    {
        fprintf(stderr, "pwrite file %s failed reason: %s\n", filename, strerror(-ret));
    }

    fileOP->close_file();

    return 0;
}

demo(一)测试运行结果:

在这里插入图片描述

more file_op.txt

在这里插入图片描述

demo(二)测试运行结果:

在这里插入图片描述

#include "file_op.h"
#include "common.h"

using namespace std;
using namespace qiniu;

int main(void)
{
    const char *filename = "file_op.txt";
    largefile::FileOperation *fileOP = new largefile::FileOperation(filename, O_CREAT | O_RDWR | O_LARGEFILE);

    int fd = fileOP->open_file();
    if (fd < 0)
    {
        fprintf(stderr, "open file %s failed. reason: %s \n", filename, strerror(-fd));
        exit(1);
    }

    char buffer[64+1];
    memset(buffer, '8', 64);
    int ret = fileOP->pwrite_file(buffer, 64, 1024);
    if (ret < 0)
    {
        fprintf(stderr, "pwrite file %s failed reason: %s\n", filename, strerror(-ret));
    }

    memset(buffer, 0, 64);
    ret = fileOP->pread_file(buffer, 64, 1024);
    if (ret < 0)
    {
        fprintf(stderr, "pread file %s failed reason %s \n", filename, strerror(-ret));
    }
    else
    {
        buffer[64] = '\0';
        printf("read: %s \n", buffer);
    }
    

    fileOP->close_file();

    return 0;
}

运行结果:
在这里插入图片描述

demo(三)测试运行结果:

在这里插入图片描述

#include "file_op.h"
#include "common.h"

using namespace std;
using namespace qiniu;

int main(void)
{
    const char *filename = "file_op.txt";
    largefile::FileOperation *fileOP = new largefile::FileOperation(filename, O_CREAT | O_RDWR | O_LARGEFILE);

    int fd = fileOP->open_file();
    if (fd < 0)
    {
        fprintf(stderr, "open file %s failed. reason: %s \n", filename, strerror(-fd));
        exit(1);
    }


    char buffer[64+1];
    memset(buffer, '8', 64);
    int ret = fileOP->pwrite_file(buffer, 64, 1024);
    if (ret < 0)
    {
        if (ret == largefile::EXIT_DISK_OPER_INCOMPLETE)
        {
            fprintf(stderr, "pwrite_file: read length is less than required!");
        }
        else
        {
            fprintf(stderr, "pwrite file %s failed reason: %s\n", filename, strerror(-ret));
        } 
    }


    memset(buffer, 0, 64);
    ret = fileOP->pread_file(buffer, 64, 1024);
    if (ret < 0)
    {
        if (ret == largefile::EXIT_DISK_OPER_INCOMPLETE)
        {
            fprintf(stderr, "pread_file: read length is less than required!");
        }else
        {
            fprintf(stderr, "pread file %s failed reason %s \n", filename, strerror(-ret));
        } 
    }
    else
    {
        buffer[64] = '\0';
        printf("read: %s \n", buffer);
    }


    memset(buffer, '9', 64);
    ret = fileOP->write_file(buffer, 64);
    if (ret < 0)
    {
        if (ret == largefile::EXIT_DISK_OPER_INCOMPLETE)
        {
            fprintf(stderr, "write_file: read length is less than requirend!");
        }
        else
        {
            fprintf(stderr, "write_file %s failed reason: %s\n", filename, strerror(-ret));
        }
    }
    

    fileOP->close_file();

    return 0;
}

运行结果:

在这里插入图片描述

more file_op.txt

在这里插入图片描述

总结:

文件的指针不变, 因此插入的字符, 还是在头部开始

demo(四)测试运行结果:

在这里插入图片描述

#include "file_op.h"
#include "common.h"

using namespace std;
using namespace qiniu;

int main(void)
{
    const char *filename = "file_op.txt";
    largefile::FileOperation *fileOP = new largefile::FileOperation(filename, O_CREAT | O_RDWR | O_LARGEFILE);

    int fd = fileOP->open_file();
    if (fd < 0)
    {
        fprintf(stderr, "open file %s failed. reason: %s \n", filename, strerror(-fd));
        exit(1);
    }


    char buffer[64+1];
    memset(buffer, '8', 64);
    int ret = fileOP->pwrite_file(buffer, 64, 128);
    if (ret < 0)
    {
        if (ret == largefile::EXIT_DISK_OPER_INCOMPLETE)
        {
            fprintf(stderr, "pwrite_file: read length is less than required!");
        }
        else
        {
            fprintf(stderr, "pwrite file %s failed reason: %s\n", filename, strerror(-ret));
        } 
    }


    memset(buffer, 0, 64);
    ret = fileOP->pread_file(buffer, 64, 128);
    if (ret < 0)
    {
        if (ret == largefile::EXIT_DISK_OPER_INCOMPLETE)
        {
            fprintf(stderr, "pread_file: read length is less than required!");
        }else
        {
            fprintf(stderr, "pread file %s failed reason %s \n", filename, strerror(-ret));
        } 
    }
    else
    {
        buffer[64] = '\0';
        printf("read: %s \n", buffer);
    }


    memset(buffer, '9', 64);
    ret = fileOP->write_file(buffer, 64);
    if (ret < 0)
    {
        if (ret == largefile::EXIT_DISK_OPER_INCOMPLETE)
        {
            fprintf(stderr, "write_file: read length is less than requirend!");
        }
        else
        {
            fprintf(stderr, "write_file %s failed reason: %s\n", filename, strerror(-ret));
        }
    }
    

    fileOP->close_file();

    return 0;
}

运行结果:
在这里插入图片描述

vi file_op.tx

在这里插入图片描述

总结:

文件的指针不变, 因此插入的字符, 还是在头部开始

结语:

温馨提示: 请不要用跑步鞋和在有太阳的情况下打球, 打球, 容易扭伤, 我星期五的时候打球(好久没有和舍友打球, 拉这他们打, 外面太阳温度有点大, 因为温度太高, 所以没有打超过30分钟, 没劲.)

时间: 2020-06-20

weifc-wei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
文件系统核心存储引擎_实现(三)
weifc-wei 的博客
06-24 188
文件映射操作类头文件定义
mysql 写一个存储引擎_【译】从草稿开始写一个 MySQL 存储引擎(一)-Go语言中文社区...
weixin_28747937的博客
02-01 192
本文主要描述了如何写一个MySQL 存储引擎 - 一个可以持久保存 MySQL 表数据的插件简介这篇文章总结了我在写一个新的 MySQL 存储引擎时学到的一些事情。MySQL 的存储引擎是一个能够提供 在磁盘中存储数据，并且能够提供对数据的链接的插件。存储引擎通常被作为 key/value 数据库实现，但是并不一定是这样。Oracle 的 MySQL 提供了多种存储引擎，并且所有的存储引擎都能够被...
文件系统核心存储引擎_文件系统接口
weifc-wei 的博客
06-14 156
文件系统接口 定义: 文件系统 －一种把数据组织成文件和目录的存储方式，提供了基于文件的存取接口，并通过文件权限控制访问。 时间: 2020-06-14
存储引擎
weixin_45439533的博客
10-23 133
一. 一条SQL语句的执行顺序 **mysql的体系结构** ![在这里插入图片描述](https://img-blog.csdnimg.cn/201910211854373.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl...
Mysql各种存储引擎和物理文件结构的对比
hearting的博客
04-02 820
存储引擎 即表类型(table_type),用户可以根据应用的需求选择如何来存储数据、索引、是否使用事务等。选择合适的存储引擎往往能够有效的提高数据库的性能和数据的访问效率，另外一个数据库中的多个表可以使用不同引擎的组合以满足各种性能和实际需求。 在mysql5之后，支持的存储引擎有十几个，但是常用的就那么几种，而且默认支持的也是InnoDB。 使用命令来看看当前数据库可以支持的存储引擎有哪...
淘宝分布式文件系统核心储存引擎学习总结
weixin_45738899的博客
03-03 3796
淘宝分布式文件核心储存引擎架构总结——TFS系统1.内存映射类1.主要功能2.主要方法2.文件操作类1.主要功能2.基本方法 1.内存映射类 内存映射类——MMapFile 1.主要功能 实现内存映射的相关操作，封装内存映射相关函数。 2.主要方法 执行内存映射——map_file() 重新执行内存映射(常用来扩容)——remap_file() 得到内存映射首地址——get_data() 得到内存映射大小——get_size() 解除内存映射——munmap_file() 将内存映射的内容同步到文件——e
【云存储】主流分布式文件系统介绍
热门推荐
dvlinker的技术专栏
07-12 2万+
本文概要性介绍几大主流分布式文件系统，给大家提供一定的参考。
老师的 -> 大文件系统核心存储引擎(源码)
06-30
老师的 -> 大文件系统核心存储引擎(源码) -> 供大家学习, 学习
基于图数据库存储引擎的CMDB系统.pdf
03-14
基于图数据库存储引擎的 CMDB 系统 传统数据中心的资源对象与关系类型较为单一，CMDB 系统可以通过关系 型数据库对资源对象和关系数据进行分析和处理。 随着云计算、大数据等技术的高速发展与应用，数据中心资源对象...
大规模分布式存储系统
01-04
范型篇——介绍谷歌、亚马逊、微软、阿里巴巴等著名互联网公司的大规模分布式存储系统架构，涉及分布式文件系统、分布式键值系统、分布式表格系统以及分布式数据库技术等。实践篇——以阿里巴巴的分布式数据库Ocean...
文件系统核心存储引擎_实现(一)
weifc-wei 的博客
06-19 223
内存映射实战之头文件定义 #ifndef QINIU_LARGEFILE_MMAPFILE_H_ #define QINIU_LARGEFILE_MMAPFILE_H_ #include <unistd.h> namespace qiniu { namespace largefile { struct MMapOption { int32_t max_mmap_size_; int32_t fir
什么是存储引擎？
weixin_30640769的博客
07-08 657
视频的格式，磁盘的文件系统ntfs 对于用户和应用程序来说统一一张表的数据，无论用什么引擎来存储，用户看到的数据都是一样的。不同的引擎存取、引擎功能，占用的空间大小，读取性能等可能有区别 MySQL最常用的存储引擎为：myisam和InnoDB。 转载于:https://www.cnblogs.com/Confusedren/p/11150198.html...
结束 - 文件系统核心存储引擎_实现(六)
weifc-wei 的博客
06-30 148
索引处理类 - 读流程实现 #include "common.h" #include "file_op.h" #include "index_handle.h" #include "sstream" using namespace std; using namespace qiniu; const static largefile::MMapOption mmap_option = {1024000, 4096, 4096}; /* 内存映射的参数 */ const static uint32_t m
C++：round函数用法
Solititude的博客
05-28 342
C++：round函数用法
C++/Python/Java AWS S3认证
一个大佬的博客
06-01 680
【代码】C++/Python/Java AWS S3认证。
CrossOver支持M4新品吗？苹果M4芯片对游戏支持的怎么样？
软妹子的博客
06-01 424
CrossOver是一款可以在不同平台之间无缝切换的软件，它可以让你在MacOS或者Linux操作系统上运行Windows应用程序，无需安装双系统或虚拟机。CrossOver是基于Wine项目开发的，Wine是一个可以在非Windows平台上运行Windows应用程序的兼容层。那么，CrossOver是否支持M4新品呢？M4芯片又对游戏支持的怎么样呢？本文将从以下几个方面来探讨这个问题。M4芯片正式亮相，首发产品是2024款的iPadPro。
【C++】list的使用（下）
2303_79329831的博客
06-01 573
本篇博客主要内容：STL库中list用法的讲解。让我们接着上一篇博文的内容继续，进入list最后一个模块，操作list对象的接口函数。本篇文章所讲到的list内容出自于同一个模块，由于其排序和合并的方式涉及到了仿函数的传递，所以内容和篇幅稍微会大一些。相信学完本篇内容之后，能对list的使用和C++有更充分的了解。♥STLC++
c++ string模拟实现
最新发布
2302_81705247的博客
06-01 523
模拟实现string类，里面包含四个成员变量，第一个是指向字符数组的指针，第二个变量是目前存放了多少个字符，第三个变量为这个字符数组的容量的大小。最后一个为静态成员变量npos。注意：一个修饰的成员变量可以在类里面初始化（三者缺一不可），而其他成员变量，要声明定义分离，类中声明，类外定义。char* _str;
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 820
string类各函数接口。
mysql 存储引擎
12-13
MySQL是一种关系型数据库管理系统，支持多种存储引擎。存储引擎是MySQL的核心组件之一，它负责数据的存储和检索。MySQL支持多种存储引擎，每种存储引擎都有其特点和适用场景。 以下是MySQL常用的几种存储引擎及其...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值