int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
        const pthread_rwlockattr_t *restrict attr);

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

int pthread_cond_init(pthread_cond_t *restrict cond,
    const pthread_condattr_t *restrict attr);

// 线程开始等待条件到达
int pthread_cond_wait(pthread_cond_t *restrict cond,
    pthread_mutex_t *restrict mutex);

// 发送信号，唤醒等待条件的线程
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);

// 全局mutex，用于同步各线程，保护条件
pthread_mutex_t mutex;

// 我是否可以行动的条件
pthread_cond_t cond; 

// 模板 
pthread_mutex_lock(&mutex);
while (/* 条件没达成吗 */)
    pthread_cond_wait(&cond, &mutex);
/* 临界区代码在此 */
pthread_mutex_unlock(&mutex);
// 非临界区

int pthread_barrier_init(pthread_barrier_t *restrict barrier,
    const pthread_barrierattr_t *restrict attr, unsigned count);

#include <signal.h>
int sigaction(int signum, const struct sigaction *act,
                struct sigaction *oldact);

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

#include <setjmp.h>
int setjmp(jmp_buf env);
int sigsetjmp(sigjmp_buf env, int savesigs);

void longjmp(jmp_buf env, int val);
void siglongjmp(sigjmp_buf env, int val);

 #include <signal.h>
int sigsuspend(const sigset_t *mask);

// Linux
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

// FreeBSD中的定义相同，不过属于库函数，而Linux中属于系统调用

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

static int c = 2;
static void sigterm_handler(int signo) {
    printf("handle signal: %d\n", signo);
    c--;
}

int
main() {
    signal(SIGTERM, &sigterm_handler);
    while (c > 0)
        pause();
    printf("exit\n");
    exit(0);
}

// Linux
#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);

#include <unistd.h>
extern char **environ;
int execl(const char *pathname, const char *arg, ...
                /* (char  *) NULL */);
int execlp(const char *file, const char *arg, ...
                /* (char  *) NULL */);
int execle(const char *pathname, const char *arg, ...
                /*, (char *) NULL, char *const envp[] */);
int execv(const char *pathname, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],
                char *const envp[]);

// t18.c，可执行文件为mypid，由exec启动这个进程
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int
main(void)
{
    printf("my pid: %d\n", getpid());
    exit(0);
}

// t19.c，原始进程，将启动./mypid
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int
main(void)
{
    printf("before exec, my pid: %d\n", getpid());
    execl("./mypid", NULL);
    printf("this line\n");
    exit(0);
}

// Linux
#include <stdlib.h>
void *malloc(size_t size);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);
void free(void *ptr);

// FreeBSD
#include <stdlib.h>
#include <malloc_np.h>
void *malloc(size_t size);
void *calloc(size_t number, size_t size);
void *realloc(void *ptr, size_t size);
void free(void *ptr);

int a = 5;

struct stat {
    dev_t     st_dev;         /* ID of device containing file */
    ino_t     st_ino;         /* Inode number */
    mode_t    st_mode;        /* File type and mode */
    nlink_t   st_nlink;       /* Number of hard links 硬链接计数器在这里 */ 
    uid_t     st_uid;         /* User ID of owner */
    gid_t     st_gid;         /* Group ID of owner */
    dev_t     st_rdev;        /* Device ID (if special file) */
    off_t     st_size;        /* Total size, in bytes */
    blksize_t st_blksize;     /* Block size for filesystem I/O */
    blkcnt_t  st_blocks;      /* Number of 512B blocks allocated */
    struct timespec st_atim;  /* Time of last access */
    struct timespec st_mtim;  /* Time of last modification */
    struct timespec st_ctim;  /* Time of last status change */
};

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

int
main(void)
{
    // 通过实际id访问文件
    if (-1 == access("file.txt", R_OK))
        perror("access");
    else
        printf("access成功\n");

    // 通过有效id访问文件
    if (-1 == open("file.txt", O_RDONLY))
        perror("open");
    else
        printf("open读成功\n");
    exit(0);
}

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

int stat(const char *pathname, struct stat *statbuf);
int fstat(int fd, struct stat *statbuf);
int lstat(const char *pathname, struct stat *statbuf);

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

int
main(void)
{
    int             fd_passwd = open("/usr/bin/passwd", O_RDONLY);
    struct stat     stat_passwd;
    if (-1 == fstat(fd_passwd, &stat_passwd)) {
        perror("fstat /usr/bin/passwd error");
        exit(1);
    }
    printf("/usr/bin/passwd st_mode: %x, S_ISUID: %x\n", 
        stat_passwd.st_mode, S_ISUID);

    printf("/usr/bin/passwd st_uid: %s\n", 
        (stat_passwd.st_mode & S_ISUID) ? "true" : "false");

    exit(0);
}

// open通过绝对路径或当前目录的相对路径打开文件，返回fd
open(const char *__path, int __oflag, ...)

// openat 可以将__fd视为当前目录，__path为相对路径，也可令__fd = AT_FDCWD 使其为当前目录
// 若__path是绝对路径，__fd无效
openat(int __fd, const char *__path, int __oflag, ...)

// 两个函数出错均返回-1，errno设为错误值

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

// 推荐buf大小为4096字节，因为ext4文件系统中一个块大小为4096字节
#define READ_BUFSIZE 256

int
main(void)
{
    int dir_fd = open(".", O_RDONLY);
    if (dir_fd < 0) {
        perror("dir open failed");
        exit(1);
    }
    int data_fd = openat(dir_fd, "data.txt", O_RDONLY);
    if (data_fd < 0) {
        perror("data.txt open failed");
        close(dir_fd);
        exit(1);
    }

    printf("dir_fd: %d, data_fd: %d\n", dir_fd, data_fd);

    char buf[READ_BUFSIZE];
    ssize_t bytes, total = 0;
    while ((bytes = read(data_fd, buf, READ_BUFSIZE)) > 0) {
        printf("byted read: %d\n", (int)bytes);
        total += bytes;
    }
    
    close(data_fd);
    close(dir_fd);
    if (bytes == -1) {
        perror("read error");
        exit(1);
    }

    printf("read from data.txt: %d bytes\n", (int)total);

    int not_exist_fd = openat(AT_FDCWD, "no_such_file.txt", O_RDONLY);
    if (not_exist_fd == -1) {
        perror("open \"no_such_file.txt\"");
    } else {
        close(not_exist_fd);
    }
    exit(0);
}