进程

int system(const char* string);

// 示例
system("cd /home/rxsi/ && sh restart.sh");

int execl(const char* path, const char* args, ...) // 函数说明：执行path字符串所代表的的文件路径，后面的参数是文件执行时的参数，并且最后要传入一个空指针作为结束
    
// 示例
execl("/bin/ls", "ls", "-al", "/etc/passwd", (char*)0);

#include <unistd.h>
pid_t id = fork();

fcntl (desc, F_SETFD, FD_CLOEXEC);

pid_t getpid();

pid_t getppid();

// 管道
int fd[2];
int ret = pipe(fd);

// FIFO
int mkfifo(const char* pathname, mod_t mode);
int mknode(const char* pathname, mode_t mode | S_IFIFO, (dev_t)0);

// pathname是一个普通的Unix路径名,也是该FIFO的名字
// mode参数指定了文件权限和将被创建的文件类型(在此情况下是S_IFIFO),dev是创建设备特殊文件时使用的一个值,对于先进先出文件该值为0

// 对于管道来说，只能是通过该种方式
int flag;
flag = fcntl(fd, F_GETFL, 0); // 先获取原始属性
flag |= O_NONBLOCK; // 再原始属性的基础上加上非阻塞属性
fcntl(fd, F_SETFL, flag); // 设置新属性

// 对于FIFO来说，可以在调用open时指定
writefd = open(FIFO1, O_WRONLY | O_NONBLOK, 0);

// 管道
#include <stdio.h>
#include <unistd.h>
#include <string.h> // .h是C语言的头文件,没有.h是C++的头文件
#include <errno.h>
#include <sys/wait.h>

int main()
{
    int fd[2];
    int ret = pipe(fd);
    if (ret == -1)
    { 
        perror("pipe error\n"); // 将保存输出到标准错误输出stderr中.0是标准输入,1是标准输出,3是标准错误输出
        return 1;
    }
    pid_t id = fork(); // fork之后,如果是0则代表是当前是子进程,但是在父进程中这个id是子进程的pid
    if (id == 0)
    {
        int i = 0;
        close(fd[0]); // 关闭读端
        const char* child = "I am child ";
        while (i < 10)
        {
            write(fd[1], child, strlen(child)+1);
            sleep(1);
            i++;
        }
    }
    else if (id > 0)
    {
        close(fd[1]);
        char msg[100];
        int status = 0;
        int j = 0;
        while (j < 5) // 这里只读取5个数据后就关闭读端
        {
            memset(msg, '\0', sizeof(msg)); // 用以给指定内存块填充数据
            ssize_t s = read(fd[0], msg, sizeof(msg));// 这个是有符号的整型,size_t是无符号的整型。size_t一般用来表示"适用于计量neiucn中可容纳的数据项目个数的无符号整数类型",因此通常用在数组下标和内存管理函数之类的函数；ssize_t一般用来表示"可以被执行读写操作的数据块的大小"
            printf("%s %d\n", msg, j);
            j++;
        }
        close(fd[0]);
        pid_t ret = waitpid(id, &status, 0);// pid waitpid(pid_t pid, int* status, int options)
        // 暂停当前进程的执行,等待有信号来到或者子进程结束,如果没有这行,那么子进程还没有运行结束,父进程就退出了
        // 子进程的状态会存储在status中,如果只是当存想到阻塞功能,那么直接传入NULL即可

        // pid < -1: 等待进程组识别码为pid绝对值的任何子进程
        // pid = -1: 等待任何子进程,相当于wait()
        // pid = 0: 等待进程组识别码与目前进程相同的任何子进程
        // pid > 0: 等待任何子进程识别码为pid的子进程
        // wait是阻塞版本

        printf("exitsingle(%d), exit(%d)\n", status&0xff, (status>>8)&0xff);
        // 输出为13, 通过 kill -l 可以知道是 SIGPIPE 信号。因为读端关闭而写端还在写入，因此抛出异常
    }
    else
    {
        perror("fork error\n");
        return 2;
    }
    return 0;
}

// FIFO有名管道
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define PATH "/tmp/my_fifo"

int main()
{
    int ret = mkfifo(PATH, 0777); // 如果文件已经存在,那么会返回-1
    if (ret == -1)
    {
        perror("pipe error\n");
        return 1;
    }

    pid_t id = fork();
    if (id == 0)
    {
        int fd = open(PATH, O_WRONLY);
        int i = 0;
        const char* child = "I am child by fifo";
        while (i < 5)
        {
            write(fd, child, strlen(child)+1);
            sleep(1);
            i++;
        }
        close(fd);
    }
    else if (id > 0)
    {
        int fd = open(PATH, O_RDONLY);
        char msg[100];
        int status = 0;
        int j = 0;
        while (j < 5)
        {
            memset(msg, '\0', sizeof(msg));
            ssize_t s = read(fd, msg, sizeof(msg));
            printf("%s %d\n", msg, j);
            j++;
        }
        close(fd); // 关闭管道文件
        unlink(PATH); // 删除管道文件,底层使用了引用计数,即使这个语句放在open之后就调用,依然不会影响已经打开的FIFO管道.
        // 如果放在open之前,则open函数会被阻塞
    }
    else
    {
        perror("fork error\n");
        return 2;
    }
    return 0;
}

#include <stdio.h>
#include <mqueue.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>
#include <algorithm>

#define PATH "/tmp" // 必须以/开头且只能含有一个/  如果想要指定诸如 /tmp/my_mq 这种格式,则需要使用 mount 挂载路径


int main()
{
    mqd_t msgid;
    int text_size = 50;
    msgid = mq_open(PATH, O_RDWR | O_CREAT, S_IRWXU | S_IRWXG, NULL); // 创建消息队列
    if (msgid == (mqd_t)-1)
    {
        perror("mq_open error");
        exit(1);
    }
    
    mq_attr msg_attr;
    if (mq_getattr(msgid, &msg_attr) == -1) // 获取消息队列属性
    {
        perror("mq_getattr error");
        exit(1);
    }
    
    pid_t pid = fork();
    if (pid < 0)
    {
        printf("fork error");
        exit(0); // exit(0)是正常退出程序,exit(1)是非正常退出程序.exit的退出会直接删除进程,并将信号返回到OS
    }
    
    if (pid == 0)
    {
        for (int i = 1; i < 10; ++i)
        {
            sleep(1);
            char text[text_size] = "write msg from child process!" ;
            if (mq_send(msgid, (char*)&text, text_size, i) == -1)
            {
                perror("mq_send error");
                exit(1);
            }
        }
    }
    else
    {
        int size = std::max(text_size, (int)msg_attr.mq_msgsize);
        printf("size = %d\n", size); // 默认是8192
        for (int i = 1; i < 10; ++i)
        {
            char buf[text_size];
            unsigned int priop; // 存放优先级的指针
            if (mq_receive(msgid, (char*)&buf, size, &priop) == -1)
            {
                perror("mq_receive error");
                exit(1);
            }
            printf("get the msg: %s, priority: %d\n", buf, priop);
        }
        
        if (mq_close(msgid) == -1)
        {
            perror("mq_close error");
            exit(1);
        }
        
        if (mq_unlink(PATH) == -1)
        {
            perror("mq_unlink error");
            exit(1);
        }
    }
    return 0;
}

int msgget(key_t key, int msgflg);
// key_t: 本质是int类型
// msgflg: 表示的权限标识，表示消息队列的访问权限。
// msgflg可以与IPC_CREATE做 | 操作，表示当key所命名的消息队列不存在时，创建一个消息队列，如果key命名的消息队列存在，则IPC_CREATE会被忽略，则只返回一个标识符(非0)；如果创建失败，则返回-1。

struct msqid_ds
{
    struct ipc_perm msg_perm; // 权限设置,类似文件访问权限
    time_t msg_stime; // 最后调用msgsnd调用时间
    time_t msg_rtime; // 最后调用msgrcv调用时间
    time_t msg_ctime; // 队列的创建时间或者最后调用msgctl执行IPC_SET操作
    unsigned long msg_cbytes; // 当前队列中所有消息的总长度
    msgqnum_t msg_qnum; // 当前队列中有多少个消息
    msglen_t msg_qbytes; // 当前队列能够存放的消息体的总字节大小
    pid_t msg_lspid; // 最后调用msgsnd的进程的ID
    pid_t msg_lrpid; // 最后调用msgrcv的进程的ID
};

int msgctl(int msqid, int cmd, struct msqid_ds* buf);
// msqid:在msgget创建的id
// cmd可选值:
// IPC_STAT: 将在msgget创建的key 和 msqid_ds结构体关联信息,复制到buf中.不过调用次方法的用户要有读权限
// IPC_SET:可设置某些属性
// IPC_RMID:删除消息队列,会唤醒所有的读进程和写进程,给这些进程返回errno=EIDRM,msgctl的buf参数可以设置为NULL

// 当调用成功会返回0，如果失败则返回-1，且errno会被设置为对应的状态

// 发送消息到消息队列,调用者需要有写权限
int msgsnd(int msqid, const void* msgp, size_t msgz, int msgflg);
// 从消息队列中取出消息,调用者需要有读权限
ssize_t msgrcv(int msqid, void* msgp, size_t msgsz, long msgtyp, int msgflg);

struct msgbuf
{
    long mtype; // 消息类型，需要>0
    char mtext[1]; // 消息体，该大小由size_t msgz指定
};

#include <sys/msg.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <iostream>

#define MAX_TEXT_SIZE 50

struct msg_buf
{
    long mtype;
    char mtext[MAX_TEXT_SIZE];
};

int main()
{

    int msgid = msgget((size_t)123, 0666 | IPC_CREAT);
    if (msgid == -1)
    {
        perror("msgget error");
        return 1; // 通过return的方式是把栈弹出,回到上层调用,这里在main函数因此起到退出进程的效果
    }

    pid_t pid = fork();
    if (pid < 0)
    {
        printf("fork error");
        exit(0); // exit(0)是正常退出程序,exit(1)是非正常退出程序.exit的退出会直接删除进程,并将信号返回到OS
    }

    if (pid == 0)
    {
        for (int i = 1; i < 10; ++i)
        {
            msg_buf buf;
            sleep(1);
            char text[MAX_TEXT_SIZE] = "write msg from child process!" ;
            buf.mtype = i; // 注意这里不能是0!!!!
            strcpy(buf.mtext, text); // 注意这里不能是buf.mtext = text;
            // 因为数组名在C语言中退化为常量指针,因此不能使用=号
            // 只能使用memcpy(字符数组是strcpy),或者使用循环赋值的方式

            if (msgsnd(msgid, &buf, MAX_TEXT_SIZE, 0) == -1)
            {
                perror("msgsnd failed");
                exit(1);
            }
        }
    }
    else
    {
        msg_buf buf;
        for (int i = 1; i < 10; ++i)
        {
            if (msgrcv(msgid, (void*)&buf, MAX_TEXT_SIZE, i, 0) == -1) // 这里设置i不为0,因此会接收对应的消息序号,如果是0,则每次都接收消息队列的头一个
            {
                perror("msgrcv fail");
                exit(1);
            }
            printf("get the msg: %s\n", buf.mtext);
        }
        if (msgctl(msgid, IPC_RMID, 0) == -1)
        {
            perror("msgctl fail");
            exit(1);
        }
        exit(0);
    }
}

#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
/*
void* addr：用户进程中所要映射的用户空间的起始地址，通常为NULL（由内核指定，内核根据/proc/sys/vm/mmap_min_addr地址计算）
size_t length：要映射的内存区域的大小
int prot：期望的内存保护标志，不能与文件的打开模式冲突
    - PORT_EXEC：页内容可以被执行
    - PORT_READ：页内容可以被读取
    - PORT_WRITE：页可以被写入
    - PORT_NONE：页不可访问
int flags：指定映射对象的类型，映射选项和映射页是否可以共享
    - MAP_FIXED：使用指定的映射起始地址，如果由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。如果指定的起始地址不可用，操作将会失败。并且起始地址必须落在页的边界上。
    - MAP_SHARED：与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件。直到msync()或者munmap()被调用，文件实际上不会被更新。当设置该属性时，fork出的子进程将会继承该共享内存区域
    - MAP_PRIVATE：建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。
int fd：有效的文件描述符
off_t offset：被映射对象内容的起点

return: 成功返回映射区的起始地址，出错则返回MAP_FAILED
*/

#include <sys/mman.h>

int munmap(void* addr, size_t len);
/*
void* addr：映射区的地址
size_t len：映射区的大小

return：成功返回0，出错返回-1
*/

#include <sys/mman.h>

int msync(void* addr, size_t len, int flags);
/*
void* addr：映射区的地址
size_t len：映射区的大小
int flags：标志位
    - MS_ASYNC：执行异步写
    - MS_SYNC：执行同步写
    - MS_INVALIDATE：使高速缓存的数据失效

return：成功返回0，出错返回-1
*/

#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <semaphore.h>
#include <iostream>
#include <string.h>

#define PATH "/home/tmp/mmap_text.txt"
#define SEM_PATH "/tmp"
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
int SIZE = 100;

int main()
{
    char* ptr = (char*)mmap(NULL, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); // 当指定了MAP_ANONYMOUS属性时，代表不需要使用file，因此fd填入-1即可，用在有亲缘关系的进程间的通信
    pid_t pid = fork();
    if (pid == 0)
    {
        char s[SIZE] = "child string";
        memcpy(ptr, s, SIZE);
    }
    else if (pid > 0)
    {
        sleep(1); // 使子进程先写入
        char* ret = new char[SIZE];
        memcpy(ret, ptr, SIZE);
        std::cout << ret << std::endl;
        munmap(ptr, SIZE);
    }
    return 0;
}

#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <semaphore.h>
#include <iostream>
#include <string.h>
#include <sys/stat.h>

#define PATH "/tmp/mmap_text" // 注意该文件要存在，否则会报 Segmentation fault
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

size_t getFileSize(const char* filename)
{
    struct stat st;
    stat(filename, &st);
    return st.st_size;
}

int main()
{
    int fd = open(PATH, O_RDWR); // 这里的模式要是RDWR，同时可读写
    int fileSize = getFileSize(PATH); // 当使用open + mmap时，该大小要通过获取文件配置的方式获得，而shm_open + mmap可以自由指定大小
    char* ptr = (char*)mmap(NULL, fileSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 
    pid_t pid = fork();
    if (pid == 0)
    {
        char s[fileSize] = "child string";
        memcpy(ptr, s, fileSize);
    }
    else if (pid > 0)
    {
        sleep(1); // 让子进程先写入
        char* ret = new char[fileSize];
        memcpy(ret, ptr, fileSize);
        std::cout << ret << std::endl;
        munmap(ptr, fileSize);
        close(fd);
    }
    return 0;
}

#include <sys/mman.h>

int shm_open(const char *name, int oflag, mode_t mode);
/*
const char *name：具体存在的系统路径，以/开头，且只能包含一个/
int oflag：至少要含有只读标志（O_RDONLY），亦或者同时含有读写（O_RDWR），同时可以包含O_CREATE、O_EXCL或O_TRUNC。如果指定了O_RDWR | O_TRUNC，则如果共享内存区对象已经存在，会截断至0长度
mode_t mode：权限位，在指定了O_CREAT标志下生效，如果非创建则填入0即可

return: 成功返回非负描述符，出错返回-1
*/

int shm_unlink(const char *name);
/*
const char *name：路径名

return: 成功返回0，失败返回-1
*/

#include <unistd.h>
int ftruncate(int fd, off_t length);
/*
int fd：描述符
off_t length：目标长度

return：成功返回0，出错返回-1
*/

#include <sys/types.h>
#include <sys/stat.h>

int fstat(int fd, struct stat *buf); 
/*
int fd：描述符
struct stat *buf：该结构体用以存储信息，比如文件的大小等
*/

#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <semaphore.h>
#include <iostream>
#include <string.h>
#include <sys/stat.h>

// 编译：g++ IPC_test.cpp -o bin/IPC_test -lrt

#define PATH "/mmap_text" // 使用open+mmap是要求该文件一定存在，不计较包含了多少个/。
// 使用shm_open + mmap则一定只能包含一个/，因此"/tmp/mmap_text"是错误的，文件可不存在，这里只是作为标识，实际挂载在tmpfs虚拟文件系统，路径在/dev/shm
// 比如这里我们定义的是mmap_text，那么当运行之后就会生成/dev/shm/mmap_text文件
int SIZE = 100;

int main()
{
    int fd = shm_open(PATH, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
    int res = ftruncate(fd, SIZE); // 默认创建之后的size是0,因此一定要先调用ftruncate调整大小
    if (res == -1)
    {
        perror("ftruncate error");
        exit(1);
    }
    char* ptr = (char*)mmap(NULL, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 
    pid_t pid = fork();
    if (pid == 0)
    {
        char s[SIZE] = "child string";
        memcpy(ptr, s, SIZE);
    }
    else if (pid > 0)
    {
        sleep(1); // 让子进程先写入
        char* ret = new char[SIZE];
        memcpy(ret, ptr, SIZE);
        std::cout << ret << std::endl;
        munmap(ptr, SIZE);
        close(fd);
        shm_unlink(PATH);
    }
    return 0;
}

#include <sys/shm.h>

struct shmid_ds
{
    struct ipc_perm shm_perm; // 每个IPC对象的权限设置
    size_t shm_segsz;
    pid_t shm_lpid; // 最后操作该共享内存区的pid
    pid_t shm_cpid; // 创建该共享内存区的pid
    shmatt_t shm_nattch;
    shmat_t shm_cnattch;
    time_t shm_atime;
    time_t shm_dtime;
    time_t shm_ctime;
}

#include <sys/shm.h>
int shmget(key_t key, size_t size, int oflag);
/*
key_t key：通过ftok函数返回的标识符，也可以是IPC_PRIVATE（由内核自行分配唯一的标识符）
size_t size：以字节位单位，如果是创建新的共享内存区，则不为0，否则应该为0
int oflag：IPC_CREAT 或 IPC_CREAT | IPC_EXCL

return：成功返回共享内存区对象的id（shmid），出错返回-1
*/

#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int flag);
/*
int shmid：由shmget返回的标识符
const void *shmaddr：指定的共享内存区地址，一般使用空指针即可，有系统自动选择，如果是非空指针，则由 flag 中的SHM_RND影响
int flag：限定权限

return：成功返回映射区的起始地址，出错返回-1
*/

#include <sys/shm.h>
int shmdt(const void *shmaddr);
/*
const void *shmaddr：由shmat函数返回的共享内存区指针地址

return：成功返回0，出错返回-1
*/

#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buff);
/*
int shmid：标识符
int cmd：命令类型：
    - IPC_RMID：删除共享内存区
    - IPC_SET：设置共享内存区对应的shmid_ds结构的三个成员：shm_perm.uid, shm_perm.gid, shm_perm.mode，这些值由buff参数提供
    - IPC_STAT：将共享内存区当前的shmid_ds结构体属性设置到buff参数中
struct shmid_ds *buff：shmid_ds结构体

return：成功返回0，出错返回-1
*/

#include <sys/shm.h>
#include <unistd.h>
#include <fcntl.h>
#include <semaphore.h>
#include <iostream>
#include <string.h>
#include <sys/stat.h>

// #define PATH "/tmp/system_v_shm" // 这里文件不要求只有一个/,但是要求有文件的权限,因此使用/tmp/system_v_shm需要使用sudo的方式运行
#define PATH "/home/rxsi/system_v_shm" // 这里可以
int SIZE = 100;

int main()
{
     // 对应的文件路径必须要存在,后面的255实际只会用上后8位
    // 因为实际只是通过该文件名获得到对应inode信息，因此文件必要存在且具有访问权限
    key_t key = ftok(PATH, 255);
    if (key == -1)
    {
        perror("ftok error");
        exit(1);
    }
     // 以下三种形式都是借助了tmpfs虚拟文件系统，但是创建的文件是不可见的
    // int shmid = shmget(key, SIZE, IPC_CREAT | SHM_R | SHM_W); // 1.通过 ftok 创建的ID
    // int shmid = shmget(IPC_PRIVATE, SIZE, IPC_CREAT | SHM_R | SHM_W); //2. 可以使用IPC_PRIVATE由内核自行分配
    int shmid = shmget(1234, SIZE, IPC_CREAT | SHM_R | SHM_W); // 3. 自定义序号
    if (shmid == -1)
    {
        perror("shmget error");
        exit(1);
    }
    pid_t pid = fork();
    if (pid == 0)
    {
        struct shmid_ds buff;
        char *ptr = (char*)shmat(shmid, nullptr, 0);
        shmctl(shmid, IPC_STAT, &buff);
        char s[SIZE] = "child string";
        memcpy(ptr, s, SIZE);
        int res = shmdt(ptr);
        if (res == -1)
        {
            perror("shmdt error");
            exit(1);
        }
    }
    else if (pid > 0)
    {
        sleep(1); // 让子进程先写入
        char *ptr = (char*)shmat(shmid, nullptr, 0);
        char* ret = new char[SIZE];
        memcpy(ret, ptr, SIZE);
        std::cout << ret << std::endl;
        int res = shmdt(ptr);
        if (res == -1)
        {
            perror("shmdt error");
            exit(1);
        }
        res = shmctl(shmid, IPC_RMID, nullptr);
        if (res == -1)
        {
            perror("shmctl error");
            exit(1);
        }
    }
    return 0;
}