tar -xavf linux-5.4.1.tar.xz

　　apt-get install libncurses5-dev
　　apt-get install libssl-dev
　　apt-get install bison
　　apt-get install flex
　　apt-get install make

　　vim arch/x86/entry/syscalls/syscall_64.tbl

　　vim include/linux/syscalls.h 

　　vim kernel/sys.c

    make menuconfig

　　tar -xvf ccache-3.6.tar.xz
　　 cd ccache-3.6
　　./configure -prefix=/var/ccache

    make -j4

    make modules

　　make modules_install

　　make install

　　update-grub2

　　reboot

struct pid *find_get_pid(pid_t nr)
{
    struct pid *pid;
    rcu_read_lock();
    pid = get_pid(find_vpid(nr));
    rcu_read_unlock();
    return pid;
}

struct task_struct *pid_task(struct pid *pid, enum pid_type type)
{
    struct task_struct *result = NULL;
    if (pid) {
        struct hlist_node *first;
        first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]),
                          lockdep_tasklist_lock_is_held());
        if (first)
            result = hlist_entry(first, struct task_struct, pid_links[(type)]);
    }
    return result;
}

static __always_inline unsigned long __must_check copy_to_user(void __user *to, const void *from, unsigned long n)
{
    if (likely(check_copy_size(from, n, true)))
        n = _copy_to_user(to, from, n);
    return n;
}

static inline int task_nice(const struct task_struct *p)
{
    return PRIO_TO_NICE((p)->static_prio);
}

void set_user_nice(struct task_struct *p, long nice)
{
    bool queued, running;
    int old_prio, delta;
    struct rq_flags rf;
    struct rq *rq;

    if (task_nice(p) == nice || nice < MIN_NICE || nice > MAX_NICE)
        return;
    /*
     * We have to be careful, if called from sys_setpriority(),
     * the task might be in the middle of scheduling on another CPU.
     */
    rq = task_rq_lock(p, &rf);
    update_rq_clock(rq);

    /*
     * The RT priorities are set via sched_setscheduler(), but we still
     * allow the ‘normal‘ nice value to be set - but as expected
     * it wont have any effect on scheduling until the task is
     * SCHED_DEADLINE, SCHED_FIFO or SCHED_RR:
     */
    if (task_has_dl_policy(p) || task_has_rt_policy(p)) {
        p->static_prio = NICE_TO_PRIO(nice);
        goto out_unlock;
    }
    queued = task_on_rq_queued(p);
    running = task_current(rq, p);
    if (queued)
        dequeue_task(rq, p, DEQUEUE_SAVE | DEQUEUE_NOCLOCK);
    if (running)
        put_prev_task(rq, p);

    p->static_prio = NICE_TO_PRIO(nice);
    set_load_weight(p, true);
    old_prio = p->prio;
    p->prio = effective_prio(p);
    delta = p->prio - old_prio;

    if (queued) {
        enqueue_task(rq, p, ENQUEUE_RESTORE | ENQUEUE_NOCLOCK);
        /*
         * If the task increased its priority or is running and
         * lowered its priority, then reschedule its CPU:
         */
        if (delta < 0 || (delta > 0 && task_running(rq, p)))
            resched_curr(rq);
    }
    if (running)
        set_curr_task(rq, p);
out_unlock:
    task_rq_unlock(rq, p, &rf);
}

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/moduleparam.h>
#include <linux/pid.h>
#include <linux/list.h>
#include <linux/sched.h>
MODULE_LICENSE("GPL");
static int pid;
module_param(pid, int, 0644);
static int __init show_task_family_init(void)
{
    struct pid *ppid;
    struct task_struct *p;
    struct task_struct *pos;
    char *ptype[4] = {"[I]", "[P]", "[S]", "[C]"};
    // 通过进程的PID号pid一步步找到进程的进程控制块p
    ppid = find_get_pid(pid);
    if (ppid == NULL){
        printk("[ShowTaskFamily] Error, PID not exists.\n");
        return -1;
    }
    p = pid_task(ppid, PIDTYPE_PID);
    // 格式化输出表头
    printk("%-10s%-20s%-6s%-6s\n", "Type", "Name", "PID", "State");// Itself
    // 打印自身信息
    printk("%-10s%-20s%-6d%-6d\n", ptype[0], p->comm, p->pid, p->state);
    // Parent
    // 打印父进程信息
    printk("%-10s%-20s%-6d%-6d\n", ptype[1], p->real_parent->comm,
           p->real_parent->pid, p->real_parent->state);
    // Siblings
    // 遍历父进程的子，即我的兄弟进程，输出信息
    // “我”同样是父进程的子进程，所以当二者进程PID号一致时，跳过不输出
    list_for_each_entry(pos, &(p->real_parent->children), sibling){
        if (pos->pid == pid)
            continue;
        printk("%-10s%-20s%-6d%-6d\n", ptype[2], pos->comm, pos->pid,
               pos->state);
    }
    // Children
    // 遍历”我“的子进程，输出信息
    list_for_each_entry(pos, &(p->children), sibling){
        printk("%-10s%-20s%-6d%-6d\n", ptype[3], pos->comm, pos->pid,
               pos->state);
    }
    return 0;
}
static void __exit show_task_family_exit(void){
    printk("[ShowTaskFamily] Module Uninstalled.\n");
}
module_init(show_task_family_init);
module_exit(show_task_family_exit);

obj-m := show_task_family.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
    make -C $(KDIR) M=$(PWD) modules
clean:
    make -C $(KDIR) M=$(PWD) clean

pstree -p

#define for_each_process(p)     for (p = &init_task ; (p = next_task(p)) != &init_task ; )

/*
    struct task_struct *pos;
    list_for_each_entry(pos, &pos->children, sibling);
*/

#define list_for_each_entry(pos, head, member)                    for (pos = __container_of((head)->next, pos, member);             &pos->member != (head);                         pos = __container_of(pos->member.next, pos, member))

#define container_of(ptr, type, member) ({            \
        const typeof(((type *)0)->member) * __mptr = (ptr);            (type *)((char *)__mptr - offsetof(type, member)); })

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

#define CMD_COLLECTION_LEN 4 //命令数组的长度（有哪几个命令）

//command index
#define INVALID_COMMAND    -1 //无效命令返回-1
#define EXIT    0
#define CMD_1 1
#define CMD_2 2
#define CMD_3 3

char *cmdStr [CMD_COLLECTION_LEN ]= {"exit","cmd1","cmd2","cmd3"};


//对比所有命令参数，如果有一样的，就返回对应数字，用于后面执行
int getCmdIndex(char *cmd)
{
    int i;

    //遍历数组寻找命令
     for(i=0;i<CMD_COLLECTION_LEN;i++){
        if (strcmp(cmd,cmdStr[i])==0){
            return i;
        }
    }

    return INVALID_COMMAND;
}


/*
创建子进程，这里使用了execl，后面的l表示list，即参数列表。
第一参数为path（要执行的文件路径），最后一个参数必须是NULL，
中间的为要传送的参数
*/
void myFork(int cmdIndex)
{
    pid_t pid;    //即 int

    if((pid = fork())<0){
        printf("Fork subprocess failure!\n");
         exit(0);
    }
    else if (pid == 0){
        int execl_status = -1;    //初始化为-1

        printf("\nSubprocess working...\n");

        switch(cmdIndex){
            case CMD_1:
                execl_status = execl("./cmd1","cmd1",NULL);    //函数执行不成功返回-1
                break;
            case CMD_2:
                execl_status = execl("./cmd2","cmd2",NULL);
                break;
            case CMD_3:
                execl_status = execl("./cmd3","cmd3",NULL);
                break;
            default:
                printf("ERROR! Command NOT FOUND!\n");
                break;
        }
        
        // 返回值为-1则表明出错
         if(execl_status<0){
            printf("Executing execl() ERROR!\n");
            exit(0);
        }
        else{
            printf("Process complete!\n");
            exit(0);
        }
    }
    else{
        return;
    }
}


//运行cmd
void runCMD(int cmdIndex)
{
    switch(cmdIndex){
        case INVALID_COMMAND:
            printf("Command Not Found!\n");
            break;
        case EXIT:
            exit(0);
            break;
        default:
            myFork(cmdIndex);
            break;
    }
}


int main()
{
    pid_t pid;
    char cmdStr[30]; //命令数组（最长30）
    int cmdIndex; //用于显示运行哪个数据

    while(1){
        printf("\nPlease input command\n>>:");
        scanf("%s",cmdStr);
        cmdIndex = getCmdIndex(cmdStr);
        runCMD(cmdIndex);
        wait(0);
    }
}

#include <errno.h>
#include <fcntl.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#define BUF_MAX_SIZE 8192
#define CHECK(x)                                                do {                                                            if (!(x)) {                                                     fprintf(stderr, "%s:%d: ", __func__, __LINE__);             perror(#x);                                                 exit(-1);                                               }                                                       } while (0)

/**
    无名管道用于具有的亲缘关系的进程，父子兄弟进程。
    
    在阻塞方式下，若设备不可读写，则该进程休眠，释放CPU资源；若设备文件可读写，则对设备文件进行读写。
    在非阻塞方式下，若设备不可读写，进程放弃读写，继续向下执行；若设备文件可读写，则对设备文件进行读写。

    简而言之：  非阻塞读写要加入判断语句(在管道满无法继续写入时返回-EAGAIN，作为循环终止条件)；
                而阻塞型读写在指定读写量后自行终止。

    阻塞方式，使用‘Posix信号量‘机制辅以实现对管道的读写使用；非阻塞方式使用‘循环+判断‘机制实现读写的终止
*/
 
int main(int argc, char **argv) {
    int pipefd[2], pid, i = 0;    //0读，1写
    int flag = 0;    //文件状态标志
    ssize_t n;    // aka. long int
    char buf[BUF_MAX_SIZE];//用作write的缓冲区，保存写入的字符
    char str[BUF_MAX_SIZE];//用作read的缓冲区，保存读取的字符

    //创建有名信号量，若不存在则创建，若存在则直接打开，默认值为0
    sem_t *write_mutex;//限制了父进程先读取数据，然后子进程二、三写入数据
    sem_t *read_mutex1;//限制了子进程2 写入数据 2，然后父进程读取数据 2
    sem_t *read_mutex2;//限制了子进程3 写入数据 3，然后父进程读取数据 3
    
    write_mutex = sem_open("pipe_test_wm", O_CREAT | O_RDWR, 0666, 0);//创建|读写方式打开，权限位，初始值=0(为了确保子进程一拿到信号量，防止子进程二、三抢占)
    read_mutex1 = sem_open("pipe_test_rm_1", O_CREAT | O_RDWR, 0666, 0);
    read_mutex2 = sem_open("pipe_test_rm_2", O_CREAT | O_RDWR, 0666, 0);

    //字符置换函数，内存空间初始化0
    memset(buf, 0, BUF_MAX_SIZE);
    memset(str, 0, BUF_MAX_SIZE);

    // 创建匿名管道并检查操作是否成功
    CHECK(pipe(pipefd) >= 0);

    // 创建第一个子进程并检查操作是否成功
    CHECK((pid = fork()) >= 0);

    // 第一个子进程，利用非阻塞写测试管道大小
    if (pid == 0) {
        int count = 0;
        close(pipefd[0]);//close reading
    //F_GETFL获取文件状态标志
        int flags = fcntl(pipefd[1], F_GETFL);//FCNTL()控制已打开文件的的各种属性

        // 新建的匿名管道默认是阻塞写，通过`fcntl`设置成非阻塞写，在管道满无法继续写入时返回-EAGAIN，作为循环终止条件
        fcntl(pipefd[1], F_SETFL, flags | O_NONBLOCK);//F_SETFL设置文件状态标志,非阻塞写

        // 写入管道
        printf("\n>>Child1 (非阻塞写):\n");
        while (!flag) {
    //从缓冲器中向pipefd[1]的偏移量后写入buf中的BUF_MAX_SIZE字节，直到无法继续写入
    //成功则返回写入的字节数，若出错则返回-1
            n = write(pipefd[1], buf, BUF_MAX_SIZE);
            if (n == -1) {
                flag = 1;
            } else {
                count++;
                printf("write %ld B to pipe\n", n);
            }
        }
        printf("\nDefault pipe size = %d KB\n", (count * BUF_MAX_SIZE) / 1024);//打印8times,64kb.
        exit(0);
    }

    // 创建第二个子进程并检查操作是否成功
    CHECK((pid = fork()) >= 0);
    if (pid == 0) {
        sem_wait(write_mutex);//父进程先读子进程一，子进程二再写
        close(pipefd[0]);//关闭管道读端
        n = write(pipefd[1], "This is the second child.\n", 28);//子进程二、三均为阻塞性写
        printf("\n>>Child 2 (阻塞写):\nwrite %ld B to pipe\n", n);
        sem_post(write_mutex);//子进程二写完成
        sem_post(read_mutex1);//父进程读进程二
        exit(0);
    }

    // 创建第三个子进程并检查操作是否成功
    CHECK((pid = fork()) >= 0);
    if (pid == 0) {
        sem_wait(write_mutex);//请求管道write
        close(pipefd[0]);
        n = write(pipefd[1], "This is the third child.\n", 18);
        printf("\n>>Child 3 (阻塞写):\nwrite %ld B to pipe\n", n);
        sem_post(write_mutex);//子进程三写完成
        sem_post(read_mutex2);//父进程读进程三
        exit(0);
    }

    //父进程必须接收到子进程结束之后返回的 0，才能继续运行，否则阻塞。
    //读取子进程一写入的数据，否则子进程二、三无法继续写入.
    //读空管道后结束循环，释放信号量，子进程二、三继续运行。
    wait(0);
    close(pipefd[1]);//关闭管道wirte端
    int flags = fcntl(pipefd[0], F_GETFL);//F_GETFL获取文件状态标志；出错返回－1

    // 设置非阻塞性读，直到不能再读入，作为循环结束标志
    fcntl(pipefd[0], F_SETFL, flags | O_NONBLOCK);
    
    printf("\n>>Father (非阻塞读):\n");
    while (!flag) {
        n = read(pipefd[0], str, BUF_MAX_SIZE);
        if (n == -1) {
            flag = 1;
        } else {
            printf("read %ld B from pipe\n", n);
        }
    }
    
    fcntl(pipefd[0], F_SETFL, flags | ~O_NONBLOCK);// 设置阻塞性读，作为循环结束标志
    printf("\n>>Father (阻塞读):\n");
    
    fcntl(pipefd[1], F_SETFL, flags | ~O_NONBLOCK);// 设置阻塞性写
    sem_post(write_mutex);//子进程二、三继续写入
    
    
    // 等待子进程二、三写入完毕,输出子进程二三写入的数据
    sem_wait(read_mutex1);
    sem_wait(read_mutex2);
    n = read(pipefd[0], str, BUF_MAX_SIZE);//返回实际读取的数据大小
    printf("\n>>Father:\nread %ld B from pipe (actual size)\n\nThe contents are:\n", n);
    for (i = 0; i < n; i++) {
        printf("%c", str[i]);
    }
    printf("\n\n注：以上读写字节数均为‘实际读写字节数‘\n");

    //关闭信号量
    sem_close(write_mutex);
    sem_close(read_mutex1);
    sem_close(read_mutex2);
    //系统中删除有名信号量
    sem_unlink("pipe_test_wm");
    sem_unlink("pipe_test_rm_1");
    sem_unlink("pipe_test_rm_2");
    return 0;
}

/*
    本次实验采用了3个semaphore信号量，但是我认为完全可以采用flag机制
    (可参考实验3-4对flag机制使用) 这样做更加便于理解，直接设置3个信号量
    过一段时间自己写的是啥都忘了...重新看一遍会耗费时间
*/
#include <pthread.h>
#include <semaphore.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define TRUE 1

#define BUF_SIZE 128    // maxium message size
#define KEY_NUM 0    // assign key number

//int f = 0;    // count finished senders (f==2: all threads abort) ; aka. ‘flag‘, which has been utilized in Receiver
int sender_id = 0;    // [Improvement] if Sender1 sent ‘end2‘, Sender2 would not be aborted
int msgid;    // message id

// message buffer struct; in order to simulate msgbuf in Linux, we added attribute ‘mtype‘, actually it is unnecessary in this project
typedef struct msgbuf
{
    long int mtype;        // unsigned long type,>0, receive function used it to confirm message type 
    char mtext[BUF_SIZE];    // 128,message content
}msgbuf;

sem_t full;        // whether message queue is full  (whether available for receiver)
sem_t empty;    // whether message queue is empty (whether available for sender)
sem_t mutex;    // whether message queue available

key_t key; // only match one queue


// Receiver
void * Receiver(void *arg)
{
    msgbuf msg;
    msg.mtype = 1;    // define mtype as type "1"; it is unnecessary, could be eliminated
    
    int flag=0;        // judge if it reached ends
    
    while(TRUE)
    {
        sem_wait(&full);    // wait for message queue full (available for Receiver)
        sem_wait(&mutex);    // wait for message queue available
        
        msgrcv(msgid,&msg,sizeof(msgbuf),1,0);        // mtype=1, 0: ignore (to control if no appointed mtype mathched); Function Prototype: int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg)
        printf("\n\n>>Receiver: %s\n",msg.mtext);
        
        if(strcmp(msg.mtext,"end1") == 0 && sender_id == 1) // [Improvement]
        {
            msg.mtype = 2;    // change mtype to 2, abort Sender1
            strncpy(msg.mtext,"over1",BUF_SIZE);    // aka. msg->mtext = over1, yet C does not confirm this writing style
            msgsnd(msgid,&msg,sizeof(msgbuf),0);    // fourth parameter: 0->ignore zone bit
            sem_post(&mutex);
            flag++;        // Sender1 ended
        }
        else if(strcmp(msg.mtext,"end2") == 0 && sender_id == 2)
        {
            msg.mtype = 3;    // change mtype to 3, abort Sender2
            strncpy(msg.mtext,"over2",BUF_SIZE);
            msgsnd(msgid,&msg,sizeof(msgbuf),0);
            sem_post(&mutex);
            flag++;        // Sender2 ended
        }
        else{
            sem_post(&empty);    // message queue empty (Receiver has received message)
            sem_post(&mutex);    // message queue available
        }
        
        // exit
        if(flag == 2){
            sleep(1);
            sem_destroy(&full);
            sem_destroy(&empty);
            sem_destroy(&mutex);
            exit(EXIT_SUCCESS);
        }
    }
}

// Sender1
void * Sender1(void *arg)
{
    char str[BUF_SIZE];
    int flag = 0;    // [Improvement] after ‘exit‘,flag=1,which means no longer send message
    msgbuf msg;
    
    while (TRUE)
    {
        msg.mtype = 1;
        
        sem_wait(&empty);    // wait for message queue empty (available for Sender)
        sem_wait(&mutex);    // wait for message queue available
        
        if(flag == 0){
            printf("\n\n>>Sender1\nPlease input the message you want to send:\n");
            scanf("%s", str);
            while(getchar()!=‘\n‘);
        }
        else{
            while(1){
                printf("\n\n>>Sender1\nFrom now on, you could not enter message but ‘end1‘\n");
                scanf("%s", str);
                while(getchar()!=‘\n‘);
                if( strcmp(str,"end1") == 0 )
                    break;
            }
        }
        
        if( strcmp(str,"end1") == 0 && flag == 1) {
            sender_id = 1;    // being utilized in the improvement part
            strncpy(msg.mtext,str,BUF_SIZE);
            msgsnd(msgid,&msg,sizeof(msgbuf),0);
            sem_post(&full);
            sem_post(&mutex);
            sleep(0.5);
            sem_wait(&mutex);
            msgrcv(msgid,&msg,sizeof(msgbuf),2,0);
            printf("\nFrom Receiver: %s\n", msg.mtext);
            sem_post(&empty);
            sem_post(&mutex);
            break;
        }
        else if(strcmp(str,"exit") == 0 && flag == 0){
            printf("Sender1 exit\n");
            flag = 1;    // no longer send message
            sem_post(&empty);    // Sender2 is available
            sem_post(&mutex);
            sleep(1);    // Switch to Sender2
        }
        else if(strcmp(str,"end1") != 0 && flag == 0){
            sender_id = 1;    // being utilized in the improvement part
            strncpy(msg.mtext,str,BUF_SIZE);
            msgsnd(msgid,&msg,sizeof(msgbuf),0);
            sem_post(&full);    // message queue full (message has been sent to the queue)
            sem_post(&mutex);    // message queue available
        }
        else{
            printf("\nPlease input ‘exit‘ before entering ‘end1‘ or ‘end2‘\n");
            sem_post(&empty);
            sem_post(&mutex);
        }
    }
    
}

// Sender2
void * Sender2(void *arg)
{
    char str[BUF_SIZE];
    int flag = 0;
    msgbuf msg;
    
    while (TRUE)
    {
        msg.mtype = 1;
        
        sem_wait(&empty);    // wait for message queue empty (available for Sender)
        sem_wait(&mutex);    // wait for message queue available
        
        if(flag == 0){
            printf("\n\n>>Sender2\nPlease input the message you want to send:\n");
            scanf("%s", str);
            while(getchar()!=‘\n‘);
        }
        else{
            while(1){
                printf("\n\n>>Sender2\nFrom now on, you could not enter message but ‘end2‘\n");
                scanf("%s", str);
                while(getchar()!=‘\n‘);
                if( strcmp(str,"end2") == 0 )
                    break;
            }
        }
        
        if( strcmp(str,"end2") == 0 && flag == 1) {
            sender_id = 2;    // being utilized in the improvement part
            strncpy(msg.mtext,str,BUF_SIZE);
            msgsnd(msgid,&msg,sizeof(msgbuf),0);
            sem_post(&full);
            sem_post(&mutex);
            sleep(0.5);
            sem_wait(&mutex);
            msgrcv(msgid,&msg,sizeof(msgbuf),3,0);
            printf("\nFrom Receiver: %s\n", msg.mtext);
            sem_post(&empty);
            sem_post(&mutex);
            break;
        }
        else if(strcmp(str,"exit") == 0 && flag == 0){
            printf("Sender2 exit\n");
            flag = 1;    // no longer send message
            sem_post(&empty);    // Sender1 is available
            sem_post(&mutex);
            sleep(1);    // Switch to Sender1
        }
        else if(strcmp(str,"end2") != 0 && flag == 0){
            sender_id = 2;    // being utilized in the improvement part
            strncpy(msg.mtext,str,BUF_SIZE);
            msgsnd(msgid,&msg,sizeof(msgbuf),0);
            sem_post(&full);    // message queue full (message has been sent to the queue)
            sem_post(&mutex);    // message queue available
        }
        else{
            printf("\nPlease input ‘exit‘ before entering ‘end1‘ or ‘end2‘\n");
            sem_post(&empty);
            sem_post(&mutex);
        }
    }
    
}


int main()
{
    pthread_t sender_pid;
    pthread_t receiver_pid;

    sem_init(&full,0,0);    // first 0: multi-thread synchronization; second 0: initial value
    sem_init(&empty,0,1);
    sem_init(&mutex,0,1);

    key = KEY_NUM;    // assign ‘key‘ value
    
    // first parameter: match the key of message queue; second parameter: user read/ write/ create if not exist
    if((msgid = msgget(key, S_IRUSR | S_IWUSR | IPC_CREAT)) == -1)
    {
        printf("Create Message Queue Error!\n");
        exit(EXIT_FAILURE);        // abnormal exit
    }
    else{
        printf("Create Message Queue Complete!\n\n");
    }
    
    pthread_create(&sender_pid,NULL,Sender1,NULL);    // second parameter: attributes (prio/size...), default is NULL;    
    pthread_create(&sender_pid,NULL,Sender2,NULL);    // third parameter: execute function (indicator function)
    pthread_create(&receiver_pid,NULL,Receiver,NULL);    // fourth parameter: thread execution parameter
    
    pthread_join(sender_pid,NULL);    // waiting for the thread end
    pthread_join(receiver_pid,NULL);
    
    msgctl(msgid,IPC_RMID,NULL);
    printf("\n\nMain Function End...\n");

    return 0;
}

/*
    经过实验三中第三个小实验的经历，我认为信号量机制的实现不必要引用系统提供的semaphore，
    可以直接在共享内存空间中引入flag变量，以实现共享内存控制机制;
    
    这样做有比直接使用semaphore更为改进之处：
    1. 系统提供的信号量机制只能实现 True or False，但是flag变量可以实现0,1,2三种变量，控制更为直观;
    2. 程序可以写在多个文件中，不需要在一串代码中完成，便于更加直观的调试
    (虽然不可否认使用semaphore机制也可以实现 --- 增加判断语句判定终止条件)
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <string.h>
 
void *pAddr;
int shmId;

//共享内存
struct Msg{
    int flag;    // 0:Read; 1:Write; 2:Cease
    char content[32];
};

// Sender
void main(){
    key_t key = ftok(".",2);
    //key_t key = 123456;    //也可以直接给出key值，只要保证和Sender中的一样即可
    shmId = shmget(key,128,IPC_CREAT | IPC_EXCL | 0666);
    pAddr = shmat(shmId,0,0);
    if(*(int *)pAddr == -1){
        printf("shmat error!\n"); 
        exit(0);
    }

    struct Msg * msg = (struct Msg *)pAddr;
    memset(pAddr,0,128);
    msg->flag = 1; //只写
    
    while(1){
        
        if(msg->flag == 1){
            printf("\nFrom Receiver:\n");
            printf("%s",msg->content); //这里改为gets()等函数可以实现语句的输入，并在后续传输整个句子，不局限于一个单词
            printf("\n\n>>Sender\nPlease input contents:\n");
            scanf("%s", msg->content);
            msg->flag = 0; //只读
        }
        
        else if(msg->flag == 2){ //strcmp(msg->content,"over") == 0
            printf("\n>>Sender\nFrom Receiver: over!\n");
            shmdt(pAddr);
            shmctl(shmId,IPC_RMID,0);
            exit(0);
        }
    }

}

/*
    经过实验三中第三个小实验的经历，我认为信号量机制的实现不必要引用系统提供的semaphore，
    可以直接在共享内存空间中引入flag变量，以实现共享内存控制机制;
    
    这样做有比直接使用semaphore更为改进之处：
    1. 系统提供的信号量机制只能实现 True or False，但是flag变量可以实现0,1,2三种变量，控制更为直观;
    2. 程序可以写在多个文件中，不需要在一串代码中完成，便于更加直观的调试
    (虽然不可否认使用semaphore机制也可以实现 --- 增加判断语句判定终止条件)
*/


#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <string.h>

void *pAddr; //新建指针，用以指向当前进程地址
int shmId; //共享内存ID
 
struct Msg
{
    int flag;    // 0:Read; 1:Write; 2:Cease
    char content[32];
};


// Server
void main()
{

    key_t key = ftok(".",2);    //把当前文件路径名和一个整数标识符转换成IPC的key值，以保证和clint中的共享内存一致；第二个参数：计划代号
    //key_t key = 123456;    //也可以直接给出key值，只要保证和Sender中的一样即可
    shmId = shmget(key,0,0);    //如果没有该块共享内存，则创建、并返回共享内存ID；若已有该块共享内存，则返回-1
    
    pAddr = shmat(shmId,0,0);    //共享内存连接到当前进程的地址空间
    if(*(int *)pAddr == -1)
    {
        printf("shmat error!\n"); 
        exit(0);
    }

    struct Msg *msg = (struct Msg *)pAddr;
    
    while(1)
    {
        if(msg->flag == 0)    //只读
        {
            printf("\n\n>>Receiver\n\nFrom sender: %s\n", msg->content);
            printf("Please response (you may enter ‘over‘ to abort the process):\n");
            scanf("%s", msg->content);
            if(strcmp(msg->content,"over") == 0){
                msg->flag = 2;    //通知Sender共享内存结束
                exit(0);
            }
            else{
                msg->flag = 1; //进程未结束，继续从Sender获取讯息
            }
        }
    }
    
}