使用mmap实现大文件的复制：单进程与多进程情况

使用mmap实现大文件的复制

典型的文件复制的流程是：

1. 读取（fread）被复制的文件的内容。
2. 写入（fwrite）到新的文件中去。

使用mmap进行文件复制的流程则是：

1. 为被复制的文件已经新文件分别进行mmap映射。
2. 将被复制的文件映射的内存的内容复制到新文件映射的内存。

在知道了基本原理之后，让我们看看具体的做法，本文只分析使用mmap进行大文件复制的方法

具体的做法

先了解一些使用mmap时，应当注意的细节：

• 文件的大小必须要大于等于内存映射区的大小，因此对于创建的新文件，可以使用文件截断函数（ftruncate）来改变文件的大小和被复制的文件大小一样，这样子才能在映射一个和被复制的文件的映射区一样大的内存映射区。
• 下面我将使用单进程和多进程两种方式来进行mmap文件复制

单进程mmap文件复制

#include<stdio.h>
#include <string.h>
#include <malloc.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>
/* 首先规定一下该命令的参数 ：
 * mycopy 源文件地址 目标文件地址
 *
 * 可能需要的函数：open\read\write\close
 * 基本流程：打开源文件，读取内容，写到另一个文件，关闭文件
 * 核心方法：通过mmap(最快的进程间通信方法) 
 * 如何获取文件的大小：
 *
 */
unsigned long get_file_byte_num(const char * filename)
{
    FILE *fp = fopen(filename, "r");
    fseek(fp, 0, SEEK_END);
    return ftell(fp);
}
int main(int argc, char ** argv)
{
    // 首先解析输入的参数得到源文件和目标文件
    if (argc < 3)
    {
        perror("参数输入不足");
    }
    int slen = strlen(argv[1]); // 这个是源文件的名的长度
    int tlen = strlen(argv[2]); // 这个是目标文件名的长度
    char *sname = (char *)malloc(sizeof(char)*(slen + 1));
    char *tname = (char*)malloc(sizeof(char)*(tlen + 1));
    strcpy(sname, argv[1]);
    strcpy(tname, argv[2]);
    // 打开目标文件
    // 计算源文件的大小（字节数）
    unsigned long byte_num = get_file_byte_num(sname);
    printf("文件的长度为%ld字节\n", byte_num);
    //--------建立 mmap 映射区 --------------
    // 获取被复制文件的文件描述符
    int fd = open(sname, O_RDWR|O_CREAT, 0644);
    int tfd = open(tname, O_RDWR|O_CREAT, 0644);
    ftruncate(tfd, byte_num);

    char *mem =(char*) mmap(NULL, byte_num, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
    if (mem == MAP_FAILED)
        perror("mmap err");
    char *tmem =(char*) mmap(NULL, byte_num, PROT_WRITE|PROT_READ, MAP_SHARED, tfd, 0);
    if (tmem == MAP_FAILED)
        perror("mmap err");

    close(fd); // 内存映射区建立之后，就可以关闭文件描述符
    close(tfd);

    memcpy(tmem, mem, byte_num);

    // 回收子进程，等待拷贝结束
    munmap(mem, byte_num);
    munmap(tmem, byte_num);
    free(sname);
    free(tname);

多进程mmap复制文件

• 所谓的多进程mmap复制文件，只是做了将复制的任务分给多个进程去完成，核心思想不变。

#include<stdio.h>
#include <string.h>
#include <malloc.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <signal.h>
#include <sys/wait.h>
/* 首先规定一下该命令的参数 ：
* mycopy 源文件地址 目标文件地址
*
* 可能需要的函数：open\read\write\close
* 基本流程：打开源文件，读取内容，写到另一个文件，关闭文件
* 核心方法：通过mmap(最快的进程间通信方法) 
* 如何获取文件的大小：
*
*/
// 获取文件的字节数
unsigned long get_file_byte_num(const char * filename)
{
    FILE *fp = fopen(filename, "r");
    fseek(fp, 0, SEEK_END);
    return ftell(fp);
}

// sigchld信号处理函数
void sigchld_handle(int a)
{
    pid_t pid;
    while ((pid = waitpid(0,NULL, WNOHANG)) > 0)
    {
        printf("回收到一个子进程%d\n", pid);
    }
}

int main(int argc, char ** argv)
{
    // 首先解析输入的参数得到源文件和目标文件
    if (argc < 3)
    {
        perror("参数输入不足");
    }
    int slen = strlen(argv[1]); // 这个是源文件的名的长度
    int tlen = strlen(argv[2]); // 这个是目标文件名的长度
    char *sname = (char *)malloc(sizeof(char)*(slen + 1));
    char *tname = (char*)malloc(sizeof(char)*(tlen + 1));
    strcpy(sname, argv[1]);
    strcpy(tname, argv[2]);
    // 打开目标文件
    FILE * tfp = fopen(tname, "w");  // 不存在则创建
    // 计算源文件的大小（字节数）
    unsigned long byte_num = get_file_byte_num(sname);
    printf("文件的长度为%ld字节\n", byte_num);
    //--------建立 mmap 映射区 --------------
    // 获取被复制文件的文件描述符
    int fd = open(sname, O_RDWR|O_CREAT, 0644);
    int tfd = open(tname, O_RDWR|O_CREAT, 0644);
    ftruncate(tfd, byte_num); // 将tfd指向的文件的大小改变为byte_num

    char *mem =(char*) mmap(NULL, byte_num, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
    char * mem_tmp = mem; // 备份共享内存入口地址
    if (mem == MAP_FAILED)
    perror("MAP_FAILED");
    char *tmem = (char*)mmap(NULL, byte_num,  PROT_WRITE, MAP_SHARED,tfd, 0);
    char * tmem_tmp = tmem;
    if (tmem == MAP_FAILED)
    perror("mmap err");

    close(fd); // 内存映射区建立之后，就可以关闭文件描述符
    close(tfd);

    // 父子进程之间就可以通过这个mem指针进行通信了
    // 规定进程数量为5mZ    const int num_proc = 5;
    // 根据进程数量，计算每个进程需要拷贝的字节数，
    // 最后一个进程拷贝剩余的字节数。
    const int num_proc = 5;
    const unsigned long each_proc_byte = byte_num/num_proc;
    // 由于可能无法整除，因此最后一个进程，需要多复制一些
    const unsigned long last_proc_byte = byte_num - each_proc_byte*(num_proc - 1);  

    // 屏蔽sigchld信号的系统默认处理方式
    sigset_t set;
    sigemptyset(&set); // 初始化一下set
    sigaddset(&set, SIGCHLD);
    sigprocmask(SIG_BLOCK, &set, NULL); // 屏蔽

    // 循环创建子进程
int i; 
pid_t  pid;
for(i = 0; i < num_proc - 1; ++i)
{
    if ((pid = fork())==-1)
    perror("fork error");
    if (pid == 0)
    break;
}

    // -------具体的拷贝过程---------
    if (i == num_proc - 1) // 父进程
    {
        // 设置信号捕捉和解除屏蔽
        struct sigaction act;
        act.sa_handler = sigchld_handle;
        sigemptyset(&act.sa_mask); // 处理期间不屏蔽其他信号
        sigaction(SIGCHLD, &act, NULL); // 启动信号捕获
        sigprocmask(SIG_UNBLOCK, &set, NULL); // 解除SIGCHLD的屏蔽

        memcpy(tmem_tmp + each_proc_byte*i, mem_tmp + each_proc_byte*i, last_proc_byte);   

    }else
    {
        memcpy(tmem + each_proc_byte*i, mem_tmp +  each_proc_byte*i, each_proc_byte);
    }
    //
    // 回收子进程，等待拷贝结束
    //

        munmap(mem, byte_num);
        munmap(tmem, byte_num);
        free(sname);
        free(tname);
        return 0;
}

几个问题

• 主进程什么时候进行munmap才不会影响其他进程使用mmap进行复制。
  父子进程之间的用户空间遵循“读时共享、写时复制”的原则，mmap肯定是采用的用户空间的内存，因此我认为最好的处理方法，就是每个进程都进行munmap。
• sleep()函数的注意点：
  sleep在manpage上的原文解释为：sleep() makes the calling process sleep until seconds seconds have elapsed or a signal arrives which is not ignored.
  也就是说，结束sleep的情况又两种：1.休眠时间到。2.调用sleep的进程收到一个信号，且该信号未被屏蔽，在该信号处理完成后，理解结束sleep。
• 子进程可能会比主进程结束的慢，而且不能让主进程阻塞等待子进程（通过信号捕捉来回收子进程），这种情况下，该如何回收子进程？
  首先，主进程准备好信号捕获回收子进程的代码。其次，能不能回收就随缘，如果主进程先退出了就把子进程交给init进程回收。所以，不需要担心能不能回收的问题。