{

  pid t_pid；/* 进程标识符 */

  unsigned int time_slice /* 调度信息 */

  struct task_struct* 父进程；/* 此进程的父级 */

  struct list_head children；/* 此进程的子进程 */

  struct *files；/* 打开文件列表 */

  struct mm_struct*mm；/* 此进程的地址空间 */

  ...

}

#include<stdio.h>

#include<unistd.h>

int main (){

  for(int i=0;i<4;++i){

    fork();

  }

	printf("This is a test printed by %d\n", getpid());

return 0;

}

#include<stdio.h>

#include<unistd.h>

int main(void) {

	printf("before execl ...\n"); // 原进程代码可以执行

	execl("/bin/ls", "/bin/ls", NULL); //exec 的一个成员函数

	printf("after execl ...\n"); // 原进程代码无法执行

	return 0;

}

#include<stdio.h>

#include<unistd.h>

int system_test(const char *cmd_str) {

    if(cmd_str == -1)

        return -1;

    if(fork() == 0) {

        execl(cmd_str, cmd_str, NULL);

        fprintf(stderr,"%s: command not found\n", cmd_str);

        exit(-1);

    }

    return 0;

}

int main(void) {

    printf("before...\n\n");

    system_test("/bin/ls");

    printf("\nafter...\n");

    return 0;

}

#include<stdio.h>

#include<unistd.h>

int system_test(const char *cmd_str) {

    if (cmd_str == -1)

        return -1;

    if(fork() == 0) {

        execl("/bin/sh", "/bin/sh","-c", cmd_str, NULL);

        fprintf(stderr,"%s: command not found\n", cmd_str);

        exit(-1);

    }

    wait(NULL);

    return 0;

}

int main(void) {

    printf ("before...\n\n"); system_test("/bin/1s");

    printf("\nafter...\n");

    return 0;

}

#include<stdio.h>

#include<unistd.h>

#include<stdlib.h>

int main(void){

    int count = 1;

    pid_t childpid, terminatedid;

    childpid = fork(); /* child duplicates parent’s address space */

    if (childpid < 0) {

        perror("fork()");

        return EXIT_FAILURE;

    }

    else if (childpid == 0) { /* This is child pro */

        count++;

        printf("child pro pid = %d, count = %d (addr = %p)\n", getpid(), count, &count);

        printf("child sleeping ...\n");

        sleep(5); /* parent wait() during this period */

        printf("\nchild waking up!\n");

    }

    else { /* This is parent pro */

        terminatedid = wait(0);

        printf("parent pro pid = %d, terminated pid = %d, count = %d (addr = %p)\n",

        getpid(), terminatedid, count, &count);

    }

    printf("\nTesting point by %d\n", getpid()); /* executed by child and parent */

    return EXIT_SUCCESS;

}

//shm 即 share memory 的缩写

int shm_open (...);

// 通过 shm_open 系统调用，申请一片共享内存区

void * mmap (...);

// 通过 mmap 系统调用，将共享内存区映射到进程自己的地址空间

#include <sys/shm.h>

key_t ftok(const char *pathname, int id);

/* key_t is of type int. ftok() convert a pathname and a project identifie

to an IPC key */

key_t key = ftok(“/home/myshm", 0x27);

if((key == -1) {

	perror(“ftok()");

} else

	printf("key = 0x%x\n", key);

int shmget(key_t key, int size, int shmflg);

/* shmget() allocates a shared memory segment */

/* upper bound of size: 1.9G */

int shmid = shmget(IPC_PRIVATE, 4096, IPC_CREATE|IPC_EXCL|0660);

if(shmid == -1) {

  perror("shmget()");

}

#define TEXT_SIZE 512

/* considering

------ Messages Limits --------

max queues system wide = 32000

max size of message (bytes) = 8192

default max size of queue (bytes) = 16384

------------------------------------------

The size of message is set to be 512, the total number of messages is 16384/512 = 32

If we take the max size 8192, the number would be 16384/8192 = 2. It is not reasonable

*/

/* message structure */

struct msg_struct {

long int msg_type;

char mtext[TEXT_SIZE]; /* binary data */

};

#define PERM S_IRUSR|S_IWUSR|IPC_CREAT

#define ERR_EXIT(m) \

  do { \

    perror(m); \

    exit(EXIT_FAILURE); \

  } while(0)

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/msg.h>

#include <sys/stat.h>

#include <fcntl.h>

#include "msgdata.h"

int main(int argc, char *argv[])

{

  struct msg_struct data;

  long int msg_type;

  char buffer[TEXT_SIZE], pathname[80];

  int msqid, ret, count = 0;

  key_t key;

  FILE *fp;

  struct stat fileattr;

  if(argc < 2) {

    printf("Usage: ./a.out pathname\n");

    return EXIT_FAILURE;

  }

  strcpy(pathname, argv[1]);

  if(stat(pathname, &fileattr) == -1) {

    ret = creat(pathname, O_RDWR);

    if (ret == -1) {

    	ERR_EXIT("creat()");

    }

    printf("shared file object created\n");

  }

  key = ftok(pathname, 0x27); /* project_id can be any nonzero integer */

  if(key < 0) {

  	ERR_EXIT("ftok()");

  }

  printf("\nIPC key = 0x%x\n", key);

  msqid = msgget((key_t)key, 0666 | IPC_CREAT);

  if(msqid == -1) {

  	ERR_EXIT("msgget()");

  }

  fp = fopen("./msgsnd.txt", "rb");

  if(!fp) {

  	ERR_EXIT("source data file: ./msgsnd.txt fopen()");

  }

  struct msqid_ds msqattr;

  ret = msgctl(msqid, IPC_STAT, &msqattr);

  printf("number of messages remainded = %ld, empty slots = %ld\n",

  msqattr.msg_qnum, 16384/TEXT_SIZE-msqattr.msg_qnum);

  printf("Blocking Sending ... \n");

  while (!feof(fp)) {

    ret = fscanf(fp, "%ld %s", &msg_type, buffer);

    if (ret == EOF) break;

    printf("%ld %s\n", msg_type, buffer);

    data.msg_type = msg_type;

    strcpy(data.mtext, buffer);

    ret = msgsnd(msqid, (void *)&data, TEXT_SIZE, 0);

    /* 0: blocking send, waiting when msg queue is full */

    if(ret == -1) {

    	ERR_EXIT("msgsnd()");

    }

    count++;

  }

  printf("number of sent messages = %d\n", count);

  fclose(fp);

  system("ipcs -q");

  exit(EXIT_SUCCESS);

}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/msg.h>

#include <sys/stat.h>

#include "msgdata.h"

int main(int argc, char *argv[])

{

  key_t key;

  struct stat fileattr;

  char pathname[80];

  int msqid, ret, count = 0;

  struct msg_struct data;

  long int msgtype = 0; /* 0 - type of any messages */

  if(argc < 2) {

    printf("Usage: ./msgrcv pathname msg_type\n");

    return EXIT_FAILURE;

  }

  strcpy(pathname, argv[1]);

  if(stat(pathname, &fileattr) == -1) {

  	ERR_EXIT("shared file object stat error");

  }

  if((key = ftok(pathname, 0x27)) < 0) {

  	ERR_EXIT("ftok()");

  }

  printf("\nIPC key = 0x%x\n", key);

  msqid = msgget((key_t)key, 0666); /* do not create a new msg queue */

  if(msqid == -1) {

  	ERR_EXIT("msgget()");

  }

  if(argc < 3)

  	msgtype = 0;

  else {

  	msgtype = atol(argv[2]);

  	if (msgtype < 0)

 			msgtype = 0;

  } /* determin msgtype (class number) */

  printf("Selected message type = %ld\n", msgtype);

  while (1) {

    ret = msgrcv(msqid, (void *)&data, TEXT_SIZE, msgtype, IPC_NOWAIT);

    /* Non_blocking receive */

    if(ret == -1) { /* end of this msgtype */

      printf("number of received messages = %d\n", count);

      break;

    }

    printf("%ld %s\n", data.msg_type, data.mtext);

    count++;

  }

  struct msqid_ds msqattr;

  ret = msgctl(msqid, IPC_STAT, &msqattr);

  printf("number of messages remainding = %ld\n", msqattr.msg_qnum);

  if(msqattr.msg_qnum == 0) {

  	printf("do you want to delete this msg queue?(y/n)");

  if (getchar() == 'y') {

    if(msgctl(msqid, IPC_RMID, 0) == -1)

    	perror("msgctl(IPC_RMID)");

    }

  }

  system("ipcs -q");

  exit(EXIT_SUCCESS);

}

#include <mqueue.h>

# Open, Close and Unlink

mqd_t mq_open(const char *name, int oflag, mode_t mode, struct mq_attr *attr ); /* return the mqdes, or -1 if failed */

mqd_t mqID;

mqID = mq_open("/anonymQueue", O_RDWR | O_CREAT, 0666, NULL);

mqd_t mq_close(mqd_t mqdes);

mqd_t mq_unlink(const char *name); /* return -1 if failed */

# Send and Receive

mqd_t mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio); /* return 0, or -1 if failed */

mq_send(mqID, msg, sizeof(msg), i)

mqd_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio); /* return the number of char received, or -1 if failed */

mq_attr mqAttr;

mq_getattr(mqID, &mqAttr);

mq_receive(mqID, buf, mqAttr.mq_msgsize, NULL)

#include <sys/types.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#define BUFFER SIZE 25

#define READ END 0

#define WRITE END 1

int main(void)

{

  char write msg[BUFFER SIZE] = "Greetings";

  char read msg[BUFFER SIZE];

  int fd[2];

  pid t pid;

  /* Program continues in Figure 3.22 */

  /* create the pipe */

  if (pipe(fd) == -1) {

    fprintf(stderr,"Pipe failed");

    return 1;

  }

  /* fork a child process */

  pid = fork();

  if (pid < 0) { /* error occurred */

    fprintf(stderr, "Fork Failed");

    return 1;

  }

  if (pid > 0) { /* parent process */

    /* close the unused end of the pipe */

    close(fd[READ END]);

    /* write to the pipe */

    write(fd[WRITE END], write msg, strlen(write msg)+1);

    /* close the write end of the pipe */

    close(fd[WRITE END]);

  }

  else { /* child process */

    /* close the unused end of the pipe */

    close(fd[WRITE END]);

    /* read from the pipe */

    read(fd[READ END], read msg, BUFFER SIZE);

    printf("read %s",read msg);

    /* close the read end of the pipe */

    close(fd[READ END]);

  }

  return 0;

}

// 普通管道

int pipefd[2];

int pipe(int pipefd);

int fcntl(int pipefd[0|1], int cmd);

int fcntl(int pipefd[0|1], int cmd, long arg);

ssize_t write(int pipefd[1], void* buf, size_t count);

ssize_t read(int pipefd[0], void* buf, size_t count);

close(pipefd[0]);

close(pipefd[1]);

// 命名管道

#define FIFO pathname /* pathname: "/tmp/my_fifo" */

unlink(FIFO); /*delete a name and possibly the file it refers to */

mkfifo(FIFO, 0666);

int fdw = open(FIFO, O_RDWR);

mkfifo(FIFO, 0444);

int fdr = open(FIFO, O_RDONLY);

ssize_t write(int fdw, void* buf, size_t count);

/* ssizt_t = signed int, sizt_t = unsigned int */

ssize_t read(int fdr, void* buf, size_t count);

close(fdw);

close(fdr);

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#define ERR_EXIT(m) \

  do { \

    perror(m); \

    exit(EXIT_FAILURE); \

  } while (0)

int main(int argc, char *argv[])

{

  int pipefd[2];

  int bufsize;

  char *buffer;

  int flags, ret, lastwritten, count, totalwritten;

  if(pipe(pipefd) == -1) /* create an ordinary pipe */

  	ERR_EXIT("pipe()");

  flags = fcntl(pipefd[1], F_GETFL);

  fcntl(pipefd[1], F_SETFL, flags | O_NONBLOCK); /* set write_end NONBLOCK */

  bufsize = atoi(argv[1]);

  printf("testing buffer size = %d\n", bufsize);

  buffer = (char *)malloc(bufsize*sizeof(char));

  if(buffer == NULL || bufsize == 0)

  	ERR_EXIT("malloc()");

  count = 0;

  while (1) {

    ret = write(pipefd[1], buffer, bufsize);

    /* bufsize is better to be 2^k */

    if(ret == -1) {

      perror("write()");

      break;

    }

    lastwritten = ret;

    count++;

  }

  totalwritten = (count-1)*bufsize +

  lastwritten;

  printf("single pipe buffer count = %d, last written = %d bytes\n", count, lastwritten);

  printf("total written = %d bytes = %d KiB\n", totalwritten, totalwritten/1024); /* pipe buffer */

  return 0;

}

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

#define BUFFER SIZE 25

int main(VOID)

{

  HANDLE ReadHandle, WriteHandle;

  STARTUPINFO si;

  PROCESS INFORMATION pi;

  char message[BUFFER SIZE] = "Greetings";

  DWORD written;

  /* Program continues in Figure 3.24 */

  /* set up security attributes allowing pipes to be inherited */

  SECURITY ATTRIBUTES sa = {sizeof(SECURITY ATTRIBUTES),NULL,TRUE};

  /* allocate memory */

  ZeroMemory(&pi, sizeof(pi));

  /* create the pipe */

  if (!CreatePipe(&ReadHandle, &WriteHandle, &sa, 0)) {

    fprintf(stderr, "Create Pipe Failed");

    return 1;

  }

  /* establish the START INFO structure for the child process */

  GetStartupInfo(&si);

  si.hStdOutput = GetStdHandle(STD OUTPUT HANDLE);

  /* redirect standard input to the read end of the pipe */

  si.hStdInput = ReadHandle;

  si.dwFlags = STARTF USESTDHANDLES;

  /* don’t allow the child to inherit the write end of pipe */

  SetHandleInformation(WriteHandle, HANDLE FLAG INHERIT, 0);

  /* create the child process */

  CreateProcess(NULL, "child.exe", NULL, NULL,

                TRUE, /* inherit handles */

                0, NULL, NULL, &si, &pi);

  /* close the unused end of the pipe */

  CloseHandle(ReadHandle);

  /* the parent writes to the pipe */

  if (!WriteFile(WriteHandle, message,BUFFER SIZE,&written,NULL))

  	fprintf(stderr, "Error writing to pipe.");

  /* close the write end of the pipe */

  CloseHandle(WriteHandle);

  /* wait for the child to exit */

  WaitForSingleObject(pi.hProcess, INFINITE);

  CloseHandle(pi.hProcess);

  CloseHandle(pi.hThread);

  return 0;

}