Linux 多进程拷贝

仅供本人参考，没有原理介绍，谨慎阅读

利用Linux系统提供的一系列函数实现多进程拷贝命令。实现的时候由于对进程控制太过生硬，一直出现莫名其妙的问题。最后参考了其他人是如何在fork后控制子进程的流程的，终于完成了。

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

void check_sys_call_err_pointer(void* ret, char*err_info, int exit_num);
void check_sys_call_err_int(int ret, char* err_info, int exit_num);

int main(int argc, char** argv)
{
    //check the number of args
    int process_nums = 0;
    if (argc < 3 || argc > 4)
    {
        puts("invalid args: Please check args");
        exit(1);
    }
    else if (argc == 3)
    {
        process_nums = 5;       //未指定进程数，默认5
    }
    else if (argc == 4) 
    {
        process_nums = atoi(argv[4]);
    }
    
    //opne src and dst file
    int fd_src = open(argv[1], O_RDONLY);
    check_sys_call_err_int(fd_src, "open", 1);

    int fd_dst = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0644);
    check_sys_call_err_int(fd_dst, "open", 1);

    // 获取src文件大小，并检验进程数量是否合适
    int src_file_size = lseek(fd_src, 0, SEEK_END);
    check_sys_call_err_int(src_file_size, "lseek", 1);

    if (src_file_size < process_nums)   //文件长度小于进程个数
        process_nums = src_file_size;
    
    int ret = ftruncate(fd_dst, src_file_size); //拓展目标文件大小
    check_sys_call_err_int(ret, "ftruncate", 1);

    // src和dst文件创建内存映射
    char* mm_src = mmap(NULL, src_file_size, PROT_READ, MAP_SHARED, fd_src, 0);
    check_sys_call_err_pointer(mm_src, "mmap", 1);
    close(fd_src);

    char* mm_dst = mmap(NULL, src_file_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_dst, 0);
    check_sys_call_err_pointer(mm_dst, "mmap", 1);
    close(fd_dst);

    int average_size = src_file_size / (process_nums + 1);      //每个子进程需要拷贝的字节数
    int average_size_last = average_size + (src_file_size % (process_nums + 1));    //最后一个子进程需要拷贝的字节数

    // 创建子进程
    pid_t pid; int i;
    for (i = 0; i < process_nums; ++i)
    {
        if ( (pid = fork()) == 0)
            break;
    }

    if (process_nums == i)  //父进程，阻塞等待回收子进程
    {
        for (int i = 0;i < process_nums; ++i)
            wait(NULL);        
    }
    else if (i == process_nums - 1) //最后一个子进程
    {
        memcpy(mm_dst + i * average_size, mm_src, average_size_last);
    }
    else    //其他子进程
    {
        memcpy(mm_dst + i * average_size, mm_src, average_size);
    }
    
    munmap(mm_src, MAPSIZE);
    munmap(mm_dst, MAPSIZE);
    return 0;
}

void check_sys_call_err_int(int ret, char* err_info, int exit_num)
{
    if (ret == -1)
    {
        perror(err_info);
        exit(exit_num);
    }
}
void check_sys_call_err_pointer(void* ret, char*err_info, int exit_num)
{
    if (ret == MAP_FAILED)
    {
        perror(err_info);
        exit(exit_num);
    }
}