### 文件/外设

#### access, faccessat

检查用户对一个文件的权限

```c
/* 检查一个用户的实际UID是否有访问文件pathname的权限。
 * mode : 4检查读权限，2检查写权限，1检查可执行权限。这些数字可以组合。
 */
int access(const char *pathname, int mode);
int faccessat(int dirfd, const char *pathname, int mode, int flags);
```



#### close

关闭文件描述符

```c
int close(int fd);
```



#### chdir, fchdir

切换工作目录

```c
int chdir(const char *path);
int fchdir(int fd);
```



#### chmod, fchmod, fchmodat

改变文件的权限

```c
/*
 * mode : 文件的模式
 *	 S_ISUID(04000) - 一个可执行文件设置此位后，其他用户可以以此文件属主的权限进行操作。
 */
int chmod(const char *pathname, mode_t mode);
int fchmod(int fd, mode_t mode);
int fchmodat(int dirfd, const char *pathname, mode_t mode, int flags);
```



#### chown, fchown, lchown, fchownat

改变文件的属主

```c
int chown(const char *pathname, uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group);
int lchown(const char *pathname, uid_t owner, gid_t group);
int fchownat(int dirfd, const char *pathname, uid_t owner, gid_t group, int flags);
```



#### chroot

切换根目录

```c
int chroot(const char *path);
```



#### dup, dup2, dup3

复制文件描述符

```c
/* 返回一个新的文件描述符，指向oldfd所指向的文件 */
int dup(int oldfd);
/* 让新文件描述符newfd也指向oldfd所指向的文件 */
int dup2(int oldfd, int newfd);
int dup3(int oldfd, int newfd, int flags);
```



#### fallocate

为文件分配磁盘空间

#### fcntl

管理文件描述符

```c
/* 依据命令cmd操作文件fd
 * cmd : 可能的值如下：
 *	 1 复制文件描述符
 *	 2 文件描述符的标志
 *	 3 文件状态的标志
 *	 4 advisory记录锁定
 *	 	F_SETLK (struct flock *) : 请求或释放锁。
 *	 		当参数里的l_type为F_RDLCK或F_WRLCK,则请求锁。
 *	 		当参数里的l_type为F_UNLCK则释放锁。
 *	 5 打开的文件描述锁定
 *	 6 强制锁定
 *	 7 丢失锁
 *	 8 管理信号
 *	 9 出租
 *	 10 文件与目录改变通知
 *	 11 改变管道
 *	 12 文件密封
 *	 13 文件读写提示
 * 返回值：如成功，取决于cmd；如失败，返回-1。
 *		F_DUPFD - 返回新的文件描述符。
 *		F_GETFD - 文件描述符标志的值。
 *		F_GETFL - 文件状态标志的值。
 *		F_GETLEASE - 文件描述符持有的lease类型。
 *		F_GETOWN - 文件描述符属主的值。
 *		F_GETSIG - 当读或写可行时要发送的信号的值，如为传统的SIGIO行为则为0。
 *		F_GETPIPE_SZ, F_SETPIPE_SZ - 管道容量
 *		F_GET_SEALS - 
 *		其它 - 0
 */
int fcntl(int fd, int cmd, ... /* arg */ );
```



#### fsync, fdatasync

 把文件的内核状态同步到存储设备

#### getcwd, getwd, get_current_dir_name

获取当前工作目录

#### getdents, getdents64

获取目录的条目

#### ioctl

控制设备

```c
/*
 * 通过控制设备文件来控制设备。特别是字符设备，如终端(teminals)。
 * fd : 设备文件的文件描述符，要求设备文件必须是打开的。
 * request : 操作的类型。关于此参数的宏和定义在<sys/ioctl.h>。
 *   TCGETS : 获取当前串口设置(Tty Ctrl GET Serial port Settings)
 *   TIOCGPGRP : 获取终端上进程的组ID(Tty IO Ctrl Get the Process GRouP id)
 * 第三个参数：无类型(untyped)的指针。(在void *语法还没出现前，它被表示为char *argp。)
 *	 第三个参数指向了一个结构体，包含了控制字符数组以及各种标志位。
 * 返回值：非负表示成功，负数表示失败。
 *   EBADF : fd无效。
 *   EFAULT : argp引用了不可访问的内存区域。
 *   EINVAL : request或argp无效。
 *   ENOTTY : fd没有关联到字符设备。
 */
int ioctl(int fd, unsigned long request, ...);
```



#### lseek

重新定位读/写文件的位置

```c
/*
 * fd : 代表要读、写的文件
 * offset : 要读写的相对位置
 * whence : SEEK_SET文件位置是相对于文件开头而言的，SEEK_CUR相对于当前位置，SEEK_END相对于文件末尾。
 * 返回值：文件指针被修改后的绝对位置
 */
off_t lseek(int fd, off_t offset, int whence);
```



#### link, linkat

创建到文件的链接。(即硬链接)

```c
int link(const char *oldpath, const char *newpath);
int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags);
```



#### mkdir, mkdirat

创建目录

```c
int mkdir(const char *pathname, mode_t mode);
int mkdirat(int dirfd, const char *pathname, mode_t mode);
```



#### mknod, mknotat

创建文件，这个文件即可以是普通文件也可以特殊文件。

```c
/* 创建文件系统节点
 * pathname : 节点名称
 * mode : 它即定义了节点的类型，也定义了节点的访问权限(rwxrwxrwx)。
 *		节点类型：S_IFREG常规文件，S_IFCHR字符设备，S_IFBLK块设备，S_IFIFO命名管道，S_IFSOCK网络插座
 * dev : 定义了主、次设备号。(注：仅对字符设备和块设备有效)
 */
int mknod(const char *pathname, mode_t mode, dev_t dev);
int mknodat(int dirfd, const char *pathname, mode_t mode, dev_t dev);
```

#### mount

挂载文件系统

```c
/*
 * filesystemtype : 在文件/proc/filesystems包含了可以挂载的类型。
 * mountflags : 定义了挂载操作的类型。
 *	 MS_RDONLY - 以只读的方式挂载文件系统。
 * data : 由文件系统来理解的参数。
 */
int mount(const char *source, const char *target,
          const char *filesystemtype, unsigned long mountflags,
          const void *data);
```



#### open, openat, creat

打开或创建文件

```c
/* 打开文件
 * pathname : 包含路径的文件名
 * flags : 打开方式。
 */
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

/* 创建并打开文件。(注：已过时，应使用open系统调用) */
int creat(const char *pathname, mode_t mode);

int openat(int dirfd, const char *pathname, int flags);
int openat(int dirfd, const char *pathname, int flags, mode_t mode);
```



#### pivot_root

切换根文件系统

#### poll, ppoll

等待一个文件描述符上的事件

#### pread, pwrite

从给定位移读取或写入文件

#### read

从文件描述符读

#### readlink, readlinkat

读取一个符号链接的值

#### readv, writev, preadv, pwritev, preadv2, pwritev2

向多个缓冲区读写数据

#### rmdir

删除目录

```c
int rmdir(const char *pathname);
```



#### rename, renameat, renameat2

改变文件的名称或位置

```c
int rename(const char *oldpath, const char *newpath);
int renameat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath);

int renameat2(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, unsigned int flags);
```



#### select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO

同步I/O多路复用

#### sendfile

在文件描述符之间传递数据

#### stat,fstat,lstat,fstatat

获取文件状态

```c
/* stat代表了文件的状态，其对应的数据结构为 */
struct stat {
	dev_t     st_dev;         /* 设备ID */
	ino_t     st_ino;         /* Inode号 */
	mode_t    st_mode;        /* 文件的类型与模式 */
	nlink_t   st_nlink;       /* 硬链接的数量 */
	uid_t     st_uid;         /* 属主的用户ID */
	gid_t     st_gid;         /* 属主的组ID */
	dev_t     st_rdev;        /* 设备的主、次设备号 */
	off_t     st_size;        /* 文件大小，以字节为单位 */
	blksize_t st_blksize;     /* Block size for filesystem I/O */
	blkcnt_t  st_blocks;      /* Number of 512B blocks allocated */

    /* 2.6内核之后提高到ns精度，增加了如下的域 */
	struct timespec st_atim;  /* 最后访问时间 */
	struct timespec st_mtim;  /* 修改时间 */
	struct timespec st_ctim;  /* 状态改变时间 */

	#define st_atime st_atim.tv_sec      /* Backward compatibility */
	#define st_mtime st_mtim.tv_sec
	#define st_ctime st_ctim.tv_sec
};

/* 通过文件名来获取文件的状态 */
int stat(const char *pathname, struct stat *statbuf);
/* 通过文件描述符来获取文件的状态 */
int fstat(int fd, struct stat *statbuf);
int lstat(const char *pathname, struct stat *statbuf);
int fstatat(int dirfd, const char *pathname, struct stat *statbuf, int flags);
```



#### statfs, fstatfs

获取文件状态

#### symlink, symlinkat

创建到文件的链接

#### sync, syncfs

把文件系统缓存提交到磁盘。

```c
void sync(void);
int syncfs(int fd);
```



#### truncate, ftruncate

将文件截断为指定长度

#### unlink,unlinkat

删除到文件的链接

#### umask

设置文件模式的掩码

```c
/* 其它系统调用所创建文件的权限将会是(~mask&mode)
 * 返回值：上一个mask的值。
 */
mode_t umask(mode_t mask);
```



#### umount, umount2

解除挂载

```c
int umount(const char *target);
int umount2(const char *target, int flags);
```



#### utimensat, futimens

把文件时间戳精度提高到纳秒级

#### write

写入文件描述符

```c
ssize_t write(int fd, const void *buf, size_t count);
```



### 进程

#### arch_prctl

设置特定架构的线程状态

```c
// code代表一个操作，并会把参数addr传给它
//   对于x86_64可用的操作：
//   ARCH_SET_FS - 把FS寄存器设置为addr
//   ARCH_GET_FS - 获取当前线程FS寄存器的值
//   ARCH_SET_GS - 设置GS寄存器的值为addr
//   ARCH_GET_GS - 获取当前线程GS寄存器的值
// addr:如果是set操作则为unsigned long，如果是get操作则为unsigned long *。
int arch_prctl(int code, unsigned long addr);
int arch_prctl(int code, unsigned long *addr);
```



#### capget, capset

设置、获取线程的capability

#### clone, __clone2

创建子进程

```c
/* 类似于fork()。与fork()不同的是，clone()出来的子进程可以共享父进程的部分上下文，如虚拟地址空间、文件描述符表、信号句柄的表(table of signal handlers)。
 * clone()的一个作用是创建线程，多个线程可以共享地址空间。
 * fn : 函数的标记，子进程从此处开始执行。而fork()出来的子进程是从调用点开始执行的。
 * child_stack : 指定子进程的栈。由于栈是向下增长的，所以此参数应指向栈的高地址。
 * 当函数fn(arg)返回时，子进程终止。fn的返回值即为子进程的退出状态。子进程也可以调用exit()终止，或接收到fatal信号后终止。
 * flags :
 * arg : 函数fn的参数。
 */
int clone(int (*fn)(void *), void *child_stack, int flags, void *arg, ...);

```

#### execve

执行程序或脚本。

```c
/* 从父进程clone()或fork()出来的子进程，执行execve()以真正执行自己所要执行的程序。
 * pathname : 一个带有路径的可执行程序或脚本。
 * argv : 传递给要执行程序的参数所组成的数组。(注：argv[0]是要执行程序的名字)
 * envp : 由环境组成的数组，数组元素的形式为：key=value。
 */
int execve(const char *pathname, char *const argv[], char *const envp[]);
```



#### _exit, _EXIT

结束进程

```c
void _exit(int status);
void _Exit(int status);
```



#### exit_group

结束一个进程里的所有线程

#### futex

快速的用户空间锁定

#### getgid, getegid

获得调用进程的组ID

```c
/*
 * 返回调用进程的实际组ID
 */
gid_t getgid(void);
/* 返回调用进程的有效组ID */
gid_t getegid(void);
```



#### getgroups, setgroups

获取、设置所附加组ID的列表

#### getpgid, getpgrp

获得进程的组ID

#### getpid, getppid

获取进程ID

```c
pid_t getpid(void);
```



#### getpriority, setpriority

获取、设置调度优先级

#### getrlimit, setrlimit, prlimit

获取、设置对资源的限制

#### getresuid, getresgid

获取真实(r)有效(e)已保存的(s)用户ID、组ID

#### getsid

获取会话(session)ID

#### gettid

获得线程ID

#### getuid, geteuid

获得调用进程的用户ID

```c
/* 返回调用进程的实际用户ID */
uid_t getuid(void);
/* 返回调用进程的有效用户ID */
uid_t geteuid(void);
```



#### pipe, pipe2

创建管道

```c
/*
 * 创建单向的管道。
 * 参数：向pipefd[1]的写入，在pipefd[0]能读出来。
 * 返回值：成功返回0，失败返回-1。
 */
int pipe(int pipefd[2]);
int pipe2(int pipefd[2], int flags);
```



#### personality

设置进程的执行域

#### prctl

对进程的操作

#### semctl

控制信号量。

#### semget

获取一个信号量。

#### semop, semtimedop

改变信号量的值

#### setns

把线程连接到一个namespace

#### setgid

设置组ID

#### setpgid, setpgrp

设置进程的组

#### setresuid, setresgid

设置真实(r)有效(e)已保存的(s)用户ID、组ID

#### setsid

创建会话并设置进程组ID

#### setuid

设置用户ID

#### sched_setaffinity, sched_getaffinity

设置、获取线程对CPU的亲和力掩码(affinity mask)

#### sched_setparam, sched_getparam

设置、获取调度参数

#### sched_setscheduler, sched_getscheduler

设置、获取调度策略

#### sched_yield

让出处理器

#### shmat, shmdt

把共享内存连接(attach)到当前进程，或把它从当前进程分离(dettach)出去。

#### shmctl

控制共享内存。

#### shmget

创建共享内存(用于进程间通信)。

#### times

获取进程相关的一些时间

```c
struct tms {
	clock_t tms_utime;  /* 用户态执行的时间 */
	clock_t tms_stime;  /* 内核态执行的时间 */
	clock_t tms_cutime; /* 所有子进程的用户态执行时间 */
	clock_t tms_cstime; /* 所有子进程的内核态执行时间 */
};

clock_t times(struct tms *buf);
```



#### unshare

分离进程执行上下文

#### wait, waitpid, waitid

等待子进程状态改变

```c
pid_t wait(int *wstatus);
// 只要有一个子进程终止就不再等待。相当于waitpid(-1, wstatus, 0).
// 返回值：成功则返回子进程id，错误返回-1。
// wstatus : NULL，则忽略。非NULL,则用于保存子进程的状态信息。

pid_t waitpid(pid_t pid, int *wstatus, int options);
// 只有给定子进程pid状态改变才不再等待。
// 返回值：成功则返回子进程id，错误返回-1，某些情况下返回0.
// pid : 小于-1则所等待的子进程的组id要等于|pid|，
//       等于-1则等待任意子进程即可，
//       等于0所等待的子进程的组id要等于父进程，
//       大于0则所等待的子进程的id要等于pid。
// optons : 所等待的子进程的状态。
//		WNOHANG : 无子进程退出。
//		WUNTRACED : 
//		WCONTINUED : 

int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
// 提供更精确的控制
// 返回值：成功返回0，错误返回-1。
// idtype : P_PID , 所等待的子进程的进程号为id。
//		P_PGID , 所等待的子进程的组id为id。
//		P_ALL , 等待任意子进程，此时忽略id。
struct siginfo_t {
    pid_t si_pid;	// 子进程的id
    uid_t si_uid;	// 子进程的用户id
    int	si_signo;	// 
    int si_status;	// 
    int si_code;	// 
}
// options : WEXITED
//		WSTOPPED
//		WCONTINUED
//		WNOHANG
//		WNOWAIT

pid_t wait3(int *wstatus, int options, struct rsuage *rusage);
// 返回值 ： 与waitpid相同。
// rusage : NULL则忽略，非NULL则保存子进程的统计信息。
pid_t wait4(pid_t pid, int *wstatus, int options, struct rusage *rusage);
// 返回值： 与waitpid相同。
```

#### wait3,wait4

BSD风格的wait

### 内存

#### brk, sbrk

改变数据段的大小。

(注：栈段在上向下增长，数据段在下向上增长，数据段和栈段之间是空闲空间)

(注：栈段是自动增长的，而数据段需要brk()来改变其大小)

```c
/*
 * addr : 指定数据段的结束地址。(注：此参数必须小于栈指针，即数据段不能与栈段重叠)
 */
int brk(void *addr);

/*
 * increment : 数据段的改变量，正数增加，负数减小，零则返回数据段的结束地址。
 */
void *sbrk(intptr_t increment);
```



#### madvise

给出对使用内存的建议

#### mmap,munmap

把文件或设备映射(或取消映射)到内存

#### mprotect, pkey_mprotect

设置对一个内存区域的保护

#### mremap

重新映射虚拟内存

#### swapon, swapoff

开始、停止交换到文件或设备

### 信号

#### alarm

设置一个报警时钟用以发送信号

```c
unsigned int alarm(unsigned int seconds);
```



#### kill

向进程发送信号

```c
int kill(pid_t pid, int sig);
```

#### pause

等待信号

```c
/*
 * 让进程或线程睡眠来等待信号
 */
int pause(void);
```



#### sigaction, rt_sigaction

检测并改变一个信号的行为

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


/* 改变进程在收到特定信号时所采取的行动。
 * signum - 指定信号。(注：不能是SIGKILL和SIGSTOP)
 * act - 新定义的动作。
 * oldact - 保存之前的动作。
 */
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
```



#### sigaltstack

设置、获取信号栈的上下文

#### sigpending, rt_sigpending

查询挂起的信号

```c
/* 
 * set : 用于保存挂起信号的掩码。
 */
int sigpending(sigset_t *set);
```



#### sigprocmask, rt_sigprocmask

检测并改变被阻塞的信号

```c
/*
 * 作用：获取或改变调用线程的信号屏蔽字。只能用于单进程单线程。
 * how：SIG_BLOCK把参数set中的信号添加到信号屏蔽字中，
 *      SIG_SETMASK把信号屏蔽字设置为参数set中的信号，
 *		SIG_UNMASK从信号屏蔽字中删除参数set中的信号
 * set：信号集。
 * oldset：如非NULL，则保存之前的信号屏蔽字。
 * 返回值：0成功,-1失败。
 */
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
```



#### sigreturn, rt_sigreturn

从信号处理例程返回，并清空栈桢

```c
int sigreturn(...);
```



#### sigsuspend, rt_sigsuspend

等待一个信号

```c
/* 临时替换信号掩码，挂起线程等待信号的到来。
 *　mask : 用此掩码来临时替换原先的掩码。
 */
int sigsuspend(const sigset_t *mask);
```



#### sigwaitinfo, sigtimedwait, rt_sigtimedwait

同步等待排队的信号

#### tkill, tgkill

向线程发信号

### 计时器

#### clock_adjtime

riscv64下的系统调用号266，未找到定义。

#### clock_getres, clock_gettime, clock_settime

时钟和时间的函数

#### clock_nanosleep

可指定时钟的高精度睡眠(high-resolution sleep with specifiable clock)

#### getitimer, setitimer

获取、设置间隔计时器(interval timer)的值

#### gettimeofday

获取从1970-01-01 00:00:00 +0000(UTC)到现在经历的时间。这个时间记录在`TimeVal`中。

```c
ing gettimeofday(struct timeval *tv, int timezone)
struct timeval {
    time_t sec;			// 秒数
    suseconds_t usec;	// 微秒数
}
```

#### settimeofday

设置时间。

#### stime

设置时间。

```c
/* t : 从1970-01-01 00:00:00到当前的秒数。
 */
int stime(const time_t *t);
```



#### time

获取时间(以秒为单位)。

```c
/* 返回1970-01-01 00:00:00到当前的时间。以秒为单位。 */
time_t time(time_t *tloc);
```

#### utime, utimes

改变文件的最后访问时间和修改时间。

```c
struct utimbuf {
	time_t actime;       /* access time */
	time_t modtime;      /* modification time */
};
struct timeval {
	long tv_sec;        /* seconds */
	long tv_usec;       /* microseconds */
};

int utime(const char *filename, const struct utimbuf *times);
int utimes(const char *filename, const struct timeval times[2]);
```



### 网络

#### accept, accept4

接受到一个socket的连接。

#### bind

给socket绑定一个名字

#### connect

在socket上发起一个连接

#### getpeername

获取对方socket的名字

#### getsockname

获取socket名称

#### getsockopt, setsockopt

获取或设置socket上的操作

#### listen

监听到一个socket上的连接

#### recv, recvfrom, recvmsg

接收从socket来的消息

#### send, sendto, sendmsg

向socket发信息

#### shutdown

关闭全双工连接的一部分

#### socket

创建通信的端点

```c
/* 
 * domain : 用于指定通信协议
 * 返回值：一个文件描述符，用以代表创建的端点。
 */
int socket(int domain, int type, int protocol);
```



#### socketpair

创建一对儿相互连接的socket

### 其它

#### gethostname, sethostname

获取、设置hostname

#### reboot

重启系统

#### sysinfo

获取系统信息

#### syslog, klogctl

read and/or clear kernel message ring buffer; set console_loglevel

#### uname

获取内核信息
