TutorialsPoint Unix/Linux 系统调用参考指南

来源：易百教程

Unix/Linux系统调用™

开始学习 >> ：accept()函数 Unix/Linux

accept()函数

名称

accept - 接受连接套接字上

内容简介

描述说明

accept()系统调用用于基于连接的套接字类型（SOCK_STREAM，SOCK_SEQPACKET）。提取完成连接队列中的第一个连接请求，创建一个新的连接套接字，并返回一个新的文件描述符，指该套接字。新创建的套接字处于监听状态。原始套接字 sockfd 不受此调用。

参数 sockfd 是一个套接字绑定到本地地址 bind(2) socket(2)，已创建侦听连接后 listen(2)。

参数addr是一个指向结构sockaddr。被填充在此结构的对等套接字的地址，作为已知的通信层。地址返回 addr 的确切格式由套接字的地址族（参见socket（2）及相应协议的手册页）。

addrlen 参数是一个值结果参数：最初它应该包含大小addr所指向的结构，在函数返回时将包含实际的长度（以字节为单位）返回的地址。当没有填写addr是NULL。

如果没有挂起的连接队列，并没有被标记为非阻塞套接字，accept() 将阻塞，直到建立连接。如果套接字被标记无阻塞，没有未完成连接队列上，accept() 失败，并出现错误EAGAIN。

为了通知传入连接在套接字上，那么可以使用select（2）或 orpoll（2）。当尝试一个新的连接，然后可以调用accept() 获取套接字，连接一个可读事件将被传递。另外，您还可以设置套接字提供SIGIO活动发生在一个socket时，详情参见socket（7）。

需要一个明确的确认，如 DECNET 对于某些协议，accept() 可以被看作是仅仅从队列中取出下一个连接请求，不意味着确认。确认可以正常的读或写上新的文件描述符，暗示和排斥反应，可通过关闭新的套接字暗示。目前只有DECNet有这样的Linux上的语义。

注意

可能并不总是等待一个连接后 SIGIO 交付 select(2) 或 poll(2) 因为连接可能已被删除，被称为异步网络错误或另一个线程 accept() 返回一个可读性事件。如果发生这种情况，那么调用将阻塞等待下一个连接到达。

为了确保 accept() 从未阻塞，通过套接字sockfd中需要有O_NONBLOCK标志设置（参见socket（7））。

返回值

如果成功，accept()返回一个非负的整数，这是一个接受套接字描述符。上的错误，则返回-1，errno设置为合适。

错误处理

Linux 的 accept() 传递已经挂起的网络错误，在新的socket accept() 错误代码。此行为不同于其他的BSD套接字实现。对于可靠运行的应用程序应该检测网络错误定义的协议后accept() ，并把它们像EAGAIN重试。在这些情况下，TCP/ IP是ENETDOWN ENOPROTOOPT EPROTO，EHOSTDOWN，ENONET，EHOSTUNREACH，EOPNOTSUPP，和ENETUNREACH的。

错误

accept()可能失败如下:

accept() 可能会失败，如下:

Linux accept() 可能会失败，如下:

此外，新的套接字的协议所定义的网络错误可能被返回。各种 Linux 内核可以返回其他错误，如ENOSR ESOCKTNOSUPPORT，EPROTONOSUPPORT ETIMEDOUT。在跟踪过程中，可能会出现值ERESTARTSYS。

遵循于

SVr4, 4.4BSD (accept() first appeared in 4.2BSD).

注意

最初是作为一个'‘int *’'声明 accept()的第三个参数（libc4和libc5和许多其他系统，如4.x的BSD，SunOS 4上，SGI）;下一个POSIX.1g标准草案希望改变它变成了'size_t*'，那是什么它是在SunOS5。后来POSIX汇票“socklen_t*”，这样做对单一Unix规范和glibc2。

另请参阅

• bind (2)
• connect (2)
• listen (2)
• select (2)
• socket (2)

下一篇：access()函数 Unix/Linux

access()函数

名称

access - 检查用户的权限的文件

内容简介

描述

access()检查该进程是否将被允许读，写或测试存在的文件（或其他文件系统对象），其名称是路径名。如果 pathname 的符号链接文件权限这个符号链接所提到的测试.

mode 是一种包括一个或多个掩码 R_OK, W_OK, X_OK 和 F_OK.

R_OK, W_OK 和 X_OK 检查文件是否存在并具有读，写和执行权限，分别要求。 F_OK 只是要求检查存在的文件。

测试依赖于权限的目录中出现的文件路径 pathname ，并在途中遇到的符号链接的目录和文件的权限。

检查进程的真实的UID和GID，而不是ID作为实际尝试操作时的有效完成。这是为了让设置用户ID程序可以轻松地确定调用用户的权限。

只有访问位被选中，而不是文件类型或内容。因此，如果一个目录被发现是“可写，”它可能意味着文件可以在目录中创建，而不是作为一个文件可以写入该目录。同样，一个DOS文件可能被发现是“可执行文件”，但仍然会失败调用execve（2）调用。

如果过程中有适当的权限，执行可能表明，即使没有任何执行文件的权限位被设置为X_OK成功。

返回值

成功（所有请求的权限），则返回0。错误（至少一个位模式要求被拒绝的权限，或发生其他一些错误），则返回-1，errno设置为合适。

错误

access() 可能会失败，如果:

access() 可能会失败，如果:

限制

access() 返回一个错误，如果没有在所请求的调用失败的访问类型，即使其他类型可能会成功。

access() 可能无法正常工作与UID映射NFS文件系统上启用UID映射，因为在服务器上完成，并从客户端隐藏，检查权限。

使用 access() 来检查用户是否被授权，例如打开一个文件之前，其实这样使用 open(2)创建一个安全漏洞，因为用户可能会利用检查并打开文件操作的间隔时间短。

C遵循于

SVr4, POSIX.1-2001, 4.3BSD

请另参阅

• chmod (2)
• chown (2)
• faccessat (2)
• open (2)
• path_resolution (2)
• setgid (2)
• setuid (2)
• stat (2)

acct()函数

名称

acct - 切换或关闭进程记帐

内容简介

描述

与现有的文件名作为参数调用时，占被打开，每个终止的进程的记录，被追加到文件名作为终止。参数为NULL 引起占用被关闭。

返回值

成功则返回0。错误则返回-1，errno 设置为合适。

错误

遵循于

SVr4, 4.3BSD (but not POSIX).

注意

没有账号产生的程序运行时发生崩溃。特别是无穷的过程从来没有账号。

add_key()函数

名称

add_key - 添加到内核的密钥管理机制一个键

内容简介

描述

add_key() 要求内核给定类型和描述来创建或更新一个键，它的有效载荷plen 长度实例，将它安装到提名 keyringand，返回其序列号。

密钥类型可能会拒绝该数据，如果它是在错误的格式或以其他方式无效。

如果目标的钥匙圈已经包含匹配指定类型和描述，然后，如果密钥类型支持一个键，该键将被更新，而不是创建一个新的密钥，如果没有，将创建一个新的密钥，它将取代链接到现存的核心，从钥匙圈。

目的地钥匙圈序号可能是一个有效的钥匙圈，主调用写入权限，或者它可以是一个特殊的密钥环ID：

密钥类型

有很多可供选择的核心密钥管理代码的密钥类型，而这些可以被指定为这个函数：

返回值

成功 add_key() 返回序列号密钥，它创建或更新。错误将返回值-1并且errno将被设置为一个适当的错误。

错误

链接

虽然这是一个Linux系统调用，它是在libc中不存在，但可以发现合适的 libkey 工具。链接时，lkey 工具应指定给链接器。

另请参阅

• keyctl (1)
• keyctl (2)
• request_key (2)

adjtimex()函数

名称

adjtimex - 调内核时钟

内容简介

描述

Linux使用大卫L. Mills的时钟调整算法（参见RFC1305）。 adjtimex()系统调用读取和任选设置该算法的调整参数。这需要一个指针的TIMEX结构，更新内核参数字段值，并返回相同的结构与当前的内核值。这种结构的声明如下：

“modes ”字段确定的参数，如果有的话就设置。它可能包含一个按位或组合的零个或多个以下bits：

普通用户限制到零值模式mode。只有超级用户可以设置任何参数。

返回值

成功，adjtimex() 返回时钟状态：

如果失败，adjtimex（）返回-1，并设置errno。

错误

遵循于

adjtimex() 是Linux特有的，并且不应该被用在程序准备移植. 查看adjtime（3）用于调整系统时钟的方法，更轻便，但弹性较差。

另请参阅

• settimeofday (2)

afs_syscall()函数

名称

以下是Unix，Linux系统还没有实现的清单，写这个页面的时候的系统调用：

内容简介

未实现的系统调用。

描述

这些系统调用在Linux 2.4内核中没有实现。

返回值

这些系统调用总是返回-1，并设置

errno to ENOSYS.

注意

注意：ftime(3), profil(3) and ulimit(3) 实现了库函数。

系统调用如： alloc_hugepages(2), free_hugepages(2),ioperm(2), iopl(2), and vm86(2) 只存在于一定的架构。

系统调用如： ipc(2), create_module(2), init_module(2), anddelete_module(2) 只存在Linux内核时，内置支持他们。

另请参阅

• obsolete (2)

alarm()函数

名称

alarm - 设置闹钟传递信号

内容简介

描述

alarm() arranges for a SIGALRM signal to be delivered to the process in secondsseconds.

If seconds is zero, no new alarm() is scheduled.

In any event any previously set alarm() is cancelled.

返回值

alarm() 返回剩余的秒数，直到任何先前预定的报警是由于传递或零，如果没有先前预定的报警。

注意

alarm() and setitimer() share the same timer; calls to one will interfere with use of the other.

sleep() may be implemented using SIGALRM; mixing calls to alarm() and sleep() is a bad idea.

调度延迟，以往一样，导致执行任意数量的时间被推迟的进程。

系统中的每个进程都有一个私有的闹钟。这个闹钟很像一个计时器，可以设置在一定秒数后闹钟。时间一到，时钟就发送一个信号SIGALRM到进程。

函数原型：unsigned int alarm（unsigned int seconds);
头文件：#include<unistd.h>
函数说明: alarm()用来设置信号SIGALRM在经过参数seconds指定的秒数后，传送给目前的进程。如果参数seconds为0，则之前设置的闹钟会被取消，并将剩下的时间返回。
返回值：如果调用此alarm()前，进程已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。 出错返回-1。

例1：

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

unsigned int timeleft;



printf( "Set the alarm and sleep\n" ); alarm( 10 ); sleep( 5 );



timeleft = alarm( 0 ); //获得上一个闹钟的剩余时间：5秒 printf( "\Time left before cancel, and rearm: %d\n", timeleft );


alarm( timeleft );

printf( "\Hanging around, waiting to die\n" ); pause(); //让进程暂停直到信号出现

return EXIT_SUCCESS;

}

运行结果：

首先打印 Set the alarm and sleep

5秒后打印 Time left before cancel, and rearm: 5

Hanging around, waiting to die

再经过5秒，程序结束

除非进程为SIGALRM设置了处理函数，否则信号将杀死这个进程。比较下例中signal(SIGALRM, wakeup);语句打开与关闭的区别。

例2：

static void timer(int sig) { static int count=0; count++;

printf("\ncount = %d\n", count);

if(sig == SIGALRM) { printf("timer\n"); }



signal(SIGALRM, timer); alarm(1);



if (count == 5) alarm(0); return; }



int main(int argc, char *argv[]) { signal(SIGALRM, timer); alarm(1); while(1);

}

计时器的另一个用途是调度一个在将来的某个时刻发生的动作同时做些其他事情。调度一个将要发生的动作很简单，通过调用alarm来设置计时器，然后继续做别的事情。当计时器计时到0时，信号发送，处理函数被调用。

遵循于

SVr4, POSIX.1-2001, 4.3BSD

另请参阅

• gettimeofday (2)
• pause (2)
• select (2)
• setitimer (2)
• sigaction (2)
• signal (2)

alloc_hugepages()函数

名称

alloc_hugepages, free_hugepages - 分配或释放巨大的页面。

内容简介

描述

The system calls alloc_hugepages() and free_hugepages() were introduced in Linux 2.5.36 and removed again in 2.5.54. They existed only on i386 and ia64 (when built with CONFIG_HUGETLB_PAGE). In Linux 2.4.20 the syscall numbers exist, but the calls return ENOSYS.

On i386 the memory management hardware knows about ordinary pages (4 KiB) and huge pages (2 or 4 MiB). Similarly ia64 knows about huge pages of several sizes. These system calls serve to map huge pages into the process’ memory or to free them again. Huge pages are locked into memory, and are not swapped.

The key parameter is an identifier. When zero the pages are private, and not inherited by children. When positive the pages are shared with other applications using the samekey, and inherited by child processes.

The addr parameter of free_hugepages() tells which page is being freed: it was the return value of a call to alloc_hugepages(). (The memory is first actually freed when all users have released it.) The addr parameter of alloc_hugepages() is a hint, that the kernel may or may not follow. Addresses must be properly aligned.

The len parameter is the length of the required segment. It must be a multiple of the huge page size.

The prot parameter specifies the memory protection of the segment. It is one of PROT_READ, PROT_WRITE, PROT_EXEC.

The flag parameter is ignored, unless key is positive. In that case, if flag is IPC_CREAT, then a new huge page segment is created when none with the given key existed. If this flag is not set, then ENOENT is returned when no segment with the given key exists.

返回值

On success, alloc_hugepages() returns the allocated virtual address, andfree_hugepages() returns zero. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

These calls existed only in Linux 2.5.36 through to 2.5.54. These calls are specific to Linux on Intel processors, and should not be used in programs intended to be portable. Indeed, the system call numbers are marked for reuse, so programs using these may do something random on a future kernel.

文件

/proc/sys/vm/nr_hugepages Number of configured hugetlb pages. This can be read and written.

/proc/meminfo Gives info on the number of configured hugetlb pages and on their size in the three variables HugePages_Total, HugePages_Free, Hugepagesize.

注意

The system calls are gone. Now the hugetlbfs filesystem can be used instead. Memory backed by huge pages (if the CPU supports them) is obtained by using mmap() to map files in this virtual filesystem.

The maximal number of huge pages can be specified using the hugepages= boot parameter.

arch_prctl()函数

名称

arch_prctl - 设置架构特定的线程状态

内容简介

描述

arch_prctl() 函数设置架构的具体进程或线程状态。代码选择一个子功能和参数地址传递给它。

x86-64的子函数是：

错误

作者

Man page written by Andi Kleen.

遵循于

arch_prctl() 是一个Linux/x86-64的扩展，并且不应该被用在程序准备移植。

请另参阅

• mmap (2)
• modify_ldt (2)
• prctl (2)
• set_thread_area (2)

bdflush()函数

名称

bdflush - 启动，刷新，或调缓冲区脏刷新守护

内容简介

描述

bdflush() starts, flushes, or tunes the buffer-dirty-flush daemon. Only a privileged process (one with the CAP_SYS_ADMIN capability) may call bdflush().

If func is negative or 0, and no daemon has been started, then bdflush() enters the daemon code and never returns.

If func is 1, some dirty buffers are written to disk.

If func is 2 or more and is even (low bit is 0), then address is the address of a long word, and the tuning parameter numbered (func-2)/2 is returned to the caller in that address.

If func is 3 or more and is odd (low bit is 1), then data is a long word, and the kernel sets tuning parameter numbered (func-3)/2 to that value.

The set of parameters, their values, and their legal ranges are defined in the kernel source file fs/buffer.c.

返回值

If func is negative or 0 and the daemon successfully starts, bdflush() never returns. Otherwise, the return value is 0 on success and -1 on failure, with errno set to indicate the error.

错误

遵循于

bdflush() Linux特有的，并且不应该被用在程序准备移植。

另请参阅

• fsync (2)
• sync (2)
• sync (8)
• update (8)

bind()函数

名称

bind - 绑定一个名字到一个套接字

内容简介

#include

#include

int bind(int sockfd, const struct sockaddr *my_addr ", socklen_t " addrlen );

描述

bind() gives the socket sockfd the local address my_addr. my_addr is addrlen bytes long. Traditionally, this is called \(lqassigning a name to a socket.\(rq When a socket is created with socket(2), it exists in a name space (address family) but has no name assigned.

It is normally necessary to assign a local address using bind() before a SOCK_STREAMsocket may receive connections (see accept(2)).

The rules used in name binding vary between address families. Consult the manual entries in Section 7 for detailed information. For AF_INET see ip(7), for AF_INET6 seeipv6(7), for AF_UNIX see unix(7), for AF_APPLETALK see ddp(7), for AF_PACKET seepacket(7), for AF_X25 see x25(7) and for AF_NETLINK see netlink(7).

The actual structure passed for the my_addr argument will depend on the address family. The sockaddr structure is defined as something like:

#include

#include

#include

#include


#define MY_SOCK_PATH "/somepath"

int
main(int argc, char *argv[])
{
int sfd;
struct sockaddr_un addr;

sfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (sfd == -1) {
perror("socket");
exit(EXIT_FAILURE);
}
memset(&addr, 0, sizeof(struct sockaddr_un));
/* Clear structure */
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, MY_SOCK_PATH,
sizeof(addr.sun_path) - 1);
if (bind(sfd, (struct sockaddr *) &addr,
sizeof(struct sockaddr_un)) == -1) {
perror("bind");
exit(EXIT_FAILURE);
}
...
}

The only purpose of this structure is to cast the structure pointer passed in my_addr in order to avoid compiler warnings. The following example shows how this is done when binding a socket in the Unix (AF_UNIX) domain:

struct sockaddr {
sa_family_t sa_family;
char sa_data[14];
}

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

BUGS

透明代理的选择没有被描述。

遵循于

SVr4, 4.4BSD (the bind() function first appeared in 4.2BSD).

注意

The third argument of bind() is in reality an int (and this is what 4.x BSD and libc4 and libc5 have). Some POSIX confusion resulted in the present socklen_t, also used by glibc. See also accept(2).

另请参阅

• accept (2)
• connect (2)
• getsockname (2)
• listen (2)
• path_resolution (2)
• socket (2)

break未实现

名称

afs_syscall, break, fattach, fdetach, ftime, getmsg, getpmsg, gtty, isastream, lock, mpx, multiplexer, prof, profil, putmsg, putpmsg, security, stty, ulimit, vserver - 未实现的系统调用

内容简介

未实现的系统调用。

描述

这些系统调用在Linux 2.4内核中没有实现。

返回值

These system calls always return -1 and set errno to ENOSYS.

注意

Note that ftime(3), profil(3) and ulimit(3) are implemented as library functions.

Some system calls, like alloc_hugepages(2), free_hugepages(2), ioperm(2), iopl(2), and vm86(2) only exist on certain architectures.

Some system calls, like ipc(2), create_module(2), init_module(2), anddelete_module(2) only exist when the Linux kernel was built with support for them.

另请参阅

• obsolete (2)

brk()函数

名称

brk, sbrk - 改变数据段大小

内容简介

#include

int brk(void *end_data_segment);
void *sbrk(intptr_t increment);

描述

brk() sets the end of the data segment to the value specified by end_data_segment, when that value is reasonable, the system does have enough memory and the process does not exceed its max data size (see setrlimit(2)).

sbrk() increments the program’s data space by increment bytes. sbrk() isn’t a system call, it is just a C library wrapper. Calling sbrk() with an increment of 0 can be used to find the current location of the program break.

返回值

On success, brk() returns zero, and sbrk() returns a pointer to the start of the new area. On error, -1 is returned, and errno is set to ENOMEM.

遵循于

4.3BSD; SUSv1, marked LEGACY in SUSv2, removed in POSIX.1-2001.

brk() and sbrk() are not defined in the C Standard and are deliberately excluded from the POSIX.1 standard (see paragraphs B.1.1.1.3 and B.8.3.3).

注意

Various systems use various types for the parameter of sbrk(). Common are int, ssize_t,ptrdiff_t, intptr_t.

另请参阅

• execve (2)
• getrlimit (2)

cacheflush()函数

名称

cacheflush - 刷新指令和/或数据高速缓存的内容

内容简介

#include


int cacheflush(char *addr, int nbytes, int cache);

描述

cacheflush() 刷新指定的缓存（S）用户地址范围内的地址（地址为nbytes-1）的内容。缓存可能是：

返回值

cacheflush() 成功返回0或-1错误。如果检测到错误，errno将指示错误。

错误

BUGS

目前的实现忽略addr和nbytes以论据。因此，总是刷新整个缓存。

注意

这个系统调用是仅适用于基于MIPS的系统。它不应该被用于准备移植的程序。

chdir()函数

chdir, fchdir - 改变工作目录

内容简介

#include


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

描述

chdir() changes the current working directory to that specified in path. fchdir() is identical to chdir(); the only difference is that the directory is given as an open file descriptor.

返回值

成功，则返回0。上的错误，则返回-1，errno设置为合适。

错误

Depending on the file system, other errors can be returned. The more general errors for chdir() are listed below:

注意

A child process created via fork(2) inherits its parent’s current working directory. The current working directory is left unchanged by execve(2).

The prototype for fchdir() is only available if _BSD_SOURCE is defined, or_XOPEN_SOURCE is defined with the value 500.

遵循于

SVr4, 4.4BSD, POSIX.1-2001.

另请参阅

• chroot (2)
• path_resolution (2)

chmod()函数

名称

chmod, fchmod - 更改文件的权限

内容简介

#include

#include


int chmod(const char *path, mode_t mode);
int fchmod(int fildes, mode_t mode);

描述

给定的文件路径或引用fildes的的模式改变。

所指定的“或”以下模式：

The effective UID of the calling process must match the owner of the file, or the process must be privileged (Linux: it must have the CAP_FOWNER capability).

If the calling process is not privileged (Linux: does not have the CAP_FSETIDcapability), and the group of the file does not match the effective group ID of the process or one of its supplementary group IDs, the S_ISGID bit will be turned off, but this will not cause an error to be returned.

As a security measure, depending on the file system, the set-user-ID and set-group-ID execution bits may be turned off if a file is written. (On Linux this occurs if the writing process does not have the CAP_FSETID capability.) On some file systems, only the superuser can set the sticky bit, which may have a special meaning. For the sticky bit, and for set-user-ID and set-group-ID bits on directories, see stat(2).

On NFS file systems, restricting the permissions will immediately influence already open files, because the access control is done on the server, but open files are maintained by the client. Widening the permissions may be delayed for other clients if attribute caching is enabled on them.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

根据文件系统上的，其他错误，也可以返回，chmod() 更普遍的错误列举如下：

遵循于

4.4BSD, SVr4, POSIX.1-2001.

另请参阅

• chown (2)
• execve (2)
• fchmodat (2)
• open (2)
• path_resolution (2)
• stat (2)

chown()函数

chown, fchown, lchown - 改变文件的所有权

内容简介

描述

These system calls change the owner and group of the file specified by path or by fd. Only a privileged process (Linux: one with the CAP_CHOWN capability) may change the owner of a file. The owner of a file may change the group of the file to any group of which that owner is a member. A privileged process (Linux: with CAP_CHOWN) may change the group arbitrarily.

If the owner or group is specified as -1, then that ID is not changed. When the owner or group of an executable file are changed by a non-superuser, the S_ISUID and S_ISGID mode bits are cleared. POSIX does not specify whether this also should happen when root does the chown(); the Linux behaviour depends on the kernel version. In case of a non-group-executable file (with clear S_IXGRP bit) the S_ISGID bit indicates mandatory locking, and is not cleared by a chown().

返回值

成功，则返回0。上的错误，则返回-1，errno设置为合适。

错误

根据文件系统上的，其他错误，也可以返回 chown() 更一般的错误在下面列出。

注意

In versions of Linux prior to 2.1.81 (and distinct from 2.1.46), chown() did not follow symbolic links. Since Linux 2.1.81, chown() does follow symbolic links, and there is a new system call lchown() that does not follow symbolic links. Since Linux 2.1.86, this new call (that has the same semantics as the old chown()) has got the same syscall number, and chown() got the newly introduced number.

The prototype for fchown() is only available if _BSD_SOURCE is defined.

遵循于

4.4BSD, SVr4, POSIX.1-2001. The 4.4BSD version can only be used by the superuser (that is, ordinary users cannot give away files).

限制

The chown() semantics are deliberately violated on NFS file systems which have UID mapping enabled. Additionally, the semantics of all system calls which access the file contents are violated, because chown() may cause immediate access revocation on already open files. Client side caching may lead to a delay between the time where ownership have been changed to allow access for a user and the time where the file can actually be accessed by the user on other clients.

另请参阅

• chmod (2)
• fchownat (2)
• flock (2)
• path_resolution (2)

chroot()函数

chroot - 改变根目录

内容简介

描述

chroot() 改变根目录中指定的路径。此目录将用于与/开头的路径名。根目录继承当前进程的的所有子目录。

Only a privileged process (Linux: one with the CAP_SYS_CHROOT capability) may callchroot(2).This call changes an ingredient in the pathname resolution process and does nothing else.

This call does not change the current working directory, so that after the call ‘.’ can be outside the tree rooted at ‘/’. In particular, the superuser can escape from a ‘chroot jail’ by doing ‘mkdir foo; chroot foo; cd ..’.

This call does not close open file descriptors, and such file descriptors may allow access to files outside the chroot tree.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

Depending on the file system, other errors can be returned. The more general errors are listed below:

遵循于

SVr4, 4.4BSD, SUSv2 (marked LEGACY). This function is not part of POSIX.1-2001.

注意

A child process created via fork(2) inherits its parent’s root directory. The root directory is left unchanged by execve(2).

FreeBSD has a stronger jail() system call.

另请参阅

• chdir (2)
• path_resolution (2)

clone()函数

clone, __clone2 - 创建一个子进程

内容简介

#include


int clone(int (*fn)(void *), void *child_stack,
int flags, void *arg, ...
/* pid_t *pid, struct user_desc *tls
", pid_t *" ctid " */ );"



int __clone2(int (*fn)(void *), void *child_stack_base,
size_t stack_size, int flags, void *arg, ...
/* pid_t *pid, struct user_desc *tls
", pid_t *" ctid " */ );"
#include <sched.h>

描述

clone() creates a new process, in a manner similar to fork(2). It is actually a library function layered on top of the underlying clone() system call, hereinafter referred to assys_clone. A description of sys_clone is given towards the end of this page.

Unlike fork(2), these calls allow the child process to share parts of its execution context with the calling process, such as the memory space, the table of file descriptors, and the table of signal handlers. (Note that on this manual page, "calling process" normally corresponds to "parent process". But see the description of CLONE_PARENT below.)

The main use of clone() is to implement threads: multiple threads of control in a program that run concurrently in a shared memory space.

When the child process is created with clone(), it executes the function applicationfn(arg). (This differs from fork(2), where execution continues in the child from the point of the fork(2) call.) The fn argument is a pointer to a function that is called by the child process at the beginning of its execution. The arg argument is passed to the fn function.

When the fn(arg) function application returns, the child process terminates. The integer returned by fn is the exit code for the child process. The child process may also terminate explicitly by calling exit(2) or after receiving a fatal signal.

The child_stack argument specifies the location of the stack used by the child process. Since the child and calling process may share memory, it is not possible for the child process to execute in the same stack as the calling process. The calling process must therefore set up memory space for the child stack and pass a pointer to this space toclone(). Stacks grow downwards on all processors that run Linux (except the HP PA processors), so child_stack usually points to the topmost address of the memory space set up for the child stack.

The low byte of flags contains the number of the termination signal sent to the parent when the child dies. If this signal is specified as anything other than SIGCHLD, then the parent process must specify the __WALL or __WCLONE options when waiting for the child with wait(2). If no signal is specified, then the parent process is not signaled when the child terminates.

.

flags may also be bitwise-or’ed with zero or more of the following constants, in order to specify what is shared between the calling process and the child process:

sys_clone

The sys_clone system call corresponds more closely to fork(2) in that execution in the child continues from the point of the call. Thus, sys_clone only requires the flags andchild_stack arguments, which have the same meaning as for clone(). (Note that the order of these arguments differs from clone().)

Another difference for sys_clone is that the child_stack argument may be zero, in which case copy-on-write semantics ensure that the child gets separate copies of stack pages when either process modifies the stack. In this case, for correct operation, theCLONE_VM option should not be specified.

Since Linux 2.5.49 the system call has five parameters. The two new parameters areparent_tidptr which points to the location (in parent and child memory) where the child thread ID will be written in case CLONE_PARENT_SETTID was specified, and child_tidptrwhich points to the location (in child memory) where the child thread ID will be written in case CLONE_CHILD_SETTID was specified.

返回值

On success, the thread ID of the child process is returned in the caller’s thread of execution. On failure, a -1 will be returned in the caller’s context, no child process will be created, and errno will be set appropriately.

错误

VERSIONS

There is no entry for clone() in libc5. glibc2 provides clone() as described in this manual page.

遵循于

The clone() and sys_clone calls are Linux specific and should not be used in programs intended to be portable.

注意

In the kernel 2.4.x series, CLONE_THREAD generally does not make the parent of the new thread the same as the parent of the calling process. However, for kernel versions 2.4.7 to 2.4.18 the CLONE_THREAD flag implied the CLONE_PARENT flag (as in kernel 2.6).

For a while there was CLONE_DETACHED (introduced in 2.5.32): parent wants no child-exit signal. In 2.6.2 the need to give this together with CLONE_THREADdisappeared. This flag is still defined, but has no effect. On x86, clone() should not be called through vsyscall, but directly through int $0x80. On IA-64, a different system call is used:

int __clone2(int (*fn)(void *), void *child_stack_base,
size_t stack_size, int flags, void *arg, ...
/* pid_t *pid, struct user_desc *tls
", pid_t *" ctid " */ );"

The __clone2() system call operates in the same way as clone(), except thatchild_stack_base points to the lowest address of the child’s stack area, and stack_sizespecifies the size of the stack pointed to by child_stack_base.

BUGS

Versions of the GNU C library that include the NPTL threading library contain a wrapper function for getpid(2) that performs caching of PIDs. In programs linked against such libraries, calls to getpid(2) may return the same value, even when the threads were not created using CLONE_THREAD (and thus are not in the same thread group). To get the truth, it may be necessary to use code such as the following

#include <syscall.h>

pid_t mypid;

mypid = syscall(SYS_getpid);

另请参阅

• fork (2)
• futex (2)
• getpid (2)
• gettid (2)
• set_thread_area (2)
• set_tid_address (2)
• tkill (2)
• unshare (2)
• wait (2)

close()函数

close - 关闭一个文件描述符

内容简介

描述

close() closes a file descriptor, so that it no longer refers to any file and may be reused. Any record locks (see fcntl(2)) held on the file it was associated with, and owned by the process, are removed (regardless of the file descriptor that was used to obtain the lock).

If fd is the last copy of a particular file descriptor the resources associated with it are freed; if the descriptor was the last reference to a file which has been removed using unlink(2) the file is deleted.

返回值

close() 成功返回零。上的错误，则返回-1，errno设置为合适。

错误

遵循于

SVr4, 4.3BSD, POSIX.1-2001.

注意

Not checking the return value of close() is a common but nevertheless serious programming error. It is quite possible that errors on a previous write(2) operation are first reported at the final close(). Not checking the return value when closing the file may lead to silent loss of data. This can especially be observed with NFS and with disk quota.

A successful close does not guarantee that the data has been successfully saved to disk, as the kernel defers writes. It is not common for a filesystem to flush the buffers when the stream is closed. If you need to be sure that the data is physically stored use fsync(2). (It will depend on the disk hardware at this point.)

另请参阅

• fcntl (2)
• fsync (2)
• open (2)
• shutdown (2)
• unlink (2)

connect()函数

connect - 发起连接在套接字上

内容简介

#include

#include


int connect(int sockfd,
const struct sockaddr *serv_addr,
socklen_t addrlen);

描述

The connect() system call connects the socket referred to by the file descriptor sockfd to the address specified by serv_addr. The addrlen argument specifies the size of serv_addr. The format of the address in serv_addr is determined by the address space of the socket sockfd; see socket(2) for further details.

If the socket sockfd is of type SOCK_DGRAM then serv_addr is the address to which datagrams are sent by default, and the only address from which datagrams are received. If the socket is of type SOCK_STREAM or SOCK_SEQPACKET, this call attempts to make a connection to the socket that is bound to the address specified byserv_addr.

Generally, connection-based protocol sockets may successfully connect() only once; connectionless protocol sockets may use connect() multiple times to change their association. Connectionless sockets may dissolve the association by connecting to an address with the sa_family member of sockaddr set to AF_UNSPEC.

返回值

如果连接或绑定成功，则返回0。上的错误，则返回-1，anderrno设置适当。

错误

以下是一般的套接字错误。有可能是其他域特定的错误代码。

遵循于

SVr4, 4.4BSD (the connect() function first appeared in 4.2BSD).

注意

The third argument of connect() is in reality an int (and this is what 4.x BSD and libc4 and libc5 have). Some POSIX confusion resulted in the present socklen_t, also used by glibc. See also accept(2).

BUGS

Unconnecting a socket by calling connect() with a AF_UNSPEC address is not yet implemented.

另请参阅

• accept (2)
• bind (2)
• getsockname (2)
• listen (2)
• path_resolution (2)
• socket (2)

create_module()函数

create_module - 创建一个可加载模块项目

内容简介

描述

create_module() 尝试创建一个可加载模块项目，并预定将需要按住模块的内核内存。此系统调用需要的特权。

返回值

On success, returns the kernel address at which the module will reside. On error -1 is returned and errno is set appropriately.

错误

遵循于

create_module() is Linux specific.

注意

这个系统调用是目前唯一在Linux2.4内核，直到它在Linux2.6中删除。

另请参阅

• init_module (2)
• query_module (2)

open()函数

open, creat - 打开并可能创建一个文件或设备

内容简介

#include

#include

#include


int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
int creat(const char *pathname, mode_t mode);

描述

Given a pathname for a file, open() returns a file descriptor, a small, non-negative integer for use in subsequent system calls (read(2), write(2), lseek(2), fcntl(2), etc.). The file descriptor returned by a successful call will be the lowest-numbered file descriptor not currently open for the process.

The new file descriptor is set to remain open across an execve(2) (i.e., theFD_CLOEXEC file descriptor flag described in fcntl(2) is initially disabled). The file offset is set to the beginning of the file (see lseek(2)).

A call to open() creates a new open file description, an entry in the system-wide table of open files. This entry records the file offset and the file status flags (modifiable via thefcntl() F_SETFL operation). A file descriptor is a reference to one of these entries; this reference is unaffected if pathname is subsequently removed or modified to refer to a different file. The new open file description is initially not shared with any other process, but sharing may arise via fork(2).

The parameter flags must include one of the following access modes: O_RDONLY,O_WRONLY, or O_RDWR. These request opening the file read-only, write-only, or read/write, respectively.

In addition, zero or more file creation flags and file status flags can be bitwise-or’d inflags. The file creation flags are O_CREAT, O_EXCL, O_NOCTTY, and O_TRUNC. The file status flags are all of the remaining flags listed below. The distinction between these two groups of flags is that the file status flags can be retrieved and (in some cases) modified using fcntl(2).

文件创建标志和文件状态标志的完整列表如下：

mode must be specified when O_CREAT is in the flags, and is ignored otherwise.

creat() is equivalent to open() with flags equal to O_CREAT|O_WRONLY|O_TRUNC.

返回值

open() and creat() return the new file descriptor, or -1 if an error occurred (in which case, errno is set appropriately).

注意

Note that open() can open device special files, but creat() cannot create them; usemknod(2) instead.

On NFS file systems with UID mapping enabled, open() may return a file descriptor but e.g. read(2) requests are denied with EACCES. This is because the client performsopen() by checking the permissions, but UID mapping is performed by the server upon read and write requests.

If the file is newly created, its st_atime, st_ctime, st_mtime fields (respectively, time of last access, time of last status change, and time of last modification; see stat(2)) are set to the current time, and so are the st_ctime and st_mtime fields of the parent directory. Otherwise, if the file is modified because of the O_TRUNC flag, its st_ctime and st_mtime fields are set to the current time.

错误

注意

Under Linux, the O_NONBLOCK flag indicates that one wants to open but does not necessarily have the intention to read or write. This is typically used to open devices in order to get a file descriptor for use with ioctl(2).

遵循于

SVr4, 4.3BSD, POSIX.1-2001. The O_NOATIME, O_NOFOLLOW, and O_DIRECTORYflags are Linux-specific. One may have to define the _GNU_SOURCE macro to get their definitions.

The (undefined) effect of O_RDONLY | O_TRUNC varies among implementations. On many systems the file is actually truncated.

The O_DIRECT flag was introduced in SGI IRIX, where it has alignment restrictions similar to those of Linux 2.4. IRIX has also a fcntl(2) call to query appropriate alignments, and sizes.

FreeBSD 4.x introduced a flag of same name, but without alignment restrictions. Support was added under Linux in kernel version 2.4.10. Older Linux kernels simply ignore this flag. One may have to define the _GNU_SOURCE macro to get its definition.

BUGS

"The thing that has always disturbed me about O_DIRECT is that the whole interface is just stupid, and was probably designed by a deranged monkey on some serious mind-controlling substances." — Linus

Currently, it is not possible to enable signal-driven I/O by specifying O_ASYNC when calling open(); use fcntl(2) to enable this flag.

限制

There are many infelicities in the protocol underlying NFS, affecting amongst others O_SYNC and O_NDELAY.

POSIX provides for three different variants of synchronised I/O, corresponding to the flags O_SYNC, O_DSYNC and O_RSYNC. Currently (2.1.130) these are all synonymous under Linux.

另请参阅

• close (2)
• dup (2)
• fcntl (2)
• link (2)
• lseek (2)
• mknod (2)
• mount (2)
• mmap (2)
• openat (2)
• path_resolution (2)
• read (2)
• socket (2)
• stat (2)
• umask (2)
• unlink (2)
• write (2)

dup2()函数

dup, dup2 - 复制一个文件描述符

内容简介

#include


int dup(int oldfd);
int dup2(int oldfd, int newfd);

描述

dup() 和 dup2() 创建副本文件描述符oldfd。

After a successful return from dup() or dup2(),the old and new file descriptors may be used interchangeably. They refer to the same open file description (see open(2)) and thus share file offset and file status flags; for example, if the file offset is modified by using lseek(2) on one of the descriptors, the offset is also changed for the other.

The two descriptors do not share file descriptor flags (the close-on-exec flag). The close-on-exec flag (FD_CLOEXEC; see fcntl(2)) for the duplicate descriptor is off.

dup() uses the lowest-numbered unused descriptor for the new descriptor.

dup2() makes newfd be the copy of oldfd, closing newfd first if necessary.

返回值

dup() and dup2() return the new descriptor, or -1 if an error occurred (in which case,errno is set appropriately).

错误

WARNINGS

The error returned by dup2() is different from that returned by fcntl(..., F_DUPFD, ...)when newfd is out of range. On some systems dup2() also sometimes returns EINVAL like F_DUPFD.

If newfd was open, any errors that would have been reported at close() time, are lost. A careful programmer will not use dup2() without closing newfd first.

遵循于

SVr4, 4.3BSD, POSIX.1-2001.

另请参阅

• close (2)
• fcntl (2)
• open (2)

dup()函数

dup, dup2 - 复制一个文件描述符

内容简介

#include


int dup(int oldfd);
int dup2(int oldfd, int newfd);

描述

dup() 和 dup2() 创建文件描述符的副本 oldfd.

After a successful return from dup() or dup2(),the old and new file descriptors may be used interchangeably. They refer to the same open file description (see open(2)) and thus share file offset and file status flags; for example, if the file offset is modified by using lseek(2) on one of the descriptors, the offset is also changed for the other.

The two descriptors do not share file descriptor flags (the close-on-exec flag). The close-on-exec flag (FD_CLOEXEC; see fcntl(2)) for the duplicate descriptor is off.

dup() 使用编号最小的未用描述符的新的描述符。

dup2() 使得newfd是oldfd副本，先关闭newfd，如果必要的话。

返回值

dup() and dup2() return the new descriptor, or -1 if an error occurred (in which case,errno is set appropriately).

错误

警告

The error returned by dup2() is different from that returned by fcntl(..., F_DUPFD, ...)when newfd is out of range. On some systems dup2() also sometimes returns EINVALlike F_DUPFD.

If newfd was open, any errors that would have been reported at close() time, are lost. A careful programmer will not use dup2() without closing newfd first.

遵循于

SVr4, 4.3BSD, POSIX.1-2001.

另请参阅

• close (2)
• fcntl (2)
• open (2)

epoll_create()函数

epoll_create - 打开一个epoll的文件描述符

内容简介

#include


int epoll_create(int size)

描述

Open an epoll file descriptor by requesting the kernel allocate an event backing store dimensioned for size descriptors. The size is not the maximum size of the backing store but just a hint to the kernel about how to dimension internal structures. The returned file descriptor will be used for all the subsequent calls to the epoll interface. The file descriptor returned by epoll_create(2) must be closed by using close(2).

返回值

When successful, epoll_create(2) returns a non-negative integer identifying the descriptor. When an error occurs, epoll_create(2) returns -1 and errno is set appropriately.

错误

遵循于

epoll_create(2) 在Linux内核2.5.44 推出了一个新的API。该接口应该由Linux kernel 2.5.66。

另请参阅

• close (2)
• epoll_ctl (2)
• epoll_wait (2)

epoll_ctl()函数

epoll_ctl - 一个epoll的描述符的控制接口

内容简介

#include


int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

描述

Control an epoll descriptor, epfd, by requesting that the operation op be performed on the target file descriptor, fd. The event describes the object linked to the file descriptorfd. The struct epoll_event is defined as :

typedef union epoll_data {
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;

struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

该事件成员是位集由使用下列可用的事件类型：

返回值

When successful, epoll_ctl(2) returns zero. When an error occurs, epoll_ctl(2) returns -1 and errno is set appropriately.

错误

遵循于

epoll_ctl(2) is a new API introduced in Linux kernel 2.5.44. The interface should be finalized by Linux kernel 2.5.66.

BUG

In kernel versions before 2.6.9, the EPOLL_CTL_DEL operation required a non-NULL pointer in event, even though this argument is ignored. Since kernel 2.6.9, event can be specified as NULL when using EPOLL_CTL_DEL.

另请参阅

• epoll_create (2)
• poll (2)
• epoll_wait (2)

epoll_wait()函数

epoll_wait - 等待在 epoll 文件描述符的I/O事件

内容简介

#include


int epoll_wait(int epfd, struct epoll_event * events,
int maxevents, int timeout);

描述

Wait for events on the epoll file descriptor epfd for a maximum time of timeoutmilliseconds. The memory area pointed to by events will contain the events that will be available for the caller. Up to maxevents are returned by epoll_wait(2).

The maxevents parameter must be greater than zero. Specifying a timeout of -1 makesepoll_wait(2) wait indefinitely, while specifying a timeout equal to zero makesepoll_wait(2) to return immediately even if no events are available (return code equal to zero).

struct epoll_event 的定义如下 :

typedef union epoll_data {
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;


struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

The data of each returned structure will contain the same data the user set with a epoll_ctl(2) (EPOLL_CTL_ADD,EPOLL_CTL_MOD) while the events member will contain the returned event bit field.

返回值

When successful, epoll_wait(2) returns the number of file descriptors ready for the requested I/O, or zero if no file descriptor became ready during the requested timeoutmilliseconds. When an error occurs, epoll_wait(2) returns -1 and errno is set appropriately.

错误

遵循于

epoll_wait(2) is a new API introduced in Linux kernel 2.5.44. The interface should be finalized by Linux kernel 2.5.66.

另请参阅

• epoll_create (2)
• epoll_ctl (2)

execve()函数

execve - 执行程序

内容简介

#include


int execve(const char *filename, char *const argv[],
char *const envp[]);

描述

execve() executes the program pointed to by filename. filename must be either a binary executable, or a script starting with a line of the form "#! interpreter [arg]". In the latter case, the interpreter must be a valid pathname for an executable which is not itself a script, which will be invoked as interpreter [arg] filename.

argv is an array of argument strings passed to the new program. envp is an array of strings, conventionally of the form key=value, which are passed as environment to the new program. Both argv and envp must be terminated by a null pointer. The argument vector and environment can be accessed by the called program’s main function, when it is defined as int main(int argc, char *argv[], char *envp[]).

execve() does not return on success, and the text, data, bss, and stack of the calling process are overwritten by that of the program loaded. The program invoked inherits the calling process’s PID, and any open file descriptors that are not set to close-on-exec. Signals pending on the calling process are cleared. Any signals set to be caught by the calling process are reset to their default behaviour. The SIGCHLD signal (when set to SIG_IGN) may or may not be reset to SIG_DFL.

If the current program is being ptraced, a SIGTRAP is sent to it after a successfulexecve().

If the set-user-ID bit is set on the program file pointed to by filename, and the calling process is not being ptraced, then the effective user ID of the calling process is changed to that of the owner of the program file. i Similarly, when the set-group-ID bit of the program file is set the effective group ID of the calling process is set to the group of the program file.

The effective user ID of the process is copied to the saved set-user-ID; similarly, the effective group ID is copied to the saved set-group-ID. This copying takes place after any effective ID changes that occur because of the set-user-ID and set-group-ID permission bits.

If the executable is an a.out dynamically-linked binary executable containing shared-library stubs, the Linux dynamic linker ld.so(8) is called at the start of execution to bring needed shared libraries into memory and link the executable with them.

If the executable is a dynamically-linked ELF executable, the interpreter named in the PT_INTERP segment is used to load the needed shared libraries. This interpreter is typically /lib/ld-linux.so.1 for binaries linked with the Linux libc version 5, or /lib/ld-linux.so.2 for binaries linked with the GNU libc version 2.

返回值

On success, execve() does not return, on error -1 is returned, and errno is set appropriately.

错误

遵循于

SVr4, 4.3BSD, POSIX.1-2001. POSIX.1-2001 does not document the #! 行为，但在其他方面兼容。

注意

SUID and SGID processes can not be ptrace()d. Linux ignores the SUID and SGID bits on scripts.

The result of mounting a filesystem nosuid vary between Linux kernel versions: some will refuse execution of SUID/SGID executables when this would give the user powers she did not have already (and return EPERM), some will just ignore the SUID/SGID bits and exec() successfully.

A maximum line length of 127 characters is allowed for the first line in a #! executable shell script.

历史

With Unix V6 the argument list of an exec() call was ended by 0, while the argument list of main was ended by -1. Thus, this argument list was not directly usable in a furtherexec() call. Since Unix V7 both are NULL.

另请参阅

• chmod (2)
• fork (2)
• path_resolution (2)
• ptrace (2)
• ld (8)

exit_group函数

exit_group - 退出所有线程在一个进程

内容简介

#include


void exit_group(int status);

描述

This system call is equivalent to exit(2) except that it terminates not only the present thread, but all threads in the current thread group.

返回值

这个系统调用无返回。

历史

This call is present since Linux 2.5.35.

遵循于

这个调用是Linux特有的。

另请参阅

• exit (2)

_exit()函数

_exit, _Exit - 终止当前进程

内容简介

#include <unistd.h>

void _exit(int status);

#include <stdlib.h>

void _Exit(int status);

描述

The function _exit() terminates the calling process "immediately". Any open file descriptors belonging to the process are closed; any children of the process are inherited by process 1, init, and the process’s parent is sent a SIGCHLD signal.

The value status is returned to the parent process as the process’s exit status, and can be collected using one of the wait() family of calls.

_Exit() 函数等同于 _exit().

返回值

些函数没有返回值

遵循于

SVr4, POSIX.1-2001, 4.3BSD. The function _Exit() was introduced by C99.

注意

For a discussion on the effects of an exit, the transmission of exit status, zombie processes, signals sent, etc., see exit(3).

The function _exit() is like exit(), but does not call any functions registered with atexit() or on_exit(). Whether it flushes standard I/O buffers and removes temporary files created with tmpfile(3) is implementation dependent. On the other hand, _exit() does close open file descriptors, and this may cause an unknown delay, waiting for pending output to finish. If the delay is undesired, it may be useful to call functions like tcflush() before calling _exit(). Whether any pending I/O is cancelled, and which pending I/O may be cancelled upon _exit(), is implementation-dependent.

另请参阅

• execve (2)
• exit_group (2)
• fork (2)
• kill (2)
• wait (2)
• wait4 (2)
• waitpid (2)

exit()函数

_exit, _Exit - 终止当前进程

内容简介

#include


void _exit(int status);


#include



void _Exit(int status);

描述

The function _exit() terminates the calling process "immediately". Any open file descriptors belonging to the process are closed; any children of the process are inherited by process 1, init, and the process’s parent is sent a SIGCHLD signal.

The value status is returned to the parent process as the process’s exit status, and can be collected using one of the wait() family of calls.

The function _Exit() is equivalent to _exit().

返回值

These functions do not return.

遵循于

SVr4, POSIX.1-2001, 4.3BSD. The function _Exit() was introduced by C99.

注意

For a discussion on the effects of an exit, the transmission of exit status, zombie processes, signals sent, etc., see exit(3).

The function _exit() is like exit(), but does not call any functions registered with atexit() or on_exit(). Whether it flushes standard I/O buffers and removes temporary files created with tmpfile(3) is implementation dependent. On the other hand, _exit() does close open file descriptors, and this may cause an unknown delay, waiting for pending output to finish. If the delay is undesired, it may be useful to call functions like tcflush() before calling _exit(). Whether any pending I/O is cancelled, and which pending I/O may be cancelled upon _exit(), is implementation-dependent.

另请参阅

• execve (2)
• exit_group (2)
• fork (2)
• kill (2)
• wait (2)
• wait4 (2)
• waitpid (2)

faccessat()函数

faccessat - 文件相对于一个目录文件描述符的更改权限

内容简介

#include

<unistd.h>




int faccessat(int dirfd, const char *path, int
mode ", int " flags );

描述

The faccessat() system call operates in exactly the same way as access(2), except for the differences described in this manual page.

If the pathname given in path is relative, then it is interpreted relative to the directory referred to by the file descriptor dirfd (rather than relative to the current working directory of the calling process, as is done by access(2) for a relative pathname).

If the pathname given in path is relative and dirfd is the special value AT_FDCWD, thenpath is interpreted relative to the current working directory of the calling process (likeaccess(2)).

If the pathname given in path is absolute, then dirfd is ignored.

flags is constructed by ORing together zero or more of the following values:

返回值

On success, faccessat() returns 0. On error, -1 is returned and errno is set to indicate the error.

错误

The same errors that occur for access(2) can also occur for faccessat(). The following additional errors can occur for faccessat():

注意

See openat(2) for an explanation of the need for faccessat().

遵循于

这个系统调用是非标准的，但建议列入POSIX.1将来的修订版。

glibc的注意事项

The AT_EACCESS and AT_SYMLINK_NOFOLLOW flags are actually implemented within the glibc wrapper function for faccessat(). If either of these flags are specified, then the wrapper function employs fstatat(2) to determine access permissions.

版本

faccessat() 加入到Linux 的 kernel 2.6.16.

另请参阅

• access (2)
• openat (2)
• path_resolution (2)

fattach()函数

afs_syscall, break, fattach, fdetach, ftime, getmsg, getpmsg, gtty, isastream, lock, mpx, multiplexer, prof, profil, putmsg, putpmsg, security, stty, ulimit, vserver - 未实现系统调用

内容简介

未实现系统调用

描述

未实现系统调用在 Linux 2.4 kernel.

返回值

These system calls always return -1 and set errno to ENOSYS.

注意

Note that ftime(3), profil(3) and ulimit(3) are implemented as library functions.

Some system calls, like alloc_hugepages(2), free_hugepages(2), ioperm(2), iopl(2), and vm86(2) only exist on certain architectures.

Some system calls, like ipc(2), create_module(2), init_module(2), anddelete_module(2) only exist when the Linux kernel was built with support for them.

另请参阅

• obsolete (2)

fchdir()函数

chdir, fchdir - 改变工作目录

内容简介

#include


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

描述

chdir() changes the current working directory to that specified in path. fchdir() is identical to chdir(); the only difference is that the directory is given as an open file descriptor.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

Depending on the file system, other errors can be returned. The more general errors for chdir() are listed below:

注意

A child process created via fork(2) inherits its parent’s current working directory. The current working directory is left unchanged by execve(2).

The prototype for fchdir() is only available if _BSD_SOURCE is defined, or_XOPEN_SOURCE is defined with the value 500.

遵循于

SVr4, 4.4BSD, POSIX.1-2001.

另请参阅

• chroot (2)
• path_resolution (2)

fchmodat()函数

fchmodat - 文件相对于一个目录文件描述符的更改权限

内容简介

#include


int fchmodat(int dirfd, const char *path, mode_t
mode ", int " flags );

描述

The fchmodat() system call operates in exactly the same way as chmod(2), except for the differences described in this manual page.

If the pathname given in path is relative, then it is interpreted relative to the directory referred to by the file descriptor dirfd (rather than relative to the current working directory of the calling process, as is done by chmod(2) for a relative pathname).

If the pathname given in path is relative and dirfd is the special value AT_FDCWD, thenpath is interpreted relative to the current working directory of the calling process (likechmod(2)).

If the pathname given in path is absolute, then dirfd is ignored.

flags can either be 0, or include the following flag:

返回值

On success, fchmodat() returns 0. On error, -1 is returned and errno is set to indicate the error.

错误

The same errors that occur for chmod(2) can also occur for fchmodat(). The following additional errors can occur for fchmodat():

注意

See openat(2) for an explanation of the need for fchmodat().

遵循于

This system call is non-standard but is proposed for inclusion in a future revision of POSIX.1.

VERSIONS

fchmodat() was added to Linux in kernel 2.6.16.

另请参阅

• chmod (2)
• openat (2)
• path_resolution (2)

fchmod()函数

chmod, fchmod - 修改一个文件权限

内容简介

#include <sys/types.h>

#include <sys/stat.h>



int chmod(const char *
path
, mode_t
mode
);

int fchmod(int
fildes
, mode_t
mode
);

描述

The mode of the file given by path or referenced by fildes is changed.

Modes are specified by or’ing the following:

The effective UID of the calling process must match the owner of the file, or the process must be privileged (Linux: it must have the CAP_FOWNER capability).

If the calling process is not privileged (Linux: does not have the CAP_FSETIDcapability), and the group of the file does not match the effective group ID of the process or one of its supplementary group IDs, the S_ISGID bit will be turned off, but this will not cause an error to be returned.

As a security measure, depending on the file system, the set-user-ID and set-group-ID execution bits may be turned off if a file is written. (On Linux this occurs if the writing process does not have the CAP_FSETID capability.) On some file systems, only the superuser can set the sticky bit, which may have a special meaning. For the sticky bit, and for set-user-ID and set-group-ID bits on directories, see stat(2).

On NFS file systems, restricting the permissions will immediately influence already open files, because the access control is done on the server, but open files are maintained by the client. Widening the permissions may be delayed for other clients if attribute caching is enabled on them.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

Depending on the file system, other errors can be returned. The more general errors forchmod() are listed below:

遵循于

4.4BSD, SVr4, POSIX.1-2001.

另请参阅

• chown (2)
• execve (2)
• fchmodat (2)
• open (2)
• path_resolution (2)
• stat (2)

fchownat()函数

fchownat - 改变文件的一个相对的所有权到一个目录文件描述符

内容简介

#include

<unistd.h>



int fchownat(int dirfd, const char *path,
uid_t owner, gid_t group, int flags);

描述

The fchownat() system call operates in exactly the same way as chown(2), except for the differences described in this manual page.

If the pathname given in path is relative, then it is interpreted relative to the directory referred to by the file descriptor dirfd (rather than relative to the current working directory of the calling process, as is done by chown(2) for a relative pathname).

If the pathname given in path is relative and dirfd is the special value AT_FDCWD, thenpath is interpreted relative to the current working directory of the calling process (likechown(2)).

If the pathname given in path is absolute, then dirfd is ignored.

flags can either be 0, or include the following flag:

返回值

On success, fchownat() returns 0. On error, -1 is returned and errno is set to indicate the error.

错误

The same errors that occur for chown(2) can also occur for fchownat(). The following additional errors can occur for fchownat():

注意

See openat(2) for an explanation of the need for fchownat().

遵循于

This system call is non-standard but is proposed for inclusion in a future revision of POSIX.1. A similar system call exists on Solaris.

VERSIONS

fchownat() was added to Linux in kernel 2.6.16.

另请参阅

• chown (2)
• openat (2)
• path_resolution (2)

fchown()函数

chown, fchown, lchown - 更改文件的所有权

内容简介

#include <sys/types.h>

#include <unistd.h>


int chown(const char *
path
, uid_t
owner
, gid_t
group
);

int fchown(int
fd
, uid_t
owner
, gid_t
group
);

int lchown(const char *
path
, uid_t
owner
, gid_t
group
);

描述

These system calls change the owner and group of the file specified by path or by fd. Only a privileged process (Linux: one with the CAP_CHOWN capability) may change the owner of a file. The owner of a file may change the group of the file to any group of which that owner is a member. A privileged process (Linux: with CAP_CHOWN) may change the group arbitrarily.

If the owner or group is specified as -1, then that ID is not changed.

When the owner or group of an executable file are changed by a non-superuser, the S_ISUID and S_ISGID mode bits are cleared. POSIX does not specify whether this also should happen when root does the chown(); the Linux behaviour depends on the kernel version. In case of a non-group-executable file (with clear S_IXGRP bit) the S_ISGID bit indicates mandatory locking, and is not cleared by a chown().

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

Depending on the file system, other errors can be returned. The more general errors forchown() are listed below.

注意

In versions of Linux prior to 2.1.81 (and distinct from 2.1.46), chown() did not follow symbolic links. Since Linux 2.1.81, chown() does follow symbolic links, and there is a new system call lchown() that does not follow symbolic links. Since Linux 2.1.86, this new call (that has the same semantics as the old chown()) has got the same syscall number, and chown() got the newly introduced number.

The prototype for fchown() is only available if _BSD_SOURCE is defined.

遵循于

4.4BSD, SVr4, POSIX.1-2001.

The 4.4BSD version can only be used by the superuser (that is, ordinary users cannot give away files).

限制

The chown() semantics are deliberately violated on NFS file systems which have UID mapping enabled. Additionally, the semantics of all system calls which access the file contents are violated, because chown() may cause immediate access revocation on already open files. Client side caching may lead to a delay between the time where ownership have been changed to allow access for a user and the time where the file can actually be accessed by the user on other clients.

另请参阅

• chmod (2)
• fchownat (2)
• flock (2)
• path_resolution (2)

fcntl()函数

fcntl - 操作文件描述符

内容简介

#include <unistd.h>

#include <fcntl.h>


int fcntl(int
fd
, int
cmd
);

int fcntl(int
fd
, int
cmd
, long
arg
);

int fcntl(int
fd
, int
cmd
, struct flock *
lock
);

描述

fcntl() 执行下述就开文件描述符fd的操作之一。该操作是由 cmd 确定。

复制一个文件描述符

文件描述符标志

The following commands manipulate the flags associated with a file descriptor. Currently, only one such flag is defined: FD_CLOEXEC, the close-on-exec flag. If theFD_CLOEXEC bit is 0, the file descriptor will remain open across an execve(2), otherwise it will be closed.

文件状态标志

Each open file description has certain associated status flags, initialized by open(2) and possibly modified by fcntl(2). Duplicated file descriptors (made with dup(),fcntl(F_DUPFD), fork(), etc.) refer to the same open file description, and thus share the same file status flags.

The file status flags and their semantics are described in open(2).

咨询锁

F_GETLK, F_SETLK and F_SETLKW are used to acquire, release, and test for the existence of record locks (also known as file-segment or file-region locks). The third argument lock is a pointer to a structure that has at least the following fields (in unspecified order).

struct flock {
...
short l_type; /* Type of lock: F_RDLCK,
F_WRLCK, F_UNLCK */
short l_whence; /* How to interpret l_start:
SEEK_SET, SEEK_CUR, SEEK_END */
off_t l_start; /* Starting offset for lock */
off_t l_len; /* Number of bytes to lock */
pid_t l_pid; /* PID of process blocking our lock
(F_GETLK only) */
...
};

The l_whence, l_start, and l_len fields of this structure specify the range of bytes we wish to lock. l_start is the starting offset for the lock, and is interpreted relative to either: the start of the file (if l_whence is SEEK_SET); the current file offset (if l_whenceis SEEK_CUR); or the end of the file (if l_whence is SEEK_END). In the final two cases,l_start can be a negative number provided the offset does not lie before the start of the file. l_len is a non-negative integer (but see the NOTES below) specifying the number of bytes to be locked. Bytes past the end of the file may be locked, but not bytes before the start of the file. Specifying 0 for l_len has the special meaning: lock all bytes starting at the location specified by l_whence and l_start through to the end of file, no matter how large the file grows.

The l_type field can be used to place a read (F_RDLCK) or a write (F_WRLCK) lock on a file. Any number of processes may hold a read lock (shared lock) on a file region, but only one process may hold a write lock (exclusive lock). An exclusive lock excludes all other locks, both shared and exclusive. A single process can hold only one type of lock on a file region; if a new lock is applied to an already-locked region, then the existing lock is converted to the new lock type. (Such conversions may involve splitting, shrinking, or coalescing with an existing lock if the byte range specified by the new lock does not precisely coincide with the range of the existing lock.)

In order to place a read lock, fd must be open for reading. In order to place a write lock,fd must be open for writing. To place both types of lock, open a file read-write.

As well as being removed by an explicit F_UNLCK, record locks are automatically released when the process terminates or if it closes any file descriptor referring to a file on which locks are held. This is bad: it means that a process can lose the locks on a file like /etc/passwd or /etc/mtab when for some reason a library function decides to open, read and close it.

Record locks are not inherited by a child created via fork(2), but are preserved across an execve(2).

Because of the buffering performed by the stdio(3) library, the use of record locking with routines in that package should be avoided; use read(2) and write(2) instead.

强制锁

(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 compatible with the access. If the O_NONBLOCK flag is enabled, then the system call fails with the error EAGAIN or EWOULDBLOCK.

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 theMS_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 (seechmod(1) and chmod(2)).

管理信号

F_GETOWN, F_SETOWN, F_GETSIG and F_SETSIG are used to manage I/O availability signals:

Using these mechanisms, a program can implement fully asynchronous I/O without using select(2) or poll(2) most of the time.

The use of O_ASYNC, F_GETOWN, F_SETOWN is specific to BSD and Linux. F_GETSIGand F_SETSIG are Linux-specific. POSIX has asynchronous I/O and the aio_sigeventstructure to achieve similar things; these are also available in Linux as part of the GNU C Library (Glibc).

租约

F_SETLEASE and F_GETLEASE (Linux 2.4 onwards) are used (respectively) to establish and retrieve the current setting of the calling process’s lease on the file referred to byfd. A file lease provides a mechanism whereby the process holding the lease (the "lease holder") is notified (via delivery of a signal) when a process (the "lease breaker") tries to open(2) or truncate(2) that file.

When a process (the "lease breaker") performs an open() or truncate() that conflicts with a lease established via F_SETLEASE, the system call is blocked by the kernel and the kernel notifies the lease holder by sending it a signal (SIGIO by default). The lease holder should respond to receipt of this signal by doing whatever cleanup is required in preparation for the file to be accessed by another process (e.g., flushing cached buffers) and then either remove or downgrade its lease. A lease is removed by performing anF_SETLEASE command specifying arg as F_UNLCK. If we currently hold a write lease on the file, and the lease breaker is opening the file for reading, then it is sufficient to downgrade the lease to a read lease. This is done by performing an F_SETLEASEcommand specifying arg as F_RDLCK.

If the lease holder fails to downgrade or remove the lease within the number of seconds specified in /proc/sys/fs/lease-break-time then the kernel forcibly removes or downgrades the lease holder’s lease.

Once the lease has been voluntarily or forcibly removed or downgraded, and assuming the lease breaker has not unblocked its system call, the kernel permits the lease breaker’s system call to proceed.

If the lease breaker’s blocked open() or truncate() is interrupted by a signal handler, then the system call fails with the error EINTR, but the other steps still occur as described above. If the lease breaker is killed by a signal while blocked in open() ortruncate(), then the other steps still occur as described above. If the lease breaker specifies the O_NONBLOCK flag when calling open(), then the call immediately fails with the error EWOULDBLOCK, but the other steps still occur as described above.

The default signal used to notify the lease holder is SIGIO, but this can be changed using the F_SETSIG command to fcntl(). If a F_SETSIG command is performed (even one specifying SIGIO), and the signal handler is established using SA_SIGINFO, then the handler will receive a siginfo_t structure as its second argument, and the si_fd field of this argument will hold the descriptor of the leased file that has been accessed by another process. (This is useful if the caller holds leases against multiple files).

文件和目录更改通知

返回值

对于一个成功的调用，返回值取决于操作：

On error, -1 is returned, and errno is set appropriately.

错误

注意

The errors returned by dup2() are different from those returned by F_DUPFD.

Since kernel 2.0, there is no interaction between the types of lock placed by flock(2) and fcntl(2).

POSIX.1-2001 allows l_len to be negative. (And if it is, the interval described by the lock covers bytes l_start+l_len up to and including l_start-1.) This is supported by Linux since Linux 2.4.21 and 2.5.49.

Several systems have more fields in struct flock such as e.g. l_sysid. Clearly, l_pid alone is not going to be very useful if the process holding the lock may live on a different machine.

BUGS

A limitation of the Linux system call conventions on some architectures (notably x86) means that if a (negative) process group ID to be returned by F_GETOWN falls in the range -1 to -4095, then the return value is wrongly interpreted by glibc as an error in the system call; that is, the return value of fcntl() will be -1, and errno will contain the (positive) process group ID.

In Linux 2.4 and earlier, there is bug that can occur when an unprivileged process usesF_SETOWN to specify the owner of a socket file descriptor as a process (group) other than the caller. In this case, fcntl() can return -1 with errno set to EPERM, even when the owner process (group) is one that the caller has permission to send signals to. Despite this error return, the file descriptor owner is set, and signals will be sent to the owner.

遵循于

SVr4, 4.3BSD, POSIX.1-2001. Only the operations F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_SETFL, F_GETLK, F_SETLK, F_SETLKW, F_GETOWN, and F_SETOWN are specified in POSIX.1-2001.

F_GETSIG, F_SETSIG, F_NOTIFY, F_GETLEASE, and F_SETLEASE are Linux specific. (Define the _GNU_SOURCE macro to obtain these definitions.)

另请参阅

• dup2 (2)
• flock (2)
• open (2)
• socket (2)

fdatasync()函数

fdatasync - 同步的核心与该数据在磁盘上的文件

内容简介

#include <unistd.h>


int fdatasync(int
fd
);

描述

fdatasync() flushes all data buffers of a file to disk (before the system call returns). It resembles fsync() but is not required to update the metadata such as access time.

Applications that access databases or log files often write a tiny data fragment (e.g., one line in a log file) and then call fsync() immediately in order to ensure that the written data is physically stored on the harddisk. Unfortunately, fsync() will always initiate two write operations: one for the newly written data and another one in order to update the modification time stored in the inode.

If the modification time is not a part of the transaction concept fdatasync() can be used to avoid unnecessary inode disk write operations.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

BUGS

Currently (Linux 2.2) fdatasync() is equivalent to fsync().

可用性

On POSIX systems on which fdatasync() is available, _POSIX_SYNCHRONIZED_IO is defined in <unistd.h> to a value greater than 0. (See also sysconf(3).)

遵循于

POSIX.1-2001.

另请参阅

• fsync (2)
• sync_file_range (2)

fdetach()函数

afs_syscall, break, fattach, fdetach, ftime, getmsg, getpmsg, gtty, isastream, lock, mpx, multiplexer, prof, profil, putmsg, putpmsg, security, stty, ulimit, vserver - 未实现系统调用

内容简介

未实现系统调用。

描述

这些系统调用未实现在 Linux 2.4 kernel.

返回值

These system calls always return -1 and set errno to ENOSYS.

注意

Note that ftime(3), profil(3) and ulimit(3) are implemented as library functions.

Some system calls, like alloc_hugepages(2), free_hugepages(2), ioperm(2), iopl(2), and vm86(2) only exist on certain architectures.

Some system calls, like ipc(2), create_module(2), init_module(2), anddelete_module(2) only exist when the Linux kernel was built with support for them.

另请参阅

• obsolete (2)

flock()函数

flock - 应用或删除上一个打开的文件的咨询锁

内容简介

#include <sys/file.h>

int flock(int
fd
, int
operation
);

描述

应用或删除由 fd 所指定的打开文件的咨询锁。参数操作是执行下列操作之一：

A call to flock() may block if an incompatible lock is held by another process. To make a non-blocking request, include LOCK_NB (by ORing) with any of the above operations.

A single file may not simultaneously have both shared and exclusive locks.

Locks created by flock() are associated with an open file table entry. This means that duplicate file descriptors (created by, for example, fork(2) or dup(2)) refer to the same lock, and this lock may be modified or released using any of these descriptors. Furthermore, the lock is released either by an explicit LOCK_UN operation on any of these duplicate descriptors, or when all such descriptors have been closed.

If a process uses open(2) (or similar) to obtain more than one descriptor for the same file, these descriptors are treated independently by flock(). An attempt to lock the file using one of these file descriptors may be denied by a lock that the calling process has already placed via another descriptor.

A process may only hold one type of lock (shared or exclusive) on a file. Subsequentflock() calls on an already locked file will convert an existing lock to the new lock mode.

Locks created by flock() are preserved across an execve(2).

A shared or exclusive lock can be placed on a file regardless of the mode in which the file was opened.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

4.4BSD (the flock(2) call first appeared in 4.2BSD). A version of flock(2), possibly implemented in terms of fcntl(2), appears on most Unices.

注意

flock(2) does not lock files over NFS. Use fcntl(2) instead: that does work over NFS, given a sufficiently recent version of Linux and a server which supports locking.

Since kernel 2.0, flock(2) is implemented as a system call in its own right rather than being emulated in the GNU C library as a call to fcntl(2). This yields true BSD semantics: there is no interaction between the types of lock placed by flock(2) and fcntl(2), andflock(2) does not detect deadlock.

flock(2) places advisory locks only; given suitable permissions on a file, a process is free to ignore the use of flock(2) and perform I/O on the file.

flock(2) and fcntl(2) locks have different semantics with respect to forked processes and dup(2). On systems that implement flock() using fcntl(), the semantics of flock() will be different from those described in this manual page.

Converting a lock (shared to exclusive, or vice versa) is not guaranteed to be atomic: the existing lock is first removed, and then a new lock is established. Between these two steps, a pending lock request by another process may be granted, with the result that the conversion either blocks, or fails if LOCK_NB was specified. (This is the original BSD behaviour, and occurs on many other implementations.)

另请参阅

• close (2)
• dup (2)
• execve (2)
• fcntl (2)
• fork (2)
• open (2)

fork()函数

fork - 创建一个子进程

内容简介

#include <sys/types.h>

#include <unistd.h>
pid_t fork(void);

描述

fork() creates a child process that differs from the parent process only in its PID and PPID, and in the fact that resource utilizations are set to 0. File locks and pending signals are not inherited.

Under Linux, fork() is implemented using copy-on-write pages, so the only penalty that it incurs is the time and memory required to duplicate the parent’s page tables, and to create a unique task structure for the child.

返回值

On success, the PID of the child process is returned in the parent’s thread of execution, and a 0 is returned in the child’s thread of execution. On failure, a -1 will be returned in the parent’s context, no child process will be created, and errno will be set appropriately.

错误

遵循于

SVr4, 4.3BSD, POSIX.1-2001.

另请参阅

• clone (2)
• execve (2)
• setrlimit (2)
• unshare (2)
• vfork (2)
• wait (2)

alloc_hugepages()函数

alloc_hugepages, free_hugepages - 分配或释放巨大的页面

内容简介

void *alloc_hugepages(int
key
, void *
addr
, size_t
len
,

int
prot
, int
flag
);

int free_hugepages(void *
addr
);

描述

The system calls alloc_hugepages() and free_hugepages() were introduced in Linux 2.5.36 and removed again in 2.5.54. They existed only on i386 and ia64 (when built with CONFIG_HUGETLB_PAGE). In Linux 2.4.20 the syscall numbers exist, but the calls return ENOSYS.

On i386 the memory management hardware knows about ordinary pages (4 KiB) and huge pages (2 or 4 MiB). Similarly ia64 knows about huge pages of several sizes. These system calls serve to map huge pages into the process’ memory or to free them again. Huge pages are locked into memory, and are not swapped.

The key parameter is an identifier. When zero the pages are private, and not inherited by children. When positive the pages are shared with other applications using the samekey, and inherited by child processes.

The addr parameter of free_hugepages() tells which page is being freed: it was the return value of a call to alloc_hugepages(). (The memory is first actually freed when all users have released it.) The addr parameter of alloc_hugepages() is a hint, that the kernel may or may not follow. Addresses must be properly aligned.

The len parameter is the length of the required segment. It must be a multiple of the huge page size.

The prot parameter specifies the memory protection of the segment. It is one of PROT_READ, PROT_WRITE, PROT_EXEC.

The flag parameter is ignored, unless key is positive. In that case, if flag is IPC_CREAT, then a new huge page segment is created when none with the given key existed. If this flag is not set, then ENOENT is returned when no segment with the given key exists.

返回值

On success, alloc_hugepages() returns the allocated virtual address, andfree_hugepages() returns zero. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

These calls existed only in Linux 2.5.36 through to 2.5.54. These calls are specific to Linux on Intel processors, and should not be used in programs intended to be portable. Indeed, the system call numbers are marked for reuse, so programs using these may do something random on a future kernel.

文件

/proc/sys/vm/nr_hugepages Number of configured hugetlb pages. This can be read and written.

/proc/meminfo Gives info on the number of configured hugetlb pages and on their size in the three variables HugePages_Total, HugePages_Free, Hugepagesize.

注意

The system calls are gone. Now the hugetlbfs filesystem can be used instead. Memory backed by huge pages (if the CPU supports them) is obtained by using mmap() to map files in this virtual filesystem.

The maximal number of huge pages can be specified using the hugepages= boot parameter.

fstatat()函数

fstatat - 得到相对文件的状态到一个目录文件描述符

内容简介

#include <sys/stat.h>

int fstatat(int
dirfd
, const char *
path
, struct stat *
buf ", int " flags );

描述

The fstatat() system call operates in exactly the same way as stat(2), except for the differences described in this manual page.

If the pathname given in path is relative, then it is interpreted relative to the directory referred to by the file descriptor dirfd (rather than relative to the current working directory of the calling process, as is done by stat(2) for a relative pathname).

If the pathname given in path is relative and dirfd is the special value AT_FDCWD, thenpath is interpreted relative to the current working directory of the calling process (likestat(2)).

If the pathname given in path is absolute, then dirfd is ignored.

flags can either be 0, or include the following flag:

返回值

On success, fstatat() returns 0. On error, -1 is returned and errno is set to indicate the error.

错误

The same errors that occur for stat(2) can also occur for fstatat(). The following additional errors can occur for fstatat():

注意

See openat(2) for an explanation of the need for fstatat().

遵循于

This system call is non-standard but is proposed for inclusion in a future revision of POSIX.1. A similar system call exists on Solaris.

版本

fstatat() was added to Linux in kernel 2.6.16.

另请参阅

• openat (2)
• path_resolution (2)
• stat (2)

statfs()函数

statfs, fstatfs - 获取文件系统统计信息

内容简介

#include <sys/vfs.h>
/* or <sys/statfs.h> */

int statfs(const char *
path
, struct statfs *
buf
);

int fstatfs(int
fd
, struct statfs *
buf
);

描述

The function statfs() returns information about a mounted file system. path is the pathname of any file within the mounted filesystem. buf is a pointer to a statfs structure defined approximately as follows:

文件系统类型：

Nobody knows what f_fsid is supposed to contain (but see below).

Fields that are undefined for a particular file system are set to 0. fstatfs() returns the same information about an open file referenced by descriptor fd.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

The Linux statfs() was inspired by the 4.4BSD one (but they do not use the same structure).

注意

The kernel has system calls statfs(), fstatfs(), statfs64(), and fstatfs64() to support this library call.

Some systems only have <sys/vfs.h>, other systems also have <sys/statfs.h>, where the former includes the latter. So it seems including the former is the best choice.

LSB has deprecated the library calls statfs() and fstatfs() and tells us to use statvfs() and fstatvfs() instead.

f_fsid 字段

Solaris, Irix and POSIX have a system callstatvfs(2) that returns astruct statvfs (defined in <sys/statvfs.h>) containing an unsigned long f_fsid. Linux, SunOS, HP-UX, 4.4BSD have a system call statfs() that returns a struct statfs (defined in <sys/vfs.h>) containing afsid_t f_fsid, where fsid_t is defined as struct { int val[2]; }. The same holds for FreeBSD, except that it uses the include file <sys/mount.h>.

The general idea is that f_fsid contains some random stuff such that the pair (f_fsid,ino) uniquely determines a file. Some OSes use (a variation on) the device number, or the device number combined with the filesystem type. Several OSes restrict giving out thef_fsid field to the superuser only (and zero it for unprivileged users), because this field is used in the filehandle of the filesystem when NFS-exported, and giving it out is a security concern.

Under some OSes the fsid can be used as second parameter to the b>sysfs() system call.

另请参阅

• path_resolution (2)
• stat (2)
• statvfs (2)

stat()函数

stat, fstat, lstat - 获取文件状态

内容简介

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>


int stat(const char *
path
, struct stat *
buf
);

int fstat(int
filedes
, struct stat *
buf
);

int lstat(const char *
path
, struct stat *
buf
);

描述

These functions return information about a file. No permissions are required on the file itself, but — in the case of stat() and lstat() — execute (search) permission is required on all of the directories in path that lead to the file.

stat() stats the file pointed to by path and fills in buf. lstat() is identical to stat(), except that if path is a symbolic link, then the link itself is stat-ed, not the file that it refers to.

fstat() is identical to stat(), except that the file to be stat-ed is specified by the file descriptor filedes.

All of these system calls return a stat structure, which contains the following fields:

The st_dev field describes the device on which this file resides.

The st_rdev field describes the device that this file (inode) represents.

The st_size field gives the size of the file (if it is a regular file or a symbolic link) in bytes. The size of a symlink is the length of the pathname it contains, without a trailing null byte.

The st_blocks field indicates the number of blocks allocated to the file, 512-byte units. (This may be smaller than st_size/512, for example, when the file has holes.)

The st_blksize field gives the "preferred" blocksize for efficient file system I/O. (Writing to a file in smaller chunks may cause an inefficient read-modify-rewrite.)

Not all of the Linux filesystems implement all of the time fields. Some file system types allow mounting in such a way that file accesses do not cause an update of the st_atimefield. (See ‘noatime’ in mount(8).)

The field st_atime is changed by file accesses, e.g. by execve(2), mknod(2), pipe(2),utime(2) and read(2) (of more than zero bytes). Other routines, like mmap(2), may or may not update st_atime.

The field st_mtime is changed by file modifications, e.g. by mknod(2), truncate(2),utime(2) and write(2) (of more than zero bytes). Moreover, st_mtime of a directory is changed by the creation or deletion of files in that directory. The st_mtime field is notchanged for changes in owner, group, hard link count, or mode.

The field st_ctime is changed by writing or by setting inode information (i.e., owner, group, link count, mode, etc.).

The following POSIX macros are defined to check the file type using the st_mode field:

以下标志被定义为st_mode字段：

The set-group-ID bit (S_ISGID) has several special uses. For a directory it indicates that BSD semantics is to be used for that directory: files created there inherit their group ID from the directory, not from the effective group ID of the creating process, and directories created there will also get the S_ISGID bit set. For a file that does not have the group execution bit (S_IXGRP) set, the set-group-ID bit indicates mandatory file/record locking.

The ‘sticky’ bit (S_ISVTX) on a directory means that a file in that directory can be renamed or deleted only by the owner of the file, by the owner of the directory, and by a privileged process.

Linux注意事项

Since kernel 2.5.48, the stat structure supports nanosecond resolution for the three file timestamp fields. Glibc exposes the nanosecond component of each field using names either of the form st_atim.tv_nsec, if the _BSD_SOURCE or _SVID_SOURCE feature test macro is defined, or of the form st_atimensec, if neither of these macros is defined. On file systems that do not support sub-second timestamps, these nanosecond fields are returned with the value 0.

For most files under the /proc directory, stat() does not return the file size in the st_sizefield; instead the field is returned with the value 0.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

These system calls conform to SVr4, 4.3BSD, POSIX.1-2001.

Use of the st_blocks and st_blksize fields may be less portable. (They were introduced in BSD. The interpretation differs between systems, and possibly on a single system when NFS mounts are involved.)

POSIX does not describe the S_IFMT, S_IFSOCK, S_IFLNK, S_IFREG, S_IFBLK, S_IFDIR, S_IFCHR, S_IFIFO, S_ISVTX bits, but instead demands the use of the macros S_ISDIR(), etc. The S_ISLNK and S_ISSOCK macros are not in POSIX.1-1996, but both are present in POSIX.1-2001; the former is from SVID 4, the latter from SUSv2.

Unix V7 (and later systems) had S_IREAD, S_IWRITE, S_IEXEC, where POSIX prescribes the synonyms S_IRUSR, S_IWUSR, S_IXUSR.

其它系统

Values that have been (or are) in use on various systems:

A sticky command appeared in Version 32V AT&T UNIX.

另请参阅

• access (2)
• chmod (2)
• chown (2)
• fstatat (2)
• readlink (2)
• utime (2)

statvfs()函数

statvfs, fstatvfs - 获取文件系统统计信息

内容简介

#include <sys/statvfs.h>
int statvfs(const char *
path
, struct statvfs *
buf
);

int fstatvfs(int
fd
, struct statvfs *
buf
);

描述

The function statvfs() returns information about a mounted file system. path is the pathname of any file within the mounted filesystem. buf is a pointer to a statvfsstructure defined approximately as follows:

Here the types fsblkcnt_t and fsfilcnt_t are defined in <sys/types.h>. Both used to beunsigned long.

The field f_flag is a bit mask (of mount flags, see mount(8)). Bits defined by POSIX are

它是不确定的返回结构的所有成员是否对所有文件系统有意义的值。

fstatvfs() 返回有关由描述符fd指定打开的文件相同的信息。

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

Solaris, Irix, POSIX.1-2001

注意

The Linux kernel has system calls statfs() and fstatfs() to support this library call.

The current glibc implementation of

uses the f_frsize, f_frsize, and f_bsize fields of the return value of statvfs(path,buf).

另请参阅

• statfs (2)

fsync()函数

fsync, fdatasync - 同步文件在内核态与存储设备

内容简介

#include <unistd.h>
int fsync(int
fd
);
int fdatasync(int
fd
);

描述

fsync() transfers ("flushes") all modified in-core data of (i.e., modified buffer cache pages for) the file referred to by the file descriptor fd to the disk device (or other permanent storage device) where that file resides. The call blocks until the device reports that the transfer has completed. It also flushes metadata information associated with the file (see stat(2)).

Calling fsync() does not necessarily ensure that the entry in the directory containing the file has also reached disk. For that an explicit fsync() on a file descriptor for the directory is also needed.

fdatasync() is similar to fsync(), but does not flush modified metadata unless that metadata is needed in order to allow a subsequent data retrieval to be correctly handled. For example, changes to st_atime or st_mtime (respectively, time of last access and time of last modification; see stat(2)) do not not require flushing because they are not necessary for a subsequent data read to be handled correctly. On the other hand, a change to the file size (st_size, as made by say ftruncate(2)), would require a metadata flush.

The aim of fdatasync(2) is to reduce disk activity for applications that do not require all metadata to be synchronised with the disk.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

注意

If the underlying hard disk has write caching enabled, then the data may not really be on permanent storage when fsync() / fdatasync() return.

When an ext2 file system is mounted with the sync option, directory entries are also implicitly synced by fsync().

On kernels before 2.4, fsync() on big files can be inefficient. An alternative might be to use the O_SYNC flag to open(2).

遵循于

POSIX.1-2001

另请参阅

• bdflush (2)
• open (2)
• sync (2)
• sync_file_range (2)
• hdparm (8)
• mount (8)
• sync (8)
• update (8)

truncate()函数

truncate, ftruncate - 截断一个文件到指定的长度

内容简介

#include <unistd.h>

#include <sys/types.h>


int truncate(const char *
path
, off_t
length
);

int ftruncate(int
fd
, off_t
length
);

描述

The truncate() and ftruncate() functions cause the regular file named by path or referenced by fd to be truncated to a size of precisely length bytes.

If the file previously was larger than this size, the extra data is lost. If the file previously was shorter, it is extended, and the extended part reads as null bytes (’\0’). The file offset is not changed.

If the size changed, then the st_ctime and st_mtime fields (respectively, time of last status change and time of last modification; see stat(2)) for the file are updated, and the set-user-ID and set-group-ID permission bits may be cleared.

With ftruncate(), the file must be open for writing; with truncate(), the file must be writable.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

For truncate():

遵循于

4.4BSD, SVr4, POSIX.1-2001 (these calls first appeared in 4.2BSD).

注意

The above description is for XSI-compliant systems. For non-XSI-compliant systems, the POSIX standard allows two behaviours for ftruncate() when length exceeds the file length (note that truncate() is not specified at all in such an environment): either returning an error, or extending the file.

Like most Unix implementations, Linux follows the XSI requirement when dealing with native file systems. However, some non-native file systems do not permit truncate() and ftruncate() to be used to extend a file beyond its current length: a notable example on Linux is VFAT.

另请参阅

• open (2)
• path_resolution (2)
• stat (2)

futex()函数

futex - 快速用户空间锁定系统调用

内容简介

描述

The futex() system call provides a method for a program to wait for a value at a given address to change, and a method to wake up anyone waiting on a particular address (while the addresses for the same memory in separate processes may not be equal, the kernel maps them internally so the same memory mapped in different locations will correspond for futex() calls). It is typically used to implement the contended case of a lock in shared memory, as described in futex(7).

When a futex(7) operation did not finish uncontended in userspace, a call needs to be made to the kernel to arbitrate. Arbitration can either mean putting the calling process to sleep or, conversely, waking a waiting process.

Callers of this function are expected to adhere to the semantics as set out in futex(7). As these semantics involve writing non-portable assembly instructions, this in turn probably means that most users will in fact be library authors and not general application developers.

The uaddr argument needs to yiibai to an aligned integer which stores the counter. The operation to execute is passed via the op parameter, along with a value val.

Five operations are currently defined:

返回值

Depending on which operation was executed, the returned value can have differing meanings.

错误

注意

To reiterate, bare futexes are not intended as an easy to use abstraction for end-users. Implementors are expected to be assembly literate and to have read the sources of the futex userspace library referenced below.

版本

Initial futex support was merged in Linux 2.5.7 but with different semantics from what was described above. A 4-parameter system call with the semantics given here was introduced in Linux 2.5.40. In Linux 2.5.70 one parameter was added. In Linux 2.6.7 a sixth parameter was added — messy, especially on the s390 architecture.

遵循于

This system call is Minux specific.

futimesat()函数

futimes - 改变文件的一个相对的时间戳到一个目录文件描述符

内容简介

描述

The futimesat() system call operates in exactly the same way as utimes(2), except for the differences described in this manual page.

If the pathname given in pathname is relative, then it is interpreted relative to the directory referred to by the file descriptor dirfd (rather than relative to the current working directory of the calling process, as is done by utimes(2) for a relative pathname).

If the pathname given in pathname is relative and dirfd is the special value AT_FDCWD, then pathname is interpreted relative to the current working directory of the calling process (like utimes(2)).

If the pathname given in pathname is absolute, then dirfd is ignored.

返回值

On success, futimesat() returns a 0. On error, -1 is returned and errno is set to indicate the error.

错误

The same errors that occur for utimes(2) can also occur for futimesat(). The following additional errors can occur for futimesat():

遵循于

This system call is non-standard but is proposed for inclusion in a future revision of POSIX.1. A similar system call exists on Solaris.

GLIBC 注意

If the path argument is NULL, then the glibc futimes() wrapper function updates the times for the file referred to by dirfd.

版本

futimesat() was added to Linux in kernel 2.6.16.

另请参阅

• path_resolution (2)
• stat (2)
• utimes (2)

getcontext()函数

getcontext, setcontext - 获取或设置用户环境

内容简介

#include <ucontext.h>

int getcontext(ucontext_t *
ucp
);
 
int setcontext(const ucontext_t *
ucp
);

where:

描述

getcontext(2) gets the current context of the calling process, storing it in the ucontext struct pointed to by ucp.

setcontext(2) sets the context of the calling process to the state stored in the ucontext struct pointed to by ucp. The struct must either have been created by getcontext(2) or have been passed as the third parameter of the sigaction(2) signal handler.

The ucontext struct created by getcontext(2) is defined in <ucontext.h> as follows:

RETURN VALUES

getcontext(2) returns 0 on success and -1 on failure. setcontext(2) does not return a value on success and returns -1 on failure.

STANDARDS

These functions comform to: XPG4-UNIX.

注意

When a signal handler executes, the current user context is saved and a new context is created by the kernel. If the calling process leaves the signal handler using longjmp(2), the original context cannot be restored, and the result of future calls to getcontext(2) are unpredictable. To avoid this problem, use siglongjmp(2) or setcontext(2) in signal handlers instead of longjmp(2).

另请参阅

sigaltstack(2), sigprocmask(2), sigsetjmp(3), setjmp(3).

getcwd()函数

getcwd - 获取当前工作目录

内容简介

描述

The getcwd() function copies an absolute pathname of the current working directory to the array pointed to by buf, which is of length size.

If the current absolute path name would require a buffer longer than size elements, -1is returned, and errno is set to ERANGE; an application should check for this error, and allocate a larger buffer if necessary.

If buf is NULL, the behaviour of getcwd() is undefined.

返回值

-1 on failure (for example, if the current directory is not readable), with errno set accordingly, and the number of characters stored in buf on success. The contents of the array pointed to by buf is undefined on error.

Note that this return value differs from the getcwd(3) library function, which returnsNULL on failure and the address of buf on success.

错误

遵循于

The getcwd system call is Linux specific, use the getcwd C library function for portability.

另请参阅

getdents()函数

getdents - 获得目录项

内容简介

描述

This is not the function you are interested in. Look at readdir(3) for the POSIX conforming C library interface. This page documents the bare kernel system call interface.

The system call getdents() reads several dirent structures from the directory pointed at by fd into the memory area pointed to by dirp. The parameter count is the size of the memory area.

The dirent structure is declared as follows:

d_ino is an inode number. d_off is the distance from the start of the directory to the start of the next dirent. d_reclen is the size of this entire dirent. d_name is a null-terminated filename.

This call supersedes readdir(2).

返回值

On success, the number of bytes read is returned. On end of directory, 0 is returned. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

SVr4.

注意

Glibc does not provide a wrapper for this system call; call it using syscall(2).

另请参阅

• readdir (2)

getdomainname()函数

getdomainname, setdomainname -获取/设置域名

内容简介

#include <unistd.h>

int getdomainname(char *
name
, size_t 
len
);
 
int setdomainname(const char *
name
, size_t 
len
);

描述

These functions are used to access or to change the domain name of the current processor. If the null-terminated domain name requires more than len bytes,getdomainname() returns the first len bytes (glibc) or returns an error (libc).

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

POSIX does not specify these calls.

另请参阅

• gethostname (2)
• sethostname (2)
• uname (2)

getdtablesize()函数

getdtablesize - 获取描述符表的大小

内容简介

#include <unistd.h>

int getdtablesize(void);

描述

getdtablesize() 返回文件的最大数量进程可以打开的，比一个文件描述符的最大可能值多一个。

返回值

当前限制在每个进程打开的文件数。

注意

getdtablesize() is implemented as a libc library function. The glibc version callsgetrlimit(2) and returns the current RLIMIT_NOFILE limit, or OPEN_MAX when that fails. The libc4 and libc5 versions return OPEN_MAX (set to 256 since Linux 0.98.4).

遵循于

SVr4, 4.4BSD (the getdtablesize() function first appeared in 4.2BSD).

另请参阅

• close (2)
• dup (2)
• getrlimit (2)
• open (2)

getgid()函数

getgid, getegid - 获得组标识

内容简介

#include <unistd.h>
 

#include <sys/types.h>

gid_t getgid(void);
 
gid_t getegid(void);

描述

getgid() 返回当前进程的实际组ID。

getegid() 返回当前进程的有效组ID。

错误

这些函数总是成功的。

遵循于

POSIX.1-2001, 4.3BSD

另请参阅

• setgid (2)
• setregid (2)

getuid()函数

getuid, geteuid - 获取用户标识

内容简介

#include <unistd.h>
 

#include <sys/types.h>

uid_t getuid(void);
 
uid_t geteuid(void);

描述

getuid() 返回当前进程的真实用户ID。

geteuid() 返回当前进程的有效用户ID。

错误

这些函数总是成功的。

遵循于

POSIX.1-2001, 4.3BSD.

历史

In Unix V6 the getuid() call returned (euid << 8) + uid. Unix V7 introduced separate callsgetuid() and geteuid().

另请参阅

• setreuid (2)
• setuid (2)

getgroups()函数

getgroups, setgroups - 补充组的get/set ID列表

内容简介

#include <sys/types.h>
 

#include <unistd.h>

int getgroups(int 
size
, gid_t 
list
[]);

#include <grp.h>

int setgroups(size_t 
size
, const gid_t *
list
);

描述

返回值

错误

注意

A process can have up to at least NGROUPS_MAX supplementary group IDs in addition to the effective group ID. The set of supplementary group IDs is inherited from the parent process and may be changed using setgroups(). The maximum number of supplementary group IDs can be found using sysconf(3):

The maximal return value of getgroups() cannot be larger than one more than the value obtained this way.

The prototype for setgroups() is only available if _BSD_SOURCE is defined.

遵循于

SVr4, 4.3BSD. The getgroups() function is in POSIX.1-2001. Since setgroups() requires privilege, it is not covered by POSIX.1-2001.

另请参阅

• getgid (2)
• setgid (2)

getgroups()函数

gethostid, sethostid - 获取或设置当前主机的唯一标识

内容简介

#include <unistd.h>


long gethostid(void);
 
int sethostid(long 
hostid
);

描述

Get or set a unique 32-bit identifier for the current machine. The 32-bit identifier is intended to be unique among all UNIX systems in existence. This normally resembles the Internet address for the local machine, as returned by gethostbyname(3), and thus usually never needs to be set.

The sethostid() call is restricted to the superuser.

The hostid argument is stored in the file /etc/hostid.

返回值

gethostid() returns the 32-bit identifier for the current host as set by sethostid(2).

遵循于

4.2BSD; these functions were dropped in 4.4BSD. SVr4 includes gethostid() but notsethostid(). POSIX.1-2001 specifies gethostid() but not sethostid().

文件

/etc/hostid

示例

id = gethostid ();
/* This is a no-op unless unsigned int is wider than 32 bits. */ id &= 0xffffffff;

另请参阅

• hostid (1)

gethostname()函数

gethostname, sethostname - 获取/设置主机名

内容简介

#include <unistd.h>

int gethostname(char *
name
, size_t 
len
);
 
int sethostname(const char *
name
, size_t 
len
);

描述

These system calls are used to access or to change the host name of the current processor. The gethostname() system call returns a null-terminated hostname (set earlier by sethostname()) in the array name that has a length of len bytes. In case the null-terminated hostname does not fit, no error is returned, but the hostname is truncated. It is unspecified whether the truncated hostname will be null-terminated.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

遵循于

SVr4, 4.4BSD (this interfaces first appeared in 4.2BSD). POSIX.1-2001 specifiesgethostname() but not sethostname().

注意

SUSv2 guarantees that ‘Host names are limited to 255 bytes’. POSIX.1-2001 guarantees that ‘Host names (not including the terminating null byte) are limited to HOST_NAME_MAX bytes’.

glibc注意事项

The GNU C library implements gethostname() as a library function that calls uname(2) and copies up to len bytes from the returned nodename field into name. Having performed the copy, the function then checks if the length of the nodename was greater than or equal to len, and if it is, then the function returns -1 with errno set toENAMETOOLONG. Versions of glibc before 2.2 handle the case where the length of thenodename was greater than or equal to len differently: nothing is copied into name and the function returns -1 with errno set to ENAMETOOLONG.

另请参阅

• getdomainname (2)
• setdomainname (2)
• uname (2)

getitimer()函数

getitimer, setitimer - 获取或设置一个间隔定时器的值

内容简介

描述

该系统为每个进程有三个间隔定时器，在不同的时间域的每个递减。当任何定时器到期时，一信号被发送到处理，定时器（可能）重新启动。

计时器的值由以下结构定义：

struct itimerval {
struct timeval it_interval; /* next value */
struct timeval it_value; /* current value */
};
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};

The function getitimer() fills the structure indicated by value with the current setting for the timer indicated by which (one of ITIMER_REAL, ITIMER_VIRTUAL, orITIMER_PROF). The element it_value is set to the amount of time remaining on the timer, or zero if the timer is disabled. Similarly, it_interval is set to the reset value. The function setitimer() sets the indicated timer to the value in value. If ovalue is non-zero, the old value of the timer is stored there.

Timers decrement from it_value to zero, generate a signal, and reset to it_interval. A timer which is set to zero (it_value is zero or the timer expires and it_interval is zero) stops.

Both tv_sec and tv_usec are significant in determining the duration of a timer.

Timers will never expire before the requested time, but may expire some (short) time afterwards, which depends on the system timer resolution and on the system load. (But see BUGS below.) Upon expiration, a signal will be generated and the timer reset. If the timer expires while the process is active (always true for ITIMER_VIRTUAL) the signal will be delivered immediately when generated. Otherwise the delivery will be offset by a small time dependent on the system loading.

返回值

On success, zero is returned. On error, -1 is returned, and errno is set appropriately.

错误

注意

A child created via fork(2) does not inherit its parent’s interval timers. Interval timers are preserved across an execve(2).

遵循于

POSIX.1-2001, SVr4, 4.4BSD (this call first appeared in 4.2BSD).

另请参阅

• gettimeofday (2)
• sigaction (2)
• signal (2)

The generation and delivery of a signal are distinct, and only one instance of each of the signals listed above may be pending for a process. Under very heavy loading, an ITIMER_REAL timer may expire before the signal from a previous expiration has been delivered. The second signal in such an event will be lost.

On Linux, timer values are represented in jiffies. If a request is made set a timer with a value whose jiffies representation exceeds MAX_SEC_IN_JIFFIES (defined ininclude/linux/jiffies.h), then the timer is silently truncated to this ceiling value. On Linux/x86 (where, since kernel 2.6.13, the default jiffy is 0.004 seconds), this means that the ceiling value for a timer is approximately 99.42 days.

On certain systems (including x86), Linux kernels before version 2.6.12 have a bug which will produce premature timer expirations of up to one jiffy under some circumstances. This bug is fixed in kernel 2.6.12.

POSIX.1-2001 says that setitimer() should fail if a tv_usec value is specified that is outside of the range 0 to 999999. However, Linux does not give an error, but instead silently adjusts the corresponding seconds value for the timer. In the future (scheduled for March 2007), this non-conformance will be repaired: existing applications should be fixed now to ensure that they supply a properly formed tv_usec value.

get_kernel_syms()函数

get_kernel_syms -检索导出的内核和模块的符号

内容简介

描述

如果 table 为 NULL, get_kernel_syms() 返回可用于查询符号的数目。否则填充结构的一个表：

The symbols are interspersed with magic symbols of the form #module-name with the kernel having an empty name. The value associated with a symbol of this form is the address at which the module is loaded.

The symbols exported from each module follow their magic module tag and the modules are returned in the reverse of the order in which they were loaded.

返回值

Returns the number of symbols copied to table. There is no possible error return.

遵循于

get_kernel_syms() is Linux specific.

BUGS

There is no way to indicate the size of the buffer allocated for table. If symbols have been added to the kernel since the program queried for the symbol table size, memory will be corrupted.

The length of exported symbol names is limited to 59 characters.

Because of these limitations, this system call is deprecated in favor of query_module(2) (which is itself nowadays deprecated in favor of other interfaces described on its manual page).

注意

This system call is only present on Linux up until kernel 2.4; it was removed in Linux 2.6.