man 7 pipe # overview of pipes and FIFOS
man 2 pipe # see relative functions

ulimit -p # to see the PIPE_BUF in system (4096 by default)

#define RECV_BUF ?

char sendmsg[RECV_BUF];
char recvmsg[RECV_BUF];
// 初始化sendmsg
for(i = 0; i < RECV_BUF; i++)
	sendmsg[i] = i % 26 + 'a';

len = write(pipedes[1], sendmsg, RECV_BUF);
printf("send len: %d\n", len);

POSIX.1-2001规定，write向pipe写入长度小于PIPE_BUF的内容，这个操作一定是原子性的(标准保证)，即写入操作是不受其他写入影响到的，不可分割的。写入多于PIPE_BUF的内容的操作可能是非原子性的，即，内核可能把当前进程写入的数据和其他进程写入的数据交错在一起。Linux上PIPE_BUF是4096字节(刚好是一个页的大小，通过getpagesize()函数查看)。进一步来说，还要看文件描述符是不是O_NONBLOCK，对于一个pipe是否有多个写入者，以及具体要写入的数据长度n。

......
更详细的可以参考man 7 pipe

strace ./test

pipe([3, 4]) = 0
write(4, "abcdefghijklmnopqrstuvwxyzabcdef"..., 65537) = 65536
SIGPIPE {si_signo=SIGPIPE, si_code=SI_USER, si_pid=3485,si_uid=0}
+++ killed by SIGPIPE +++

SIGPIPE 13 Term Broken pipe: write to pipe with no readers

/proc/sys/fs/pipe-max-size (since Linux 2.6.35)

The value in this file defines an upper limit for raising the capacity of a pipe using the fcntl(2) F_SETPIPE_SZ operation.  This limit applies only to unprivileged processes. The default value for this file is 1,048,576. The value assigned to this file may be rounded upward, to reflect the value actually employed for a convenient implementation. To determine the rounded-up value, display the contents of this file after assigning a value to it.  The minimum value that can be assigned to this file is the system page size.

/*
 * The max size that a non-root user is allowed to grow the pipe
 * Can be set by root in /proc/sys/fs/pipe-max-size
 */
unsigned int pipe_max_size = 1048576; // 1MB

/*
 * Minimum pipe size, as required by POSIX
 */
unsigned int pipe_min_size = PAGE_SIZE;

/* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual memory allocation, whereas PIPE_BUF makes atomicity guarantees */
#define PIPE_SIZE       PAGE_SIZE

cat /proc/sys/fs/pipe-max-size

#define PIPE_DEF_BUFFERS    16

man fifo # something about fifo

mkfifo fifotest # you can also use mknod fifotest p
cat ./makefile > fifotest &
cat < fifotest

man 3 mkfifo

// parent
pid = getpid();
printf("parent pid: %d\n", pid);
if((fd = open(FIFO, O_RDWR)) < 0){
    perror("open");
    return ERROR;
}
printf("Send to child: %s\n", sendmsg);
len = write(fd, sendmsg, strlen(sendmsg));

// child
if((fd = open(FIFO, O_RDWR)) < 0){
    perror("open");
    return ERROR;
}
printf("Read from parent\n");
total = 0;
sleep(9);
while((len = read(fd, recvmsg+total, RECV_BUF)) > 0)
    total += len;
printf("what?\n");
if(len == -1){
    perror("read");
    close(fd);
    return ERROR;
}
recvmsg[total] = '\0';
close(fd);
printf("Read from parent: %s\n", recvmsg);

// Process-A.c
readfd  = open(FIFO1, O_RDONLY); // step1
writefd = open(FIFO2, O_WRONLY); // step2

// Process-B.c
readfd  = open(FIFO2, O_RDONLY); // step1
writefd = open(FIFO1, O_WRONLY); // step2

// Process-A.c
writefd = open(FIFO1, O_WRONLY); // step1
readfd  = open(FIFO2, O_RDONLY); // step2

// Process-B.c
readfd  = open(FIFO1, O_RDONLY); // step1
writefd = open(FIFO2, O_WRONLY); // step2

unlink(FIFO1);

// Process A
write();
...
read();
...
close(writefd);
close(readfd);

// Process B
read();
...
write();
...
close(readfd);
close(writefd);

// Process A
write();
close(writefd);
...
read();
...
close(readfd);

// Process B
read();
close(readfd);
...
write();
...
close(writefd);

#include <sys/stat.h>

#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

man 7 signal
man 2 sigaction

#define SIG_IGN ((_sighandler_t) 1) // this one
#define SIG_DEL ((_sighandler_t) 0)
#define SIG_ERR ((_sighandler_t) -1)

/* Signals used in this test:
 *      signal          B's behavior
 0      SIGCONT         printf("SIGCONT: continue\n");
 1      SIGURG          printf("SIGURG: continue\n");
 2      SIGUSR1         printf("SIGUSR1: continue\n");
 3      SIGUSR2         printf("SIGUSR2: exit\n");
 4      SIGTERM         printf("SIGTERM: exit\n");
 5      SIGKILL         printf("SIGKILL: continue\n");
 */
int Sig[SIG_NUM] = { 
    SIGCONT,
    SIGURG,
    SIGUSR1,
    SIGUSR2,
    SIGTERM,
    SIGKILL
};

void Handler0(int sig);
...
void Handler5(int sig);

struct sigaction act[SIG_NUM], oact[SIG_NUM];
void (*Handler[SIG_NUM])(int) = {
    Handler0,
    Handler1,
    Handler2,
    Handler3,
    Handler4,
    Handler5
};
for(i = 0; i < SIG_NUM; i++){
    act[i].sa_handler = Handler[i];
    sigemptyset(&(act[i].sa_mask));
    act[i].sa_flags = 0;
    sigaction(Sig[i], &act[i], &oact[i]);
}

int sigaction(int signum, 
	const struct sigaction *act, 
    struct sigaction *oldact);

struct sigaction {
	void (*sa_handler)(int); // 1
    void (*sa_sigaction)(int, siginfo_t *, void *); // 2
    sigset_t sa_mask;
    int sa_flags;
    void (*sa_restorer)(void);
};

--------- 消息队列 -----------
键         msqid      拥有者     权限     已用字节数   消息
------------ 共享内存段 --------------
键         shmid      拥有者     权限     字节    nattch     状态
--------- 信号量数组 -----------
键         semid      拥有者     权限     nsems

struct msgbuf{
	int mytype; // 'long' is right
    char mtext[512];
}

man 7 unix

void mylock(int fd, int op) 
{
    struct flock lock;
    lock.l_whence = SEEK_SET;
    lock.l_start = lock.l_len = 0;
    lock.l_pid = getpid();
    lock.l_type = op;
    if(fcntl(fd, F_SETLKW, &lock) == -1){
        close(fd);
        oops("fcntl", ERROR);
    }
}

man 2 fcntl

   Mandatory locking
       (Non-POSIX.)  The above record locks may be either advisory or mandatory, and are advisory by default.

       Advisory locks are not enforced and are useful only between cooperating processes.

       Mandatory locks are enforced for all processes.  If a process tries  to  perform  an  incompatible  access
       (e.g.,  read(2)  or  write(2))  on  a file region that has an incompatible mandatory lock, then the result
       depends upon whether the O_NONBLOCK flag is enabled for its open file description.  If the O_NONBLOCK flag
       is not enabled, then system call is blocked until the lock is removed or converted to a mode that is com‐
       patible with the access.  If the O_NONBLOCK flag is enabled, then the system call  fails  with  the  error
       EAGAIN.

       To  make  use  of mandatory locks, mandatory locking must be enabled both on the file system that contains
       the file to be locked, and on the file itself.  Mandatory locking is enabled on a file  system  using  the
       "-o  mand"  option  to  mount(8), or the MS_MANDLOCK flag for mount(2).  Mandatory locking is enabled on a
       file by disabling group execute permission on the file and enabling the set-group-ID permission  bit  (see
       chmod(1) and chmod(2)).

       The Linux implementation of mandatory locking is unreliable.  See BUGS below.
       
       BUGS:
       
       The implementation of mandatory locking in all known versions of Linux is subject to race conditions which
       render  it  unreliable: a write(2) call that overlaps with a lock may modify data after the mandatory lock
       is acquired; a read(2) call that overlaps with a lock may detect changes to data that were made only after
       a  write  lock  was  acquired.   Similar races exist between mandatory locks and mmap(2).  It is therefore
       inadvisable to rely on mandatory locking.