Системные вызовы ос linux для работы со временем

Timers and time management in the Linux kernel. Part 7.

Time related system calls in the Linux kernel

This is the seventh and last part chapter, which describes timers and time management related stuff in the Linux kernel. In the previous part, we discussed timers in the context of x86_64: High Precision Event Timer and Time Stamp Counter. Internal time management is an interesting part of the Linux kernel, but of course not only the kernel needs the time concept. Our programs also need to know time. In this part, we will consider implementation of some time management related system calls. These system calls are:

• clock_gettime;
• gettimeofday;
• nanosleep.

We will start from a simple userspace C program and see all way from the call of the standard library function to the implementation of certain system calls. As each architecture provides its own implementation of certain system calls, we will consider only x86_64 specific implementations of system calls, as this book is related to this architecture.

Additionally, we will not consider the concept of system calls in this part, but only implementations of these three system calls in the Linux kernel. If you are interested in what is a system call, there is a special chapter about this.

So, let’s start from the gettimeofday system call.

Implementation of the gettimeofday system call

As we can understand from the name gettimeofday, this function returns the current time. First of all, let’s look at the following simple example:

#include <time.h>
#include <sys/time.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    char buffer[40];
    struct timeval time;
        
    gettimeofday(&time, NULL);

    strftime(buffer, 40, "Current date/time: %m-%d-%Y/%T", localtime(&time.tv_sec));
    printf("%sn",buffer);

    return 0;
}

As you can see, here we call the gettimeofday function, which takes two parameters. The first parameter is a pointer to the timeval structure, which represents an elapsed time:

struct timeval {
    time_t      tv_sec;     /* seconds */
    suseconds_t tv_usec;    /* microseconds */
};

The second parameter of the gettimeofday function is a pointer to the timezone structure which represents a timezone. In our example, we pass address of the timeval time to the gettimeofday function, the Linux kernel fills the given timeval structure and returns it back to us. Additionally, we format the time with the strftime function to get something more human readable than elapsed microseconds. Let’s see the result:

~$ gcc date.c -o date
~$ ./date
Current date/time: 03-26-2016/16:42:02

As you may already know, a userspace application does not call a system call directly from the kernel space. Before the actual system call entry will be called, we call a function from the standard library. In my case it is glibc, so I will consider this case. The implementation of the gettimeofday function is located in the sysdeps/unix/sysv/linux/x86/gettimeofday.c source code file. As you already may know, the gettimeofday is not a usual system call. It is located in the special area which is called vDSO (you can read more about it in the part, which describes this concept).

The glibc implementation of gettimeofday tries to resolve the given symbol; in our case this symbol is __vdso_gettimeofday by the call of the _dl_vdso_vsym internal function. If the symbol cannot be resolved, it returns NULL and we fallback to the call of the usual system call:

return (_dl_vdso_vsym ("__vdso_gettimeofday", &linux26)
  ?: (void*) (&__gettimeofday_syscall));

The gettimeofday entry is located in the arch/x86/entry/vdso/vclock_gettime.c source code file. As we can see the gettimeofday is a weak alias of the __vdso_gettimeofday:

int gettimeofday(struct timeval *, struct timezone *)
	__attribute__((weak, alias("__vdso_gettimeofday")));

The __vdso_gettimeofday is defined in the same source code file and calls the do_realtime function if the given timeval is not null:

notrace int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
{
	if (likely(tv != NULL)) {
		if (unlikely(do_realtime((struct timespec *)tv) == VCLOCK_NONE))
			return vdso_fallback_gtod(tv, tz);
		tv->tv_usec /= 1000;
	}
	if (unlikely(tz != NULL)) {
		tz->tz_minuteswest = gtod->tz_minuteswest;
		tz->tz_dsttime = gtod->tz_dsttime;
	}

	return 0;
}

If the do_realtime will fail, we fallback to the real system call via call the syscall instruction and passing the __NR_gettimeofday system call number and the given timeval and timezone:

notrace static long vdso_fallback_gtod(struct timeval *tv, struct timezone *tz)
{
	long ret;

	asm("syscall" : "=a" (ret) :
	    "0" (__NR_gettimeofday), "D" (tv), "S" (tz) : "memory");
	return ret;
}

The do_realtime function gets the time data from the vsyscall_gtod_data structure which is defined in the arch/x86/include/asm/vgtod.h header file and contains mapping of the timespec structure and a couple of fields which are related to the current clock source in the system. This function fills the given timeval structure with values from the vsyscall_gtod_data which contains a time related data which is updated via timer interrupt.

First of all we try to access the gtod or global time of day the vsyscall_gtod_data structure via the call of the gtod_read_begin and will continue to do it until it will be successful:

do {
	seq = gtod_read_begin(gtod);
	mode = gtod->vclock_mode;
	ts->tv_sec = gtod->wall_time_sec;
	ns = gtod->wall_time_snsec;
	ns += vgetsns(&mode);
	ns >>= gtod->shift;
} while (unlikely(gtod_read_retry(gtod, seq)));

ts->tv_sec += __iter_div_u64_rem(ns, NSEC_PER_SEC, &ns);
ts->tv_nsec = ns;

As we got access to the gtod, we fill the ts->tv_sec with the gtod->wall_time_sec which stores current time in seconds gotten from the real time clock during initialization of the timekeeping subsystem in the Linux kernel and the same value but in nanoseconds. In the end of this code we just fill the given timespec structure with the resulted values.

That’s all about the gettimeofday system call. The next system call in our list is the clock_gettime.

Implementation of the clock_gettime system call

The clock_gettime function gets the time which is specified by the second parameter. Generally the clock_gettime function takes two parameters:

• clk_id — clock identifier;
• timespec — address of the timespec structure which represent elapsed time.

Let’s look on the following simple example:

#include <time.h>
#include <sys/time.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    struct timespec elapsed_from_boot;

    clock_gettime(CLOCK_BOOTTIME, &elapsed_from_boot);

    printf("%d - seconds elapsed from bootn", elapsed_from_boot.tv_sec);
    
    return 0;
}

which prints uptime information:

~$ gcc uptime.c -o uptime
~$ ./uptime
14180 - seconds elapsed from boot

We can easily check the result with the help of the uptime util:

The elapsed_from_boot.tv_sec represents elapsed time in seconds, so:

>>> 14180 / 60
236
>>> 14180 / 60 / 60
3
>>> 14180 / 60 % 60
56

The clock_id maybe one of the following:

• CLOCK_REALTIME — system wide clock which measures real or wall-clock time;
• CLOCK_REALTIME_COARSE — faster version of the CLOCK_REALTIME;
• CLOCK_MONOTONIC — represents monotonic time since some unspecified starting point;
• CLOCK_MONOTONIC_COARSE — faster version of the CLOCK_MONOTONIC;
• CLOCK_MONOTONIC_RAW — the same as the CLOCK_MONOTONIC but provides non NTP adjusted time.
• CLOCK_BOOTTIME — the same as the CLOCK_MONOTONIC but plus time that the system was suspended;
• CLOCK_PROCESS_CPUTIME_ID — per-process time consumed by all threads in the process;
• CLOCK_THREAD_CPUTIME_ID — thread-specific clock.

The clock_gettime is not usual syscall too, but as the gettimeofday, this system call is placed in the vDSO area. Entry of this system call is located in the same source code file — arch/x86/entry/vdso/vclock_gettime.c) as for gettimeofday.

The Implementation of the clock_gettime depends on the clock id. If we have passed the CLOCK_REALTIME clock id, the do_realtime function will be called:

notrace int __vdso_clock_gettime(clockid_t clock, struct timespec *ts)
{
	switch (clock) {
	case CLOCK_REALTIME:
		if (do_realtime(ts) == VCLOCK_NONE)
			goto fallback;
		break;
    ...
    ...
    ...
fallback:
	return vdso_fallback_gettime(clock, ts);
}

In other cases, the do_{name_of_clock_id} function is called. Implementations of some of them is similar. For example if we will pass the CLOCK_MONOTONIC clock id:

...
...
...
case CLOCK_MONOTONIC:
	if (do_monotonic(ts) == VCLOCK_NONE)
		goto fallback;
	break;
...
...
...

the do_monotonic function will be called which is very similar on the implementation of the do_realtime:

notrace static int __always_inline do_monotonic(struct timespec *ts)
{
	do {
		seq = gtod_read_begin(gtod);
		mode = gtod->vclock_mode;
		ts->tv_sec = gtod->monotonic_time_sec;
		ns = gtod->monotonic_time_snsec;
		ns += vgetsns(&mode);
		ns >>= gtod->shift;
	} while (unlikely(gtod_read_retry(gtod, seq)));

	ts->tv_sec += __iter_div_u64_rem(ns, NSEC_PER_SEC, &ns);
	ts->tv_nsec = ns;

	return mode;
}

We already saw a little about the implementation of this function in the previous paragraph about the gettimeofday. There is only one difference here, that the sec and nsec of our timespec value will be based on the gtod->monotonic_time_sec instead of gtod->wall_time_sec which maps the value of the tk->tkr_mono.xtime_nsec or number of nanoseconds elapsed.

That’s all.

Implementation of the nanosleep system call

The last system call in our list is the nanosleep. As you can understand from its name, this function provides sleeping ability. Let’s look on the following simple example:

#include <time.h>
#include <stdlib.h>
#include <stdio.h>

int main (void)
{    
   struct timespec ts = {5,0};

   printf("sleep five secondsn");
   nanosleep(&ts, NULL);
   printf("end of sleepn");

   return 0;
}

If we will compile and run it, we will see the first line

~$ gcc sleep_test.c -o sleep
~$ ./sleep
sleep five seconds
end of sleep

and the second line after five seconds.

The nanosleep is not located in the vDSO area like the gettimeofday and the clock_gettime functions. So, let’s look how the real system call which is located in the kernel space will be called by the standard library. The implementation of the nanosleep system call will be called with the help of the syscall instruction. Before the execution of the syscall instruction, parameters of the system call must be put in processor registers according to order which is described in the System V Application Binary Interface or in other words:

• rdi — first parameter;
• rsi — second parameter;
• rdx — third parameter;
• r10 — fourth parameter;
• r8 — fifth parameter;
• r9 — sixth parameter.

The nanosleep system call has two parameters — two pointers to the timespec structures. The system call suspends the calling thread until the given timeout has elapsed. Additionally it will finish if a signal interrupts its execution. It takes two parameters, the first is timespec which represents timeout for the sleep. The second parameter is the pointer to the timespec structure too and it contains remainder of time if the call of the nanosleep was interrupted.

As nanosleep has two parameters:

int nanosleep(const struct timespec *req, struct timespec *rem);

To call system call, we need put the req to the rdi register, and the rem parameter to the rsi register. The glibc does these job in the INTERNAL_SYSCALL macro which is located in the sysdeps/unix/sysv/linux/x86_64/sysdep.h header file.

# define INTERNAL_SYSCALL(name, err, nr, args...) 
  INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, ##args)

which takes the name of the system call, storage for possible error during execution of system call, number of the system call (all x86_64 system calls you can find in the system calls table) and arguments of certain system call. The INTERNAL_SYSCALL macro just expands to the call of the INTERNAL_SYSCALL_NCS macro, which prepares arguments of system call (puts them into the processor registers in correct order), executes syscall instruction and returns the result:

# define INTERNAL_SYSCALL_NCS(name, err, nr, args...)      
  ({									                                      
    unsigned long int resultvar;					                          
    LOAD_ARGS_##nr (args)						                              
    LOAD_REGS_##nr							                                  
    asm volatile (							                                  
    "syscallnt"							                                  
    : "=a" (resultvar)							                              
    : "0" (name) ASM_ARGS_##nr : "memory", REGISTERS_CLOBBERED_BY_SYSCALL);   
    (long int) resultvar; })

The LOAD_ARGS_##nr macro calls the LOAD_ARGS_N macro where the N is number of arguments of the system call. In our case, it will be the LOAD_ARGS_2 macro. Ultimately all of these macros will be expanded to the following:

# define LOAD_REGS_TYPES_1(t1, a1)					   
  register t1 _a1 asm ("rdi") = __arg1;					   
  LOAD_REGS_0

# define LOAD_REGS_TYPES_2(t1, a1, t2, a2)				   
  register t2 _a2 asm ("rsi") = __arg2;					   
  LOAD_REGS_TYPES_1(t1, a1)
...
...
...

After the syscall instruction will be executed, the context switch will occur and the kernel will transfer execution to the system call handler. The system call handler for the nanosleep system call is located in the kernel/time/hrtimer.c source code file and defined with the SYSCALL_DEFINE2 macro helper:

SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,
		struct timespec __user *, rmtp)
{
	struct timespec tu;

	if (copy_from_user(&tu, rqtp, sizeof(tu)))
		return -EFAULT;

	if (!timespec_valid(&tu))
		return -EINVAL;

	return hrtimer_nanosleep(&tu, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
}

More about the SYSCALL_DEFINE2 macro you may read in the chapter about system calls. If we look at the implementation of the nanosleep system call, first of all we will see that it starts from the call of the copy_from_user function. This function copies the given data from the userspace to kernelspace. In our case we copy timeout value to sleep to the kernelspace timespec structure and check that the given timespec is valid by the call of the timesc_valid function:

static inline bool timespec_valid(const struct timespec *ts)
{
	if (ts->tv_sec < 0)
		return false;
	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
		return false;
	return true;
}

which just checks that the given timespec does not represent date before 1970 and nanoseconds does not overflow 1 second. The nanosleep function ends with the call of the hrtimer_nanosleep function from the same source code file. The hrtimer_nanosleep function creates a timer and calls the do_nanosleep function. The do_nanosleep does main job for us. This function provides loop:

do {
	set_current_state(TASK_INTERRUPTIBLE);
	hrtimer_start_expires(&t->timer, mode);

	if (likely(t->task))
		freezable_schedule();
    
} while (t->task && !signal_pending(current));

__set_current_state(TASK_RUNNING);
return t->task == NULL;

Which freezes current task during sleep. After we set TASK_INTERRUPTIBLE flag for the current task, the hrtimer_start_expires function starts the give high-resolution timer on the current processor. As the given high resolution timer will expire, the task will be again running.

That’s all.

Conclusion

This is the end of the seventh part of the chapter that describes timers and timer management related stuff in the Linux kernel. In the previous part we saw x86_64 specific clock sources. As I wrote in the beginning, this part is the last part of this chapter. We saw important time management related concepts like clocksource and clockevents frameworks, jiffies counter and etc., in this chpater. Of course this does not cover all of the time management in the Linux kernel. Many parts of this mostly related to the scheduling which we will see in other chapter.

If you have questions or suggestions, feel free to ping me in twitter 0xAX, drop me email or just create issue.

Please note that English is not my first language and I am really sorry for any inconvenience. If you found any mistakes please send me PR to linux-insides.

Links

• system call
• C programming language
• standard library
• glibc
• real time clock
• NTP
• nanoseconds
• register
• System V Application Binary Interface
• context switch
• Introduction to timers in the Linux kernel
• uptime
• system calls table for x86_64
• High Precision Event Timer
• Time Stamp Counter
• x86_64
• previous part

Знание системных вызовов очень облегчает работу программистов (для написаний программ на языке программирования С) и системным администратором при дебаге какой-либо программы, с помощью таких инструментов, как: strace/gdb и пр. Вот небольшое описание системных вызовов Linux.

1. exit Завершение процесса
2. fork Создание дочернего процесса
3. read чтение из файлового дескриптора
4. write Запись в файловый дескриптора
5. open открытие файла или устройства
6. close закрытие файлового дескриптора
7. waitpid ожидание завершения процесса
8. creat создание файла или устройства (man 2 open)
9. link задание нового имени файла
10. unlink удаление имени и файла
11. execve выполнить программу
12. chdir изменить рабочую директорию
13. time получить время в секундах
14. mknod создание специального блочного или символьного файла
15. chmod изменение прав доступа к файлу
16. lchown изменение владельца файла
17. stat получения статус файла
18. lseek установка смещения для позиционирования операций чтения/записи
19. getpid получение идентификатора процесса
20. mount монтирование файловой системы
21. umount размонтирование файловой системы
22. setuid установить идентификатор пользователя
23. getuid получить идентификатор пользователя
24. stime установить системное время и дату
25. ptrace разрешить родительскому процессу контролировать выполнеине дочернего процесса
26. alarm установка времени доставки тревожного сигнала
27. fstat получить статус файла
28. pause останавливает процесс до получения сигнала
29. utime изменить время доступа и/или модификация inode
30. access проверить права доступа пользователя к файлу
31. nice изменить приоритет процесса
32. sync сброс буферов файловой системы
33. kill отправить сигнал процессу
34. rename изменить имя или расположение файла
35. mkdir создать директорию
36. rmdir удалить директорию
37. dup создать дубликат файлового дескриптора
38. pipe создает межпроцессорный канал
39. times ведет запись времен процесса
40. brk изменение размера сегмента данныхх
41. setdig установить идентификатор группы
42. getgid получить идентификатор группы
43. sys_signal ANSI C обработка сигналов
44. geteuid получить эффективный идентификатор пользователя, установленный setuid битом на исполняемом файле
45. getegid получить эффективный идентификатор группы, установленные setuid битом на исполняемом файле
46. acct включает или выключает учет процессов
47. umount2 размонтировать файловую систему
48. ioctl управление устройствами
49. fcntl манипуляция с файловым дескриптором
50. setpgid установить идентификатор группы дял процесса
51. umask получение или установка маски режима создания файлов
52. chroot изменение корневой директории
53. ustat получить статистику по файловой системе
54. dup2 создать дубликат файлового дескриптора
55. getppid получить ID родительского процесса
56. getpgrp получить ID группы процесса
57. setsid создает сеанс и устанвливает идентификатор группы
58. sigaction POSIX обработка сигналов
59. sgetmask ANSI C обработка сигналов
60. ssetmask ANCI C обработки сигналов
61. setreuid устанавливает действительный и/или действующий идентификатор пользователя
62. setregid устанавливает дейсвтительный и/или действующий идентификатор группы
63. sigsuspend временно изменяет значение маски блокировки сигналов процесса
64. sigpendind позволяет определить наличие ожидающих сигналов
65. sethostname устанавливает хостнейм
66. setrlimit устанавливает ограничения использования ресурсов
67. getrlimit получить ограничение использования ресурсов
68. getrusage получить максимальное ограничение использования ресурсов
69. gettimeofday получить время
70. settimeofday установить время
71. getgroups получить список дополнительных идентификаторов групп
72. setgroups установить список дополнительных идентификаторов групп
73. old_select синхронизировать I/O мультиплексирование
74. symlink создать символическую ссылку на файл
75. lstat считать статус файла
76. readlink вывести значение символической ссылки
77. uselib выбрать разделяемую библиотеку
78. swapon разрешает подкачку данных в файл/устройство
79. reboot перезагружает систему и разрешает/запрещает использование клавш Ctrl-Alt-Del
80. old_readdir считывает данные директории
81. old_mmap отражает файлы или устройства в памяти
82. munmap снимает отражение файлов или устройств в памяти
83. truncate укорачивает файл до заданной длины (файл должен быть доступен для записи)
84. ftruncate укорачивает файл до заданноой длины (файл должен быть открыт для записи)
85. fchmod изменить права доступа к файлу
86. fchown изменить владельца и группу файла
87. getpriority получить приоритет программы
88. setpriority установить приоритет программы
89. profil выполняет профилирование времени
90. statfs получить статистику файловой системы
91. fstatfs получить статистику файловой системы
92. ioperm устанавливает права на работу с портами ввода/вывода
93. socketcall системные вызовы сокетов
94. syslog читает и/или очищает кольцевой буфер сообщений ядра, устанавливает console_loglevel
95. setitimer устанавливает значение таймера интервалов (interval timer)
96. getitimer считывает значение таймера интервалов
97. sys_newstat получить статус файла
98. sys_newlstat получить статус файла
99. sys_newfstat получить статус файла
100. iopl менять уровень привелений ввода-вывода
101. vhangup имитирует прекращение работы на текущем терминале
102. idle делает процесс 0 простаиваемым
103. vm86old включить виртуальный 8086 режим
104. wait4 ожидает завершение работы процесса (стиль BSD)
105. swapoff запрещает подкачку данных в файл/устройство
106. sysinfo возвращает общесистемную статистику
107. ipc системные вызовы System V IPC
108. fsync синхронизирует состояние файла в памяти с состоянием на диске
109. sigreturn возвращается из обработчика сигнала и очищает временный стек
110. clone создать процесс-потомок
110. setdomainname установить имя домена
111. uname сообщает информацию о данном компьютере и операционной системе
112. modify_ldt получает или устанавливает ldt
113. adjtimex тонкая настройка часов в ядре
114. mprotect контролирует доступ к области памяти
115. sigprocmask POSIX-фукнция обработки сигналов
116. create_module создает загружаемый модуль
117. init_module инициализирует загружаемый модуль
118. delete_module удаляет загружаемый модуль
119. get_kernel_syms retrieve exported kernel and module symbols
120. quotactl работает с дисковыми квотами
121. getpgid получает группу процессов
122. fchdir изменить рабочий каталог
123. bdflush запустить, активизировать или настроить демона записи буферов кэша
124. sys_newfstat получает информацию о файловой системе
125. personality устанавливает домен исполнения процесса
126. setfsuid устанавливает идентификатор пользователя файловой системы
127. setfsgid устанавливает идентификатор группы для досутпа к файловой системе
128. sys_llseek move extended read/write file pointer
129. getdents получить записи каталога
130. select многопоточный синхронный ввод-вывод
131. flock установить или снять advisory Блокировку на открытый файл
132. msync синхронизирует содержимое файла с его отражением в памяти
133. readv чтение данных из нескольких буферов
134. writev запись данных в несколько буферов
135. sys_getsid get process group ID of session leader
136. fdatasync снихронизирует содержимое файла в памяти с содержимым на диске
137. sysctl читает/записывает параметры системы
138. mlock запрещает страинчный обмен в некоторых областях памяти
139. munlock разрашает страинчный обмен в некоторых областях памяти
140. mlockall запрещает страничный обмен всему процессу
141. munlockall разрашает страничный обмен всему процессу
142. sched_setparam устанавливает параметры планировщика
143. sched_getparam получает параметры планировщика
144. sched_setscheduler устанавливает алгоритм планировщика (и его параметры)
145. sched_getscheduler получает алгоритм планировщика (и его параметры)
146. sched_yield освободить процессор
147. sched_get_priority_max задать верхнюю планку диапазона статических приоритетов
148. sched_get_priority_min задать нижнию планку диапазона статических приоритетов
149. sched_rr_get_interval определяет временной интервал SCHED_RR для заданного процесса
150. nanosleep останавливает работу процесса на заданное время (нано секунды)
151. mremap изменяет отражение адреса виртуальной памяти
152. setresuid устанавливает идентификатор реальной, эффективной и сохранненной групп пользователей
153. getresuid получает идентификатор реальной, эффективной и сохранненной групп пользователей
154. vm86 войти в виртуальный режим 8086
155. query_module query the kernel for various bits pertain ing to modules
156. poll ожидает некоторое событие в файловом описателе
157. nfsservctl интерфейсная функция системного демона nfs
158. setresgid устанавливает идентификатор реальной, эффективной и сохранненной групп пользователей
159. getresgid получает идентификатор реальной, эффективной и сохранненной групп пользователей
160. prctl оперирует процессами
161. pread чтение информации из опистаеля файла согласно заданному смещению
162. pwrite запись информации из описателя файла согласно заданному смещению
163. chown изменяет владельца и группу файлов
164. getcwd возвращает текущий рабочий каталог
165. capget получить возможности процесса
166. capset установить возможности процесса
167. sigaltstack считывает или устанавливает содержимое дополнительного стека сигнала
168. sendfile производит обмен данными между описателями файлов
169. vfork создает дочерний процесс и блокирует родительский

Open source, Разработка под Linux, Настройка Linux, Блог компании OTUS. Онлайн-образование

---

Рекомендация: подборка платных и бесплатных курсов PR-менеджеров — https://katalog-kursov.ru/

---

Системный вызов — это механизм взаимодействия пользовательских программ с ядром Linux, а strace — мощный инструмент, для их отслеживания. Для лучшего понимания работы операционной системы полезно разобраться с тем, как они работают.

В операционной системе можно выделить два режима работы:

• Режим ядра (kernel mode) — привилегированный режим, используемый ядром операционной системы.
• Пользовательский режим (user mode) — режим, в котором выполняется большинство пользовательских приложений.

Пользователи при повседневной работе обычно используют утилиты командной строки и графический интерфейс (GUI). При этом в фоне незаметно работают системные вызовы, обращаясь к ядру для выполнения работы.

Системные вызовы очень похожи на вызовы функций, в том смысле, что в них передаются аргументы и они возвращают значения. Единственное отличие состоит в том, что системные вызовы работают на уровне ядра, а функции нет. Переключение из пользовательского режима в режим ядра осуществляется с помощью специального механизма прерываний.

Большая часть этих деталей скрыта от пользователя в системных библиотеках (glibc в Linux-системах). Системные вызовы по своей природе являются универсальными, но несмотря на это, механика их выполнения во многом аппаратно-зависима.

В этой статье рассматривается несколько практических примеров анализа системных вызовов с помощью strace. В примерах используется Red Hat Enterprise Linux, но все команды должны работать и в других дистрибутивах Linux:

[root@sandbox ~]# cat /etc/redhat-release
Red Hat Enterprise Linux Server release 7.7 (Maipo)
[root@sandbox ~]#
[root@sandbox ~]# uname -r
3.10.0-1062.el7.x86_64
[root@sandbox ~]#

Для начала убедитесь, что в вашей системе установлены необходимые инструменты. Проверить установлен ли strace можно с помощью приведенной ниже команды. Для просмотра версии strace запустите ее с параметром -V:

[root@sandbox ~]# rpm -qa | grep -i strace
strace-4.12-9.el7.x86_64
[root@sandbox ~]#
[root@sandbox ~]# strace -V
strace -- version 4.12
[root@sandbox ~]#

Если strace не установлен, то установите запустив:

yum install strace

Для примера создайте тестовый каталог в /tmp и два файла с помощью команды touch:

[root@sandbox ~]# cd /tmp/
[root@sandbox tmp]#
[root@sandbox tmp]# mkdir testdir
[root@sandbox tmp]#
[root@sandbox tmp]# touch testdir/file1
[root@sandbox tmp]# touch testdir/file2
[root@sandbox tmp]#

(Я использую каталог /tmp только потому, что доступ к нему есть у всех, но вы можете использовать любой другой.)

С помощью команды ls проверьте, что в каталоге testdir создались файлы:

[root@sandbox tmp]# ls testdir/
file1  file2
[root@sandbox tmp]#

Вероятно, вы используете команду ls каждый день, не осознавая того, что под капотом работают системные вызовы. Здесь в игру вступает абстракция. Вот как работает эта команда:

Утилита командной строки -> Функции системных библиотек (glibc) -> Системные вызовы

Команда ls вызывает функции из системных библиотек Linux (glibc). Эти библиотеки, в свою очередь, вызывают системные вызовы, которые выполняют большую часть работы.

Если вы хотите узнать, какие функции вызывались из библиотеки glibc, то используйте команду ltrace со следующей за ней командой ls testdir/:

ltrace ls testdir/

Если ltrace не установлен, то установите:

yum install ltrace

На экране будет много информации, но не беспокойтесь — мы это рассмотрим далее. Вот некоторые из важных библиотечных функций из вывода ltrace:

opendir("testdir/")                                  = { 3 }
readdir({ 3 })                                       = { 101879119, "." }
readdir({ 3 })                                       = { 134, ".." }
readdir({ 3 })                                       = { 101879120, "file1" }
strlen("file1")                                      = 5
memcpy(0x1665be0, "file1", 6)                      = 0x1665be0
readdir({ 3 })                                       = { 101879122, "file2" }
strlen("file2")                                      = 5
memcpy(0x166dcb0, "file2", 6)                      = 0x166dcb0
readdir({ 3 })                                       = nil
closedir({ 3 })    

Изучив этот вывод, вы, вероятно, поймете, что происходит. Каталог с именем testdir открывается с помощью библиотечной функции opendir, после чего следуют вызовы функций readdir, читающих содержимое каталога. В конце происходит вызов функции closedir, которая закрывает каталог, открытый ранее. Пока проигнорируйте остальные функции, такие как strlen и memcpy.

Как вы видите, можно легко посмотреть вызываемые библиотечные функции, но в этой статье мы сфокусируемся на системных вызовах, которые вызываются функциями системных библиотек.

Для просмотра системных вызовов используйте strace с командой ls testdir, как показано ниже. И вы снова получите кучу бессвязной информации:

[root@sandbox tmp]# strace ls testdir/
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
brk(NULL)                               = 0x1f12000
<<< truncated strace output >>>
write(1, "file1  file2n", 13file1  file2
)          = 13
close(1)                                = 0
munmap(0x7fd002c8d000, 4096)            = 0
close(2)                                = 0
exit_group(0)                           = ?
+++ exited with 0 +++
[root@sandbox tmp]#

В результате выполнения strace вы получите список системных вызовов, выполненных при работе команды ls. Все системные вызовы можно разделить на следующие категории:

• Управление процессами
• Управление файлами
• Управление каталогами и файловой системой
• Прочие

Есть удобный способ анализа полученной информации — записать вывод в файл с помощью опции -o.

[root@sandbox tmp]# strace -o trace.log ls testdir/
file1  file2
[root@sandbox tmp]#

На этот раз на экране не будет никаких данных — команда ls отработает, как и ожидается, показав список файлов и записав весь вывод strace в файл trace.log. Для простой команды ls файл содержит почти 100 строк:

[root@sandbox tmp]# ls -l trace.log
-rw-r--r--. 1 root root 7809 Oct 12 13:52 trace.log
[root@sandbox tmp]#
[root@sandbox tmp]# wc -l trace.log
114 trace.log
[root@sandbox tmp]#

Взгляните на первую строку в файле trace.log:

execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0

• В начале строки находится имя выполняемого системного вызова — это execve.
• Текст в круглых скобках — это аргументы, передаваемые системному вызову.
• Число после знака = (в данном случае 0) — это значение, возвращаемое системным вызовом.

Теперь результат не кажется слишком пугающим, не так ли? И вы можете применить ту же логику и для других строк.

Обратите внимание на ту единственную команду, которую вы вызвали — ls testdir. Вам известно имя каталога, используемое командой ls, так почему бы не воспользоваться grep для testdir в файле trace.log и не посмотреть, что найдется? Посмотрите внимательно на результат:

[root@sandbox tmp]# grep testdir trace.log
execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
stat("testdir/", {st_mode=S_IFDIR|0755, st_size=32, ...}) = 0
openat(AT_FDCWD, "testdir/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3
[root@sandbox tmp]#

Возвращаясь к приведенному выше анализу execve, можете ли вы сказать, что делает следующий системный вызов?

execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0

Не нужно запоминать все системные вызовы и то, что они делают: все есть в документации. Man-страницы спешат на помощь! Перед запуском команды man убедитесь, что установлен пакет man-pages:

[root@sandbox tmp]# rpm -qa | grep -i man-pages
man-pages-3.53-5.el7.noarch
[root@sandbox tmp]#

Помните, что вам нужно добавить «2» между командой man и именем системного вызова. Если вы прочитаете в man про man (man man), то увидите, что раздел 2 зарезервирован для системных вызовов. Аналогично если вам нужна информация о библиотечных функциях, то нужно добавить 3 между man и именем библиотечной функции.

Ниже приведены номера разделов man:

1. Выполняемые программы или команды для командной оболочки.
2. Системные вызовы (функции, предоставляемые ядром).
3. Библиотечные вызовы (функции программных библиотек).
4. Специальные файлы (которые обычно находятся в /dev).

Для просмотра документации по системному вызову запустите man с именем этого системного вызова.

man 2 execve

В соответствии с документацией системный вызов execve выполняет программу, которая передается ему в параметрах (в данном случае это ls). В него также передаются дополнительные параметры для ls. В этом примере это testdir. Следовательно, этот системный вызов просто запускает ls с testdir в качестве параметра:

'execve - execute program'

'DESCRIPTION
       execve()  executes  the  program  pointed to by filename'

В следующий системный вызов stat передается параметр testdir:

stat("testdir/", {st_mode=S_IFDIR|0755, st_size=32, ...}) = 0

Для просмотра документации используйте man 2 stat. Системный вызов stat возвращает информацию об указанном файле. Помните, что все в Linux — файл, включая каталоги.

Далее системный вызов openat открывает testdir. Обратите внимание, что возвращается значение 3. Это дескриптор файла, который будет использоваться в последующих системных вызовах:

openat(AT_FDCWD, "testdir/", O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC) = 3

Теперь откройте файл

trace.log

и обратите внимание на строку, следующую после системного вызова openat. Вы увидите системный вызов getdents, который делает большую часть необходимой работы для выполнения команды ls testdir. Теперь выполним grep getdents для файла trace.log:

[root@sandbox tmp]# grep getdents trace.log
getdents(3, /* 4 entries */, 32768)     = 112
getdents(3, /* 0 entries */, 32768)     = 0
[root@sandbox tmp]#

В документации (man getdents) говорится, что getdents читает записи каталога, это, собственно, нам и нужно. Обратите внимание, что аргумент для getdent равен 3 — это дескриптор файла, полученный ранее от системного вызова openat.

Теперь, когда получено содержимое каталога, нужен способ отобразить информацию в терминале. Итак, делаем grep для другого системного вызова write, который используется для вывода на терминал:

[root@sandbox tmp]# grep write trace.log
write(1, "file1  file2n", 13)          = 13
[root@sandbox tmp]#

В аргументах вы можете видеть имена файлов, которые будут выводится: file1 и file2. Что касается первого аргумента (1), вспомните, что в Linux для любого процесса по умолчанию открываются три файловых дескриптора:

• 0 — стандартный поток ввода
• 1 — стандартный поток вывода
• 2 — стандартный поток ошибок

Таким образом, системный вызов write выводит file1 и file2 на стандартный вывод, которым является терминал, обозначаемый числом 1.

Теперь вы знаете, какие системные вызовы сделали большую часть работы для команды ls testdir/. Но что насчет других 100+ системных вызовов в файле trace.log?

Операционная система выполняет много вспомогательных действий для запуска процесса, поэтому многое из того, что вы видите в файле trace.log — это инициализация и очистка процесса. Посмотрите файл trace.log полностью и попытайтесь понять, что происходит во время запуска команды ls.

Теперь вы можете анализировать системные вызовы для любых программ. Утилита strace так же предоставляет множество полезных параметров командной строки, некоторые из которых описаны ниже.

По умолчанию strace отображает не всю информацию о системных вызовах. Однако у нее есть опция -v verbose, которая покажет дополнительную информацию о каждом системном вызове:

strace -v ls testdir

Хорошая практика использовать параметр -f для отслеживания дочерних процессов, созданных запущенным процессом:

strace -f ls testdir

А если вам нужны только имена системных вызовов, количество их запусков и процент времени, затраченного на выполнение? Вы можете использовать опцию -c, чтобы получить эту статистику:

strace -c ls testdir/

Если вы хотите отследить определенный системный вызов, например, open, и проигнорировать другие, то можно использовать опцию -e с именем системного вызова:

[root@sandbox tmp]# strace -e open ls testdir
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libcap.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libacl.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libpcre.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libattr.so.1", O_RDONLY|O_CLOEXEC) = 3
open("/lib64/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
open("/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
file1  file2
+++ exited with 0 +++
[root@sandbox tmp]#

А что, если нужно отфильтровать по нескольким системным вызовам? Не волнуйтесь, можно использовать ту же опцию -e и разделить необходимые системные вызовы запятой. Например, для write и getdent:

[root@sandbox tmp]# strace -e write,getdents ls testdir
getdents(3, /* 4 entries */, 32768)     = 112
getdents(3, /* 0 entries */, 32768)     = 0
write(1, "file1  file2n", 13file1  file2
)          = 13
+++ exited with 0 +++
[root@sandbox tmp]#

До сих пор мы отслеживали только явный запуск команд. Но как насчет команд, которые были запущены ранее? Что, если вы хотите отслеживать демонов? Для этого у strace есть специальная опция -p, которой вы можете передать идентификатор процесса.

Мы не будем запускать демона, а используем команду cat, которая отображает содержимое файла, переданного ему в качестве аргумента. Но если аргумент не указать, то команда cat будет просто ждать ввод от пользователя. После ввода текста она выведет введенный текст на экран. И так до тех пор, пока пользователь не нажмет Ctrl+C для выхода.

Запустите команду cat на одном терминале.

[root@sandbox tmp]# cat

На другом терминале найдите идентификатор процесса (PID) с помощью команды ps:

[root@sandbox ~]# ps -ef | grep cat
root      22443  20164  0 14:19 pts/0    00:00:00 cat
root      22482  20300  0 14:20 pts/1    00:00:00 grep --color=auto cat
[root@sandbox ~]#

Теперь запустите strace с опцией -p и PID’ом, который вы нашли с помощью ps. После запуска strace выведет информацию о процессе, к которому он подключился, а также его PID. Теперь strace отслеживает системные вызовы, выполняемые командой cat. Первый системный вызов, который вы увидите — это read, ожидающий ввода от потока с номером 0, то есть от стандартного ввода, который сейчас является терминалом, на котором запущена команда cat:

[root@sandbox ~]# strace -p 22443
strace: Process 22443 attached
read(0,

Теперь вернитесь к терминалу, где вы оставили запущенную команду cat, и введите какой-нибудь текст. Для демонстрации я ввел x0x0. Обратите внимание, что cat просто повторил то, что я ввел и x0x0 на экране будет дважды.

[root@sandbox tmp]# cat
x0x0
x0x0

Вернитесь к терминалу, где strace был подключен к процессу cat. Теперь вы видите два новых системных вызова: предыдущий read, который теперь прочитал x0x0, и еще один для записи write, который записывает x0x0 обратно в терминал, и снова новый read, который ожидает чтения с терминала. Обратите внимание, что стандартный ввод (0) и стандартный вывод (1) находятся на одном и том же терминале:

[root@sandbox ~]# strace -p 22443
strace: Process 22443 attached
read(0, "x0x0n", 65536)                = 5
write(1, "x0x0n", 5)                   = 5
read(0,

Представляете, какую пользу может принести вам запуск strace для демонов: вы можете увидеть все, что делается в фоне. Завершите команду

cat

, нажав

Ctrl+C

. Это также прекратит сеанс

strace

, так как отслеживаемый процесс был прекращен.

Для просмотра отметок времени системных вызовов используйте опцию -t:

[root@sandbox ~]#strace -t ls testdir/

14:24:47 execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
14:24:47 brk(NULL)                      = 0x1f07000
14:24:47 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f2530bc8000
14:24:47 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
14:24:47 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3

А если вы хотите узнать время, проведенное между системными вызовами? Есть удобная опция -r, которая показывает время, затраченное на выполнение каждого системного вызова. Довольно полезно, не так ли?

[root@sandbox ~]#strace -r ls testdir/

0.000000 execve("/usr/bin/ls", ["ls", "testdir/"], [/* 40 vars */]) = 0
0.000368 brk(NULL)                 = 0x1966000
0.000073 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fb6b1155000
0.000047 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
0.000119 open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3

Заключение

Утилита strace очень удобна для изучения системных вызовов в Linux. Чтобы узнать о других параметрах командной строки, обратитесь к man и онлайн-документации.

ВикиЧтение

Разработка ядра Linux
Лав Роберт

В этом руководстве вы найдете полный список системных вызовов Linux с их определением, параметрами и часто используемыми флагами.

Вы можете комбинировать несколько флагов, используя логическое И и передавая результат рассматриваемому аргументу.

Некоторые примечания к этому руководству:

• Звонки, которые давно обесценивались или были удалены, были опущены.
• Пункты, относящиеся к устаревшим или редко используемым архитектурам (например, MIPS, PowerPC), обычно опускаются.
• Структуры определяются только один раз. Если структура настроен и не может быть найден в системном вызове, поищите в документе его определение.

Исходные материалы включают страницы руководства, исходный код ядра и заголовки разработки ядра.

Оглавление

• Список системных вызовов Linux
• Оглавление
  • читать
  • написать
  • открыто
    • открытые флаги
  • Закрыть
  • стат
  • fstat
  • lstat
  • голосование
  • я ищу
    • откуда флаги
  • mmap
    • защитные флаги
    • флаги
  • mprotect
    • защитные флаги
  • munmap
  • BRK
  • rt_sigaction
  • rt_sigprocmask
    • как флаги
  • rt_sigreturn
  • ioctl
  • pread64
  • pwrite64
  • Readv
  • написать
  • доступ
  • трубка
  • Выбрать
  • sched_yield
  • mremap
    • флаги
  • msync
    • флаги
  • mincore
  • Madvise
    • совет
  • шмгет
    • shmflg
  • шмат
    • shmflg
  • shmctl
    • cmd
  • обман
  • dup2
  • Пауза
  • наносон
  • Getitimer
    • какие таймеры
  • тревога
  • setitimer
  • Getpid
  • Отправить файл
  • разъем
    • флаги домена
    • типовые флаги
  • соединять
  • принимать
  • Отправить
    • флаги
  • recvfrom
    • флаги
  • sendmsg
  • recvmsg
  • неисправность
    • как
  • связывать
  • Слушать
  • getsockname
  • getpeername
  • пара розеток
  • Setsockopt
  • Getsockopt
  • клон
    • флаги
  • вилка
  • vfork
  • Execve
  • выход
  • ждать4
    • опции
  • убийство
  • Getppid
  • безымянный
  • Семгет
  • семоп
  • semctl
    • cmd
  • шмдт
  • msgget
  • msgsnd
    • msgflg
  • msgrcv
  • msgctl
    • cmd
  • fcntl
    • cmd
    • стадо
    • f_owner_ex
  • стадо
    • операция
  • fsync
  • fdatasync
  • обрезать
  • ftruncate
  • Гетденты
    • типы
  • getcwd
  • чдир
  • fchdir
  • переименовать
  • mkdir
  • rmdir
  • Creat
  • ссылка на сайт
  • разорвать связь
  • символическая ссылка
  • ссылка для чтения
  • chmod
  • fchmod
  • Chown
  • Fchown
  • lchown
  • маска
  • gettimeofday
  • getrlimit
    • флаги ресурсов
  • Getrusage
    • кто нацелен
  • sysinfo
  • раз
  • ptrace
    • флаги запроса
  • Getuid
  • системный журнал
    • тип флаг
  • Getgid
  • Setuid
  • сетгид
  • geteuid
  • Getegid
  • setpgid
  • Getppid
  • getpgrp
  • SetSid
  • Setreuid
  • Setregid
  • getgroups
  • setgroups
  • Setresuid
  • Сетресгид
  • getresuid
  • Getresgid
  • getpgid
  • setfsuid
  • setfsgid
  • Getid
  • Capget
  • капсет
  • rt_sigpending
  • rt_sigtimedwait
  • rt_sigqueueinfo
  • rt_sigsuspend
  • сигальтовая стопка
  • время
  • mknod
  • uselib
  • личность
  • устат
  • statfs
  • fstatfs
  • sysfs
  • получить приоритет
    • который
  • Установить приоритет
  • sched_setparam
  • sched_getparam
  • sched_setscheduler
    • политика
  • sched_getscheduler
  • sched_get_priority_max
  • sched_get_priority_min
  • sched_rr_get_interval
  • mlock
  • мунлок
  • торговый центр
    • флаги
  • munlockall
  • Vhangup
  • modify_ldt
  • pivot_root
  • prctl
    • вариант
  • arch_prctl
  • adjtimex
  • setrlimit
  • chroot
  • синхронизировать
  • acct
  • время дня
  • устанавливать
    • mountflags
  • umount2
    • флаги
  • обменять
    • поменять флагами
  • обмен
  • перезагружать
    • аргумент
  • sethostname
  • setdomainname
  • iopl
  • иопермия
  • init_module
  • delete_module
    • флаги
  • quotactl
    • cmd
  • Gettid
  • читать вперед
  • setxattr
  • lsetxattr
  • fsetxattr
  • getxattr
  • lgetxattr
  • fgetxattr
  • listxattr
  • llistxattr
  • Flistxattr
  • removexattr
  • lremovexattr
  • fremovexattr
  • tkill
  • время
  • фьютекс
    • op
  • sched_setaffinity
  • sched_getaffinity
  • set_thread_area
  • io_setup
  • io_destroy
  • io_getevents
  • io_submit
  • io_cancel
  • get_thread_area
  • lookup_dcookie
  • epoll_create
  • гетеросексуалы64
  • set_tid_address
  • restart_syscall
  • семимедоп
  • fadvise64
    • совет
  • timer_create
    • Clockid
  • timer_settime
  • timer_gettime
  • timer_getoverrun
  • timer_delete
  • clock_settime
  • clock_gettime
  • clock_getres
  • clock_nanosleep
  • exit_group
  • epoll_wait
  • epoll_ctl
    • op
  • tgkill
  • время
  • mbind
    • Режим
  • set_mempolicy
  • get_mempolicy
    • флаги
  • mq_open
    • офлаг
  • mq_unlink
  • mq_timedsend
  • mq_timedreceive
  • mq_notify
  • kexec_load
    • флаги
  • waitid
    • опции
  • add_key
    • брелок для ключей
  • request_key
  • keyctl
    • cmd
  • ioprio_set
    • который
  • ioprio_get
  • inotify_init
  • inotify_add_watch
  • inotify_rm_watch
  • migrate_pages
  • открывать
  • мкдират
  • mknodat
  • Fchownat
  • отсоединить
  • переименовать
  • линкат
  • символическая ссылка
  • readlinkat
  • fchmodat
  • факс
  • pselect6
  • ppoll
  • не делиться
    • флаги
  • set_robust_list
  • get_robust_list
  • сращивание
    • флаги
  • тройник
  • sync_file_range
    • флаги
  • vmsplice
  • move_pages
    • флаги
  • utimensat
  • epoll_pwait
  • signalfd
  • timerfd_create
  • eventfd
    • флаги
  • сбиваться
    • Режим
  • timerfd_settime
  • timerfd_gettime
  • accept4
  • signalfd4
  • eventfd2
  • epoll_create1
  • dup3
  • pipe2
  • inotify_init1
  • Preadv
  • pwritev
  • rt_tgsigqueueinfo
  • perf_event_open
    • флаги
  • recvmmsg
  • fanotify_init
    • флаги
    • event_f_flags
  • fanotify_mark
    • dirfd
    • флаги
  • name_to_handle_at
  • open_by_handle_at
  • syncfs
  • sendmmsg
  • Setns
    • nsflag
  • getcpu
  • process_vm_readv
  • process_vm_writev
  • KCMP
    • типовые флаги
  • finit_module
    • флаги

читать

Читает из указанного файла, используя файловый дескриптор. Перед использованием этого вызова вы должны сначала получить дескриптор файла, используя открытосистемный вызов. Возвращает байты, прочитанные успешно.

ssize_t читать(int fd,пустота*бух,size_t считать)

• fd — дескриптор файла
• бух — указатель на буфер для заполнения прочитанным содержимым
• считать — количество байтов для чтения

написать

Записывает в указанный файл с помощью файлового дескриптора. Перед использованием этого вызова вы должны сначала получить дескриптор файла, используя открыто системный вызов. Возвращает успешно записанные байты.

ssize_t написать(int fd,constпустота*бух,size_t считать)

• fd — дескриптор файла
• бух — указатель на буфер для записи
• считать — количество байтов для записи

открыто

Открывает или создает файл в зависимости от флагов, переданных вызову. Возвращает целое число с файловым дескриптором.

int открыто(constchar*путь,int флаги, mode_t режим)

• путь — указатель на буфер, содержащий полный путь и имя файла
• флаги — целое число с флагами операций (см. Ниже)
• Режим — (необязательно) определяет режим разрешений, если файл должен быть создан

открытые флаги

• O_APPEND — добавить в существующий файл
• O_ASYNC — использовать управляемый сигналом ввод-вывод
• O_CLOEXEC — использовать close-on-exec (избегать состояний гонки и конфликтов блокировки)
• O_CREAT — создать файл, если его не существует
• O_DIRECT — обход кеша (медленнее)
• O_DIRECTORY — сбой, если путь не является каталогом
• O_DSYNC — убедитесь, что вывод отправляется на оборудование, а метаданные записываются перед возвратом
• O_EXCL — обеспечить создание файла
• O_LARGEFILE — позволяет использовать размеры файлов, представленные off64_t
• O_NOATIME — не увеличивать время доступа при открытии
• O_NOCTTY — если путь — это оконечное устройство, не становиться управляющим терминалом
• O_NOFOLLOW — сбой, если путь — символическая ссылка
• O_NONBLOCK — по возможности открыть файл с неблокирующим вводом-выводом
• O_NDELAY — такой же как O_NONBLOCK
• O_PATH — открытый дескриптор для получения разрешений и статуса файла, но не разрешает операции чтения / записи
• O_SYNC — дождитесь завершения ввода-вывода перед возвратом
• O_TMPFILE — создать безымянный, недоступный (через любой другой открытый вызов) временный файл
• O_TRUNC — если файл существует, перезаписать его (осторожно!)

Закрыть

Закройте файловый дескриптор. После успешного выполнения он больше не может использоваться для ссылки на файл.

int Закрыть(int fd)

• fd — дескриптор файла для закрытия

стат

Возвращает информацию о файле в структуре с именем стат.

int стат(constchar*дорожка,структура стат *бух);

• дорожка — указатель на имя файла
• бух — указатель на структуру для получения информации о файле

В случае успеха бух структура заполняется следующими данными:

struct stat {dev_t st_dev; / * идентификатор устройства устройства с файлом * / ino_t st_ino; / * индексный дескриптор * / mode_t st_mode; / * режим разрешения * / nlink_t st_nlink; / * количество жестких ссылок на файл * / uid_t st_uid; / * идентификатор пользователя-владельца * / gid_t st_gid; / * идентификатор группы владельцев * / dev_t st_rdev; / * идентификатор устройства (только если файл устройства) * / off_t st_size; / * общий размер (байты) * / blksize_t st_blksize; / * размер блока для ввода / вывода * / blkcnt_t st_blocks; / * количество выделенных блоков по 512 байт * / time_t st_atime; / * время последнего доступа * / time_t st_mtime; / * время последней модификации * / time_t st_ctime; / * время последнего изменения статуса * / };

fstat

Работает точно так же, как стат системный вызов, кроме файлового дескриптора (fd) предоставляется вместо пути.

int fstat(int fd,структура стат *бух);

• fd — дескриптор файла
• бух — указатель на буфер статистики (описан в стат системный вызов)

Вернуть данные в бух идентичен стат вызов.

lstat

Работает точно так же, как стат syscall, но если рассматриваемый файл является символической ссылкой, возвращается информация о ссылке, а не о ее цели.

int lstat(constchar*дорожка,структура стат *бух);

• дорожка — полный путь к файлу
• бух — указатель на буфер статистики (описан в стат системный вызов)

Вернуть данные в бух идентичен стат вызов.

голосование

Подождите, пока не произойдет событие в указанном дескрипторе файла.

int голосование(структура опрос *fds, nfds_t nfds,int тайм-аут);

• fds — указатель на массив опрос конструкции (описаны ниже)
• нфд — количество опрос предметы в fds множество
• тайм-аут — устанавливает количество миллисекунд, которое системный вызов должен блокировать (отрицательные силы голосование немедленно вернуться)

struct pollfd {int fd; / * файловый дескриптор * / короткие события; / * события, запрошенные для опроса * / short revents; / * события, произошедшие во время опроса * / };

я ищу

Этот системный вызов изменяет смещение чтения / записи связанного файлового дескриптора. Полезно для установки позиции в определенное место для чтения или записи, начиная с этого смещения.

off_t я ищу(int fd,off_t компенсировать,int откуда)

• fd — дескриптор файла
• компенсировать — смещение для чтения / записи из
• откуда — определяет отношение смещения и поведение поиска

откуда флаги

• SEEK_SET – компенсировать это абсолютная позиция смещения в файле
• SEEK_CUR – компенсировать текущее положение смещения плюс компенсировать
• SEEK_END – компенсировать размер файла плюс компенсировать
• SEEK_DATA — установить смещение к следующему положению больше или равно компенсировать который содержит данные
• SEEK_HOLE — установить смещение до следующего отверстия в файле большим или равным компенсировать

Возвращает результирующее смещение в байтах от начала файла.

mmap

Отображает файлы или устройства в память.

пустота*mmap(пустота*адрес,size_t длина,int защита,int флаги,int fd,off_t компенсировать)

• адрес — подсказка местоположения для отображения местоположения в памяти, в противном случае, если NULL, ядро ​​назначает адрес
• длина — длина отображения
• защита — указывает защиту памяти отображения
• флаги — контролировать видимость сопоставления с другими процессами
• fd — дескриптор файла
• компенсировать — смещение файла

Возвращает указатель на сопоставленный файл в памяти.

защитные флаги

• PROT_EXEC — разрешает выполнение отображенных страниц
• PROT_READ — позволяет читать отображенные страницы
• PROT_WRITE — позволяет записывать отображенные страницы
• PROT_NONE — предотвращает доступ к отображенным страницам

флаги

• MAP_SHARED — позволяет другим процессам использовать это отображение
• MAP_SHARED_VALIDATE — такой же как MAP_SHARED но гарантирует, что все флаги действительны
• MAP_PRIVATE — предотвращает использование этого сопоставления другими процессами
• MAP_32BIT — сообщает ядру найти отображение в первых 2 ГБ ОЗУ
• MAP_ANONYMOUS — позволяет отображению не поддерживаться каким-либо файлом (таким образом игнорируя.

  fd

  )

• MAP_FIXED — угощает адрес аргумент как реальный адрес, а не намек
• MAP_FIXED_NOREPLACE — такой же как MAP_FIXED но предотвращает затирание существующих сопоставленных диапазонов
• MAP_GROWSDOWN — указывает ядру развернуть отображение вниз в ОЗУ (полезно для стеков)
• MAP_HUGETB — принудительное использование огромных страниц при отображении
• MAP_HUGE_1MB — использовать с MAP_HUGETB для установки страниц размером 1 МБ
• MAP_HUGE_2MB — использовать с MAP_HUGETB для установки страниц размером 2 МБ
• MAP_LOCKED — отображает блокируемую область (поведение аналогично mlock)
• MAP_NONBLOCK — предотвращает упреждающее чтение для этого сопоставления
• MAP_NORESERVE — предотвращает выделение пространства подкачки для этого сопоставления
• MAP_POPULATE — указывает ядру заполнить таблицы страниц для этого сопоставления (вызывая упреждающее чтение)
• MAP_STACK — сообщает ядру о выделении адреса, подходящего для использования в стеке
• MAP_UNINITIALIZED — предотвращает очистку анонимных страниц

mprotect

Устанавливает или регулирует защиту области памяти.

int mprotect(пустота*адрес,size_t len,int защита)

• адрес — указатель на регион в памяти
• защита — флаг защиты

В случае успеха возвращает ноль.

защитные флаги

• PROT_NONE — предотвращает доступ к памяти
• PROT_READ — позволяет читать память
• PROT_EXEC — разрешает выполнение памяти
• PROT_WRITE — позволяет изменять память
• PROT_SEM — позволяет использовать память в атомарных операциях
• PROT_GROWSUP — устанавливает повышающий режим защиты (для архитектур, у которых стек растет вверх)
• PROT_GROWSDOWN — устанавливает понижающий режим защиты (полезно для стековой памяти)

munmap

Отменяет отображение сопоставленных файлов или устройств.

int munmap(пустота*адрес,size_t len)

• адрес — указатель на отображаемый адрес
• len — размер отображения

В случае успеха возвращает ноль.

BRK

Позволяет изменить разрыв программы, определяющий конец сегмента данных процесса.

int BRK(пустота*адрес)

• адрес — новый указатель адреса прерывания программы

В случае успеха возвращает ноль.

rt_sigaction

Изменить действие, предпринимаемое, когда процесс получает определенный сигнал (кроме СИГКИЛЛ и SIGSTOP).

int rt_sigaction(int сигнум,constструктура подписание *действовать,структура подписание *старый акт)

• сигнум — номер сигнала
• действовать — структура для нового действия
• старый акт — структура для старого действия

struct sigaction {void (* sa_handler) (интервал); void (* sa_sigaction) (интервал, siginfo_t *, void *); sigset_t sa_mask; int sa_flags; void (* sa_restorer) (недействительно); }; 

siginfo_t {int si_signo; / * номер сигнала * / int si_errno; / * значение ошибки * / int si_code; / * сигнальный код * / int si_trapno; / * ловушка, вызвавшая аппаратный сигнал (не используется на большинстве архитектур) * / pid_t si_pid; / * отправка PID * / uid_t si_uid; / * настоящий UID программы-отправителя * / int si_status; / * значение выхода или сигнал * / clock_t si_utime; / * затраченное пользователем время * / clock_t si_stime; / * затраченное системное время * / sigval_t si_value; / * значение сигнала * / int si_int; / * Сигнал POSIX.1b * / void * si_ptr; / * Сигнал POSIX.1b * / int si_overrun; / * счетчик превышения таймера * / int si_timerid; / * идентификатор таймера * / void * si_addr; / * место в памяти, вызвавшее ошибку * / long si_band; / * событие бэнда * / int si_fd; / * дескриптор файла * / short si_addr_lsb; / * Младший бит адреса * / void * si_lower; / * нижняя граница при нарушении адреса * / void * si_upper; / * верхняя граница при нарушении адреса * / int si_pkey; / * ключ защиты на PTE, вызывающий ошибку * / void * si_call_addr; / * адрес инструкции системного вызова * / int si_syscall; / * количество попыток системного вызова * / unsigned int si_arch; / * свод попыток системного вызова * / }

rt_sigprocmask

Получить и / или установить сигнальную маску потока.

int sigprocmask(int как,const sigset_t *задавать, sigset_t *старый набор)

• как — флаг для определения поведения звонка
• задавать — маска нового сигнала (NULL оставить без изменений)
• старый набор — маска предыдущего сигнала

В случае успеха возвращает ноль.

как флаги

• SIG_BLOCK — установить маску на блок согласно задавать
• SIG_UNBLOCK — установить маску разрешить согласно задавать
• SIG_SETMASK — установить маску на задавать

rt_sigreturn

Вернитесь из обработчика сигналов и очистите кадр стека.

int сигнатура(беззнаковыйдолго __ неиспользованный)

ioctl

Задайте параметры файлов устройства.

int ioctl(int d,int запрос, …)

• d — открыть файловый дескриптор файла устройства
• запрос — код запроса
• ... — нетипизированный указатель

В большинстве случаев возвращает ноль в случае успеха.

pread64

Чтение из файла или устройства, начиная с определенного смещения.

ssize_t pread64(int fd,пустота*бух,size_t считать,off_t компенсировать)

• fd — дескриптор файла
• бух — указатель на буфер чтения
• считать — байты для чтения
• компенсировать — смещение для чтения

Возвращает прочитанные байты.

pwrite64

Запись в файл или устройство, начиная с определенного смещения.

ssize_t pwrite64(int fd,пустота*бух,size_t считать,off_t компенсировать)

• fd — дескриптор файла
• бух — указатель на буфер
• считать — байты на запись
• компенсировать — смещение для начала записи

Возвращает записанные байты.

Readv

Чтение из файла или устройства в несколько буферов.

ssize_t readv(int fd,constструктура iovec *iov,int iovcnt)

• fd — дескриптор файла
• iov — указатель на структуру iovec
• iovcnt — количество буферов (описывается iovec)

struct iovec {void * iov_base; / * Начальный адрес * / size_t iov_len; / * Количество байтов для передачи * / };

Возвращает прочитанные байты.

написать

Запись в файл или устройство из нескольких буферов.

ssize_t writev(int fd,constструктура iovec *iov,int iovcnt)

• fd — дескриптор файла
• iov — указатель на структуру iovec
• iovcnt — количество буферов (описывается iovec)

struct iovec {void * iov_base; / * Начальный адрес * / size_t iov_len; / * Количество байтов для передачи * / };

Возвращает записанные байты.

доступ

Проверить разрешения текущего пользователя для указанного файла или устройства.

int доступ(constchar*путь,int Режим)

• путь — файл или устройство
• Режим — проверка разрешений на выполнение

В случае успеха возвращает ноль.

трубка

Создайте трубу.

int трубка(int pipefd[2])

• pipefd — массив файловых дескрипторов с двумя концами конвейера

В случае успеха возвращает ноль.

Выбрать

Подождите, пока файловые дескрипторы станут готовы к вводу-выводу.

int Выбрать(int нфд, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
структура время *тайм-аут)

• нфд — количество описаний файлов для мониторинга (добавить 1)
• readfds — исправлен буфер со списком файловых дескрипторов для ожидания доступа на чтение
• writefds — исправлен буфер со списком файловых дескрипторов для ожидания доступа на запись
• exceptfds — исправлен буфер со списком файловых дескрипторов для ожидания исключительных условий
• тайм-аут — временная структура со временем ожидания перед возвратом

typedef struct fd_set {u_int fd_count; РАЗЪЕМ fd_array [FD_SETSIZE]; } 

struct timeval {long tv_sec; / * секунды * / long tv_usec; / * микросекунды * / };

Возвращает количество файловых дескрипторов или ноль, если истекло время ожидания.

sched_yield

Верните процессорное время ядру или другим процессам.

int sched_yield(пустота)

В случае успеха возвращает ноль.

mremap

Уменьшите или увеличьте область памяти, возможно, переместив ее в процессе.

пустота*mremap(пустота*old_address,size_t old_size,size_t new_size,int флаги,… /* пустота
*новый адрес */)

• old_address — указатель на старый адрес для переназначения
• old_size — размер старой области памяти
• new_size — размер новой области памяти
• флаги — определить дополнительное поведение

флаги

• MREMAP_MAYMOVE — разрешить ядру перемещать регион, если места недостаточно (по умолчанию)
• MREMAP_FIXED — переместить отображение (также необходимо указать MREMAP_MAYMOVE)

msync

Синхронизировать файл с отображением памяти, ранее сопоставленный с mmap.

int msync(пустота*адрес,size_t длина,int флаги)

• адрес — адрес файла с привязкой к памяти
• длина — длина отображения памяти
• флаги — определить дополнительное поведение

флаги

• MS_ASYNC — синхронизация расписания, но возврат немедленно
• MS_SYNC — дождитесь завершения синхронизации
• MS_INVALIDATE — сделать недействительными другие сопоставления того же файла

В случае успеха возвращает ноль.

mincore

Проверьте, есть ли страницы в памяти.

int mincore(пустота*адрес,size_t длина,беззнаковыйchar*vec)

• адрес — адрес памяти для проверки
• длина — длина сегмента памяти
• vec — указатель на массив размером до (длина + PAGE_SIZE-1) / PAGE_SIZE это ясно, если страница находится в памяти

Возвращает ноль, но vec необходимо ссылаться на наличие страниц в памяти.

Madvise

Посоветуйте ядру, как использовать данный сегмент памяти.

int Madvise(пустота*адрес,size_t длина,int совет)

• адрес — адрес памяти
• длина — длина сегмента
• совет — флаг совета

совет

• MADV_NORMAL — без советов (по умолчанию)
• MADV_RANDOM — страницы могут располагаться в произвольном порядке (может быть затруднено упреждающее чтение)
• MADV_SEQUENTIAL — страницы должны быть в последовательном порядке
• MADV_WILLNEED — Скоро потребуются страницы (намекает на ядро, чтобы запланировать упреждающее чтение)
• MADV_DONTNEED — не нужны в ближайшее время (не рекомендуется читать вперед)

шмгет

Выделите сегмент разделяемой памяти System V.

int шмгет(key_t ключ,size_t размер,int shmflg)

• ключ — идентификатор сегмента памяти
• размер — длина сегмента памяти
• shmflg — флаг модификатора поведения

shmflg

• IPC_CREAT — создать новый сегмент
• IPC_EXCL — убедитесь, что создание происходит, иначе вызов не удастся
• SHM_HUGETLB — использовать огромные страницы при выделении сегмента
• SHM_HUGE_1GB — используйте размер hugetlb 1 ГБ
• SHM_HUGE_2M — используйте размер hugetlb 2 МБ
• SHM_NORESERVE — не резервируйте место подкачки для этого сегмента

шмат

Присоединить сегмент разделяемой памяти к пространству памяти вызывающего процесса.

пустота*шмат(int шмид,constпустота*Shmaddr,int shmflg)

• шмид — идентификатор сегмента разделяемой памяти
• Shmaddr — адрес сегмента разделяемой памяти
• shmflg — определить дополнительное поведение

shmflg

• SHM_RDONLY — прикрепить сегмент как доступный только для чтения
• SHM_REMAP — заменить существующее отображение

shmctl

Получить или установить детали управления для сегмента разделяемой памяти.

int shmctl(int шмид,int cmd,структура shmid_ds *бух)

• шмид — идентификатор сегмента разделяемой памяти
• cmd — флаг команды
• бух – shmid_ds структурный буфер для возврата или установки параметров

struct shmid_ds {struct ipc_perm shm_perm; / * Право собственности и разрешения * / size_t shm_segsz; / * Размер разделяемого сегмента (байты) * / time_t shm_atime; / * Время последнего подключения * / time_t shm_dtime; / * Время последнего отключения * / time_t shm_ctime; / * Время последнего изменения * / pid_t shm_cpid; / * PID создателя разделяемого сегмента * / pid_t shm_lpid; / * PID последнего системного вызова shmat (2) / shmdt (2) * / shmatt_t shm_nattch; / * Количество текущих подключений * /... }; 

struct ipc_perm {key_t __key; / * Ключ предоставлен для shmget * / uid_t uid; / * Эффективный UID владельца * / gid_t gid; / * Действующий GID владельца * / uid_t cuid; / * Эффективный UID создателя * / gid_t cgid; / * Действующий GID создателя * / unsigned short mode; / * Разрешения и флаги SHM_DEST + SHM_LOCKED * / unsigned short __seq; /* Последовательность */ }; 

Успешные системные вызовы IPC_INFO или SHM_INFO возвращают индекс самой использованной записи в массиве сегментов разделяемой памяти ядра. Успешные системные вызовы SHM_STAT возвращают идентификатор сегмента памяти, указанного в shmid. Все остальное в случае успеха возвращает ноль.

cmd

• IPC_STAT — получить информацию о сегменте разделяемой памяти и поместить в буфер
• IPC_SET — установить параметры сегмента разделяемой памяти, определенные в буфере
• IPC_RMID — отметить сегмент разделяемой памяти для удаления

обман

Дубликат файлового десиптора.

int обман(int oldfd)

• oldfd — файловый дескриптор для копирования

Возвращает новый дескриптор файла.

dup2

Такой же как обман Кроме dup2 использует номер дескриптора файла, указанный в newfd.

int dup2(int oldfd,int newfd)

• oldfd — файловый дескриптор для копирования
• newfd — новый файловый дескриптор

Пауза

Подождите сигнала и возвращайтесь.

int Пауза(пустота)

Возвращает -1 при получении сигнала.

наносон

Такой же как спать но со временем, указанным в наносекундах.

int наносон(constструктура время *req,структура время *rem)

• req — указатель на структуру аргументов системного вызова
• rem — указатель на структуру с оставшимся временем в случае прерывания по сигналу

struct timespec {time_t tv_sec; / * время в секундах * / long tv_nsec; / * время в наносекундах * / };

Возвращает ноль при успешном засыпании, в противном случае истекшее время копируется в rem структура.

Getitimer

Получите значение от интервального таймера.

int Getitimer(int который,структура Itimerval *curr_value)

• который — какой таймер
• curr_value — указатель на Itimerval структура с деталями аргумента

struct itimerval {struct timeval it_interval; / * Интервал для периодического таймера * / struct timeval it_value; / * Время до следующего истечения срока * /}; 

В случае успеха возвращает ноль.

какие таймеры

• ITIMER_REAL — таймер использует реальное время
• ITIMER_VIRTUAL — таймер использует время выполнения ЦП в пользовательском режиме
• ITIMER_PROF — таймер использует время выполнения как пользователя, так и системы

тревога

Установить будильник для доставки сигнала SIGALRM.

беззнаковыйint тревога(беззнаковыйint секунды)

• секунды — Отправить SIGALRM через x секунд

Возвращает количество секунд, оставшихся до срабатывания ранее установленного сигнала тревоги, или ноль, если ранее не был установлен сигнал тревоги.

setitimer

Создать или уничтожить тревогу, указанную который.

int setitimer(int который,constструктура Itimerval *новое_значение,структура Itimerval *old_value)

• который — какой таймер
• новое_значение — указатель на Itimerval структура с новыми деталями таймера
• old_value — если не ноль, указатель на Itimerval структура с предыдущими деталями таймера

struct itimerval {struct timeval it_interval; / * Интервал для периодического таймера * / struct timeval it_value; / * Время до следующего истечения срока * /}; 

В случае успеха возвращает ноль.

Getpid

Получить PID текущего процесса.

pid_t getpid(пустота)

Возвращает PID процесса.

Отправить файл

Передача данных между двумя файлами или устройствами.

ssize_t sendfile(int out_fd,int in_fd,off_t*компенсировать,size_t считать)

• out_fd — файловый дескриптор для назначения
• in_fd — файловый дескриптор для источника
• компенсировать — позиция для начала чтения
• считать — байты для копирования

Возвращает записанные байты.

разъем

Создайте конечную точку для сетевого взаимодействия.

int разъем(int домен,int тип,int протокол)

• домен — флаг, указывающий тип сокета
• тип — флаг, указывающий специфику сокета
• протокол — флаг, указывающий протокол для связи

флаги домена

• AF_UNIX — Местная связь
• AF_LOCAL — То же, что AF_UNIX
• AF_INET — Интернет-протокол IPv4
• AF_AX25 — Радиолюбительский протокол AX.25
• AF_IPXIPX — Протоколы Novell
• AF_APPLETALK — AppleTalk
• AF_X25 — Протокол ITU-T X.25 / ISO-8208
• AF_INET6 — Интернет-протокол IPv6
• AF_DECnet — сокеты протокола DECet
• AF_KEYKey — Протокол управления IPsec
• AF_NETLINK — Устройство пользовательского интерфейса ядра
• AF_PACKET — Пакетный интерфейс низкого уровня
• AF_RDS — Надежные сокеты для дейтаграмм (RDS)
• AF_PPPOX — Общий транспортный уровень PPP для туннелей L2 (L2TP, PPPoE и т. Д.)
• AF_LLC — Управление логическим каналом (IEEE 802.2 LLC)
• AF_IB — Собственная адресация InfiniBand
• AF_MPLS — Многопротокольная коммутация меток
• AF_CAN — Протокол автомобильной шины Controller Area Network
• AF_TIPC — TIPC (сокеты кластерного домена)
• AF_BLUETOOTH — Протокол низкоуровневого сокета Bluetooth
• AF_ALG — Интерфейс к API криптографии ядра
• AF_VSOCK — Протокол VSOCK для связи между гипервизором и гостем (VMWare и т. Д.)
• AF_KCMKCM — Интерфейс мультиплексора соединения ядра
• AF_XDPXDP — Интерфейс экспресс-передачи данных

типовые флаги

• SOCK_STREAM — последовательные, надежные потоки байтов
• SOCK_DGRAM — дейтаграммы (сообщения без установления соединения и ненадежные сообщения, фиксированная максимальная длина)
• SOCK_SEQPACKET — последовательная, надежная передача дейтаграмм
• SOCK_RAW— доступ к необработанному сетевому протоколу
• SOCK_RDM — надежный слой дейтаграмм с возможной передачей вне очереди
• SOCK_NONBLOCK — сокет не блокируется (избегайте лишних вызовов fcntl)
• SOCK_CLOEXEC — установить флаг закрытия при выполнении

В случае успеха возвращает дескриптор файла.

соединять

Подключите к розетке.

int соединять(int sockfd,constструктура sockaddr *адрес, socklen_t addrlen)

• sockfd — файловый дескриптор сокета
• адрес — указатель на адрес сокета
• адрес — размер адреса

В случае успеха возвращает ноль.

принимать

Подтвердите подключение к сокету.

int принимать(int sockfd,структура sockaddr *адрес, socklen_t *адрес)

• sockfd — файловый дескриптор сокета
• адрес — указатель на адрес сокета
• адрес — размер адреса

В случае успеха возвращает файловый дескриптор принятого сокета.

Отправить

Отправить сообщение в сокет.

Отправить(int sockfd,constпустота*бух,size_t len,int флаги)

• sockfd — файловый дескриптор сокета
• бух — буфер с сообщением для отправки
• len — длина сообщения
• флаги — дополнительные параметры

флаги

• MSG_CONFIRM — сообщает канальному уровню, что ответ получен
• MSG_DONTROUTE — не использовать шлюз при передаче пакета
• MSG_DONTWAIT — выполнить неблокирующую операцию
• MSG_EOR — конец записи
• MSG_MORE — больше данных для отправки
• MSG_NOSIGNAL — не генерировать сигнал SIGPIPE, если одноранговое закрытое соединение
• MSG_OOB — отправляет внеполосные данные о поддерживаемых сокетах и ​​протоколах

recvfrom

Получите сообщение от сокета.

ssize_t recvfrom(int sockfd,пустота*бух,size_t len,int флаги,структура sockaddr
*src_addr, socklen_t *адрес)

• sockfd — файловый дескриптор сокета
• бух — буфер для приема сообщения
• размер — размер буфера
• флаги — дополнительные параметры
• src_addr — указатель на адрес источника
• адрес — длина исходного адреса.

флаги

• MSG_CMSG_CLOEXEC — установить флаг close-on-exec для дескриптора файла сокета
• MSG_DONTWAIT — выполнять операцию без блокировки
• MSG_ERRQUEUE — ошибки в очереди должны поступать в очередь ошибок сокета

Возвращает успешно полученные байты.

sendmsg

Подобно Отправить syscall, но позволяет отправлять дополнительные данные через сообщение аргумент.

ssize_t sendmsg(int sockfd,constструктура msghdr *сообщение,int флаги)

• sockfd — файловый дескриптор сокета
• сообщение — указатель на структуру msghdr с сообщением для отправки (с заголовками)
• флаги— такой же как Отправить системный вызов

struct msghdr {void * msg_name; / * необязательный адрес * / socklen_t msg_namelen; / * размер адреса * / struct iovec * msg_iov; / * массив разброса / сбора * / size_t msg_iovlen; / * количество элементов массива в msg_iov * / void * msg_control; / * вспомогательные данные * / size_t msg_controllen; / * длина вспомогательных данных * / int msg_flags; / * помечает полученное сообщение * / };

recvmsg

Получите сообщение от сокета.

ssize_t recvmsg(int sockfd,структура msghdr *сообщение,int флаги)

• sockfd — файловый дескриптор сокета
• сообщение — указатель на структуру msghdr (определенную в sendmsg выше) получить
• флаги — определить дополнительное поведение (см. Отправить системный вызов)

неисправность

Отключите полнодуплексное подключение розетки.

int неисправность(int sockfd,int как)

• sockfd — файловый дескриптор сокета
• как — флаги, определяющие дополнительное поведение

В случае успеха возвращает ноль.

как

• SHUT_RD — предотвратить дальнейшие приемы
• SHUT_WR — предотвратить дальнейшие передачи
• SHUT_RDWR — предотвратить дальнейший прием и передачу

связывать

Привязать имя к сокету.

int связывать(int sockfd,constструктура sockaddr *адрес, socklen_t addrlen)

• sockfd — файловый дескриптор сокета
• адрес — указатель на структуру sockaddr с адресом сокета
• адрес — длина адреса

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

В случае успеха возвращает ноль.

Слушать

Слушайте сокет на предмет соединений.

int Слушать(int sockfd,int отставание)

• sockfd — файловый дескриптор сокета
• отставание — максимальная длина очереди ожидающих подключений

В случае успеха возвращает ноль.

getsockname

Получите имя сокета.

int getsockname(int sockfd,структура sockaddr *адрес, socklen_t *адрес)

• sockfd — файловый дескриптор сокета
• адрес — указатель на буфер, в который будет возвращено имя сокета
• адрес — длина буфера

В случае успеха возвращает ноль.

getpeername

Получите имя подключенного однорангового сокета.

int getpeername(int sockfd,структура sockaddr *адрес, socklen_t *адрес)

• sockfd — файловый дескриптор сокета
• адрес — указатель на буфер, в который будет возвращено имя пира
• адрес — длина буфера

В случае успеха возвращает ноль.

пара розеток

Создайте пару уже подключенных розеток.

int пара розеток(int домен,int тип,int протокол,int св[2])

Аргументы идентичны разъем системный вызов, кроме четвертого аргумента (св) представляет собой целочисленный массив, заполненный двумя дескрипторами сокета.

В случае успеха возвращает ноль.

Setsockopt

Установите параметры на розетке.

int Setsockopt(int sockfd,int уровень,int optname,constпустота*optval, socklen_t optlen)

• sockfd — файловый дескриптор сокета
• optname — возможность установить
• optval — указатель на значение опции
• optlen — длина варианта

В случае успеха возвращает ноль.

Getsockopt

Получите текущие настройки розетки.

int Getsockopt(int sockfd,int уровень,int optname,пустота*optval, socklen_t *optlen)

• sockfd — файловый дескриптор сокета
• optname — возможность получить
• optval — указатель на получение значения опции
• optlen — длина варианта

В случае успеха возвращает ноль.

клон

Создайте дочерний процесс.

int клон(int(*fn)(пустота*),пустота*куча,int флаги,пустота*аргумент, …
/ * pid_t * parent_tid, void * tls, pid_t * child_tid * /)

• fd — указатель на начальный адрес исполнения
• куча — указатель на стек дочернего процесса
• флаг — определить поведение системного вызова клона
• аргумент — указатель на аргументы дочернего процесса

флаги

• CLONE_CHILD_CLEARTID — очистить идентификатор дочернего потока в местоположении, на которое ссылается child_tld
• CLONE_CHILD_SETTID — сохранить идентификатор дочернего потока в местоположении, на которое ссылается child_tid
• CLONE_FILES — родительский и дочерний процессы используют одни и те же файловые дескрипторы
• CLONE_FS — родительский и дочерний процессы используют одну и ту же информацию о файловой системе
• CLONE_IO — дочерний процесс разделяет контекст ввода-вывода с родительским
• CLONE_NEWCGROUP — дочерний элемент создается в новом пространстве имен cgroup
• CLONE_NEWIPC — дочерний процесс, созданный в новом пространстве имен IPC
• CLONE_NEWNET — создать дочерний элемент в новом сетевом пространстве имен
• CLONE_NEWNS — создать дочерний элемент в новом пространстве имен монтирования
• CLONE_NEWPID — создать дочерний элемент в новом пространстве имен PID
• CLONE_NEWUSER — создать дочерний элемент в новом пространстве имен пользователя
• CLONE_NEWUTS — создать дочерний процесс в новом пространстве имен UTS
• CLONE_PARENT — потомок является клоном вызывающего процесса
• CLONE_PARENT_SETTID — сохранить идентификатор дочернего потока в местоположении, на которое ссылается parent_tid
• CLONE_PID — дочерний процесс создается с тем же PID, что и родительский
• CLONE_PIDFD — Дескриптор файла PID дочернего процесса помещается в родительскую память
• CLONE_PTRACE — если отслеживается родительский процесс, отслеживать и дочерний процесс
• CLONE_SETTLS — дескриптор локального хранилища потока (TLS) установлен на TLS
• CLONE_SIGHAND — обработчики сигналов родительского и дочернего общих ресурсов
• CLONE_SYSVSEM — дочерний и родительский элементы используют одни и те же значения настройки семафора System V
• CLONE_THREAD — дочерний элемент создается в той же группе потоков, что и родительский
• CLONE_UNTRACED — если отслеживается родитель, дочерний элемент не отслеживается
• CLONE_VFORK — родительский процесс приостанавливается до вызова дочернего Execve или _выход
• CLONE_VM — родительский и дочерний запускаются в одном и том же пространстве памяти

вилка

Создайте дочерний процесс.

вилка pid_t(пустота)

Возвращает PID дочернего процесса.

vfork

Создать дочерний процесс без копирования таблиц страниц родительского процесса.

pid_t vfork(пустота)

Возвращает PID дочернего процесса.

Execve

Выполнить программу.

int Execve(constchar*путь,char*const argv[],char*const envp[])

• путь — путь к программе для запуска
• argv — указатель на массив аргументов для программы
• envp — указатель на массив строк (в формате ключ = значение) для окружения

Не возвращается в случае успеха, возвращает -1 в случае ошибки.

выход

Завершить процесс вызова.

пустота _выход(int статус)

• статус — код статуса для возврата к родителю

Не возвращает значения.

ждать4

Подождите, пока процесс изменит состояние.

pid_t wait4(pid_t pid,int*wstatus,int опции,структура ржавчина *ржавчина)

• пид — PID процесса
• wstatus — статус ждать
• опции — флаги опций для звонка
• ржавчина — указатель на структуру с использованием о дочернем процессе, заполняемый при возврате

Возвращает PID завершенного дочернего элемента.

опции

• WNOHANG — вернуть, если ни один ребенок не вышел
• ГЛАВНЫЙ — вернуть, если дочерний элемент останавливается (но не отслеживается с помощью ptrace)
• ПРОДОЛЖАЕТСЯ — вернуть, если остановленный ребенок возобновил с SIGCONT
• WIFEXITED — вернуть, если дочерний элемент нормально завершается
• WEXITSTATUS — вернуть статус выхода ребенка
• WIFSIGNALED — вернуть истину, если потомок был прерван сигналом
• WTERMSIG — вернуть номер сигнала, который привел к завершению дочернего процесса
• WCOREDUMP — вернуть истину, если дочернее ядро ​​сброшено
• IFSTOPPED — вернуть истину, если ребенок был остановлен сигналом
• WSTOPSIG — возвращает номер сигнала, вызвавшего остановку ребенка
• WIF ПРОДОЛЖАЕТСЯ — вернуть истину, если потомок был возобновлен с помощью SIGCONT

убийство

Отправить сигнал для обработки.

int убийство(pid_t pid,int сиг)

• пид — PID процесса
• сиг — номер сигнала для отправки в процесс

В случае успеха вернуть ноль.

Getppid

Получить PID родительского процесса вызова.

pid_t getppid(пустота)

Возвращает PID родителя вызывающего процесса.

безымянный

Получите информацию о ядре.

int безымянный(структура utsname *бух)

• бух — указатель на utsname структура для получения информации

В случае успеха вернуть ноль.

struct utsname {char sysname []; / * Имя ОС (например, "Linux") * / char nodename []; / * имя узла * / char release []; / * Версия ОС (например, "4.1.0") * / char version []; / * Версия ОС * / char machine []; / * идентификатор оборудования * / #ifdef _GNU_SOURCE char domainname []; / * Доменное имя NIS или YP * / #endif. }; 

Семгет

Получить идентификатор набора семафоров System V.

int Семгет(key_t ключ,int nsems,int semflg)

• ключ — ключ идентификатора для получения
• nsems — количество семафоров в наборе
• semflg — флаги семафоров

Возвращает значение идентификатора набора семафоров.

семоп

Выполните операцию на указанном (ых) пороге (ах).

int семоп(int полусухой,структура сембуф *подачки,size_t nsops)

• полусухой — идентификатор семафора
• подачки — указатель на сембуф структура для операций
• nsops — количество операций

struct sembuf {ushort sem_num; / * индекс семафора в массиве * / short sem_op; / * работа с семафором * / short sem_flg; / * флаги для работы * / };

В случае успеха вернуть ноль.

semctl

Выполните операцию управления семафором.

int semctl(int полусухой,int семя,int cmd, …)

• полусухой — идентификатор набора семафоров
• семя — номер семафора в наборе
• cmd — операция для выполнения

Необязательный четвертый аргумент — это семун структура:

союз семун {int val; / * Значение SETVAL * / struct semid_ds * buf; / * буфер для IPC_STAT, IPC_SET * / unsigned short * array; / * массив для GETALL, SETALL * / struct Seinfo * __ buf; / * буфер для IPC_INFO * / };

Возвращает неотрицательное значение, соответствующее cmd флаг в случае успеха или -1 в случае ошибки.

cmd

• IPC_STAT — копировать информацию из ядра, связанную с полусухой в semid_ds на который ссылается arg.buf
• IPC_SET — записать значения semid_ds структура, на которую ссылается arg.buf
• IPC_RMID — удалить набор семафоров
• IPC_INFO — получить информацию об ограничениях системных семафоров Seminfo структура
• SEM_INFO — возвращение Seminfo структура с той же информацией, что и IPC_INFO за исключением того, что некоторые поля возвращаются с информацией о ресурсах, потребляемых семафорами
• SEM_STAT — возвращение semid_ds структура как IPC_STAT но полусухой аргумент — это индекс в массиве семафоров ядра
• SEM_STAT_ANY — возвращение Seminfo структура с той же информацией, что и SEM_STAT но sem_perm.mode не проверяется разрешение на чтение
• ПОЛУЧИТЬ ВСЕ — возвращение семвал для всех семафоров в наборе, указанном полусухой в arg.array
• GETNCNT — возвращаемое значение Semncnt для семафора набора, индексированного семя
• GETPID — возвращаемое значение семпид для семафора набора, индексированного семя
• ПОЛУЧИТЬ — возвращаемое значение семвал для семафора набора, индексированного семя
• GETZCNT — возвращаемое значение semzcnt для семафора набора, индексированного семя
• УСТАНОВИТЬ — установить semval для всех семафоров, установленных с помощью arg.array
• SETVAL — установить значение семвал к arg.val для семафора набора, индексированного семя

шмдт

Отсоединить сегмент разделяемой памяти, на который ссылается Shmaddr.

int шмдт(constпустота*Shmaddr)

• Shmaddr — адрес сегмента разделяемой памяти для отсоединения

В случае успеха вернуть ноль.

msgget

Получить идентификатор очереди сообщений System V.

int msgget(key_t ключ,int msgflg)

• ключ — идентификатор очереди сообщений
• msgflg — если IPC_CREAT и IPC_EXCL указаны и существует очередь для ключа, то msgget не выполняется с ошибкой возврата, установленной на EEXIST

Идентификатор очереди возврата сообщений.

msgsnd

Отправить сообщение в очередь сообщений System V.

int msgsnd(int msqid,constпустота*msgp,size_t msgsz,int msgflg)

• msqid — идентификатор очереди сообщений
• msgp — указатель на msgbuf структура
• msgsz — размер msgbuf структура
• msgflg — флаги, определяющие конкретное поведение

struct msgbuf {длинный mtype; / * тип сообщения, должен быть больше нуля * / char mtext [1]; / * текст сообщения * / };

Возвращает ноль в случае успеха или иным образом изменено пользователем. msgflg.

msgflg

• IPC_NOWAIT — немедленно возвращать, если в очереди нет сообщения запрошенного типа
• MSG_EXCEPT — использовать с msgtyp > 0, чтобы прочитать первое сообщение в очереди с типом, отличным от msgtyp
• MSG_NOERROR — обрезать текст сообщения, если он длиннее, чем msgsz байты

msgrcv

Получение сообщения из системной очереди сообщений V.

ssize_t msgrcv(int msqid,пустота*msgp,size_t msgsz,долго msgtyp,int msgflg)

• msqid — идентификатор очереди сообщений
• msgp — указатель на msgbuf структура
• msgsz — размер msgbuf структура
• msgtyp — прочитать первое сообщение, если 0, прочитать первое сообщение msgtyp если> 0, или если отрицательное, прочитать первое сообщение в очереди с типом меньше или равным абсолютному значению msgtyp
• msgflg — флаги, определяющие конкретное поведение

struct msgbuf {длинный mtype; / * тип сообщения, должен быть больше нуля * / char mtext [1]; / * текст сообщения * / };

Возвращает ноль в случае успеха или иным образом изменено пользователем. msgflg.

msgctl

Управление сообщениями System V.

int msgctl(int msqid,int cmd,структура msqid_ds *бух)

• msqid — идентификатор очереди сообщений
• cmd — команда на выполнение
• бух — указатель на буфер, оформленный в msqid_ds

struct msqid_ds {struct ipc_perm msg_perm; / * владение / разрешения * / time_t msg_stime; / * время последнего сообщения msgsnd (2) * / time_t msg_rtime; / * последнее время msgrcv (2) * / time_t msg_ctime; / * время последнего изменения * / unsigned long __msg_cbytes; / * байты в очереди * / msgqnum_t msg_qnum; / * сообщения в очереди * / msglen_t msg_qbytes; / * максимальное количество байтов в очереди pid_t msg_lspid; / * PID последнего сообщения msgsnd (2) * / pid_t msg_lrpid; / * PID последнего msgrcv (2) * / };

struct msginfo {int msgpool; / * Кб используемого буферного пула * / int msgmap; / * максимальное количество записей в карте сообщений * / int msgmax; / * максимальное количество байтов на одно сообщение * / int msgmnb; / * максимальное количество байтов в очереди * / int msgmni; / * максимальное количество очередей сообщений * / int msgssz; / * размер сегмента сообщения * / int msgtql; / * максимальное количество сообщений в очередях * / unsigned short int msgseg; / * максимальное количество неиспользуемых сегментов в ядре * / };

Возвращает ноль при измененном возвращаемом значении преемника на основе cmd.

cmd

• IPC_STAT — скопировать структуру данных из ядра с помощью msqid в msqid_ds структура, на которую ссылается бух
• IPC_SET — Обновить msqid_ds структура, на которую ссылается бух в ядро, обновив его msg_ctime
• IPC_RMID — удалить очередь сообщений
• IPC_INFO — возвращает информацию об ограничениях очереди сообщений в msginfo структура, на которую ссылается бух
• MSG_INFO — такой же как IPC_INFO Кроме msginfo структура наполнена использованием vs. статистика максимального использования
• MSG_STAT — такой же как IPC_STAT Кроме msqid указатель на внутренний массив ядра

fcntl

Управляйте файловым дескриптором.

int fcntl(int fd,int cmd,… / * аргумент * /)

• fd — дескриптор файла
• cmd — флаг cmd
• / * аргумент * / — дополнительные параметры на основе cmd

Возвращаемое значение зависит от cmd флаги.

cmd

Параметры в () необязательный / * аргумент * / с указанным типом.

• F_DUPFD — найти дескриптор файла с наименьшим номером, больший или равный (int) и продублируйте его, вернув новый дескриптор файла
• F_DUPFD_CLOEXEC — такой же как F_DUPFD но устанавливает флаг закрытия при запуске
• F_GETFD — вернуть флаги дескриптора файла
• F_SETFD — установить флаги файлового дескриптора на основе (int)
• F_GETFL — получить режим доступа к файлам
• F_SETFL — установить режим доступа к файлам на основе (int)
• F_GETLK — получить блокировку записей в файле (указатель на struct flock)
• F_SETLK — установить блокировку файла (указатель на struct flock)
• F_SETLKW — установить блокировку файла с ожиданием (указатель на struct flock)
• F_GETOWN — получение идентификатора процесса возврата SIGIO и СИГУРГ
• F_SETOWN — установить идентификатор процесса для получения SIGIO и СИГУРГ (int)
• F_GETOWN_EX — вернуть настройки владельца дескриптора файла (структура f_owner_ex *)
• F_SETOWN_EX — прямые сигналы ввода-вывода на файловый дескриптор (структура f_owner_ex *)
• F_GETSIG — ответный сигнал отправляется, когда IO доступен
• F_SETSIG — установить сигнал, отправляемый, когда IO доступен (int)
• F_SETLEASE — получить в аренду файловый дескриптор (int), где arg — F_RDLCK, F_WRLCK, и F_UNLCK
• F_GETLEASE — получить текущую аренду файлового дескриптора (F_RDLCK, F_WRLCK, или F_UNLCK возвращаются)
• F_NOTIFY — уведомлять, когда каталог, на который ссылается файловый дескриптор, изменяется (int) (DN_ACCESS, DN_MODIFY, DN_CREATE, DN_DELETE, DN_RENAME, DN_ATTRIB возвращаются)
• F_SETPIPE_SZ — изменить размер канала, на который ссылается файловый дескриптор, на (int) байты
• F_GETPIPE_SZ — получить размер канала, на который ссылается файловый дескриптор

стадо

struct flock {... короткий l_type; / * тип блокировки: F_RDLCK, F_WRLCK или F_UNLCK * / short l_whence; / * интерпретировать l_start с помощью SEEK_SET, SEEK_CUR или SEEK_END * / off_t l_start; / * смещение для блокировки * / off_t l_len; / * байты для блокировки * / pid_t l_pid; / * PID процесса блокировки (только F_GETLK) * /... }; 

f_owner_ex

struct f_owner_ex {тип int; pid_t pid; }; 

стадо

Применить или снять рекомендательную блокировку открытого файла

int стадо(int fd,int операция)

• fd — дескриптор файла
• операция — флаг оператора

В случае успеха возвращает ноль.

операция

• LOCK_SH — поставить общий замок
• LOCK_EX — поставить эксклюзивный замок
• LOCK_UN — удалить существующую блокировку

fsync

Синхронизируйте данные файла и метаданные в памяти с диском, очищая все буферы записи и завершая ожидающие операции ввода-вывода.

int fsync(int fd)

• fd — дескриптор файла

В случае успеха возвращает ноль.

fdatasync

Синхронизировать данные файла (но не метаданные, если они не нужны) на диск.

int fdatasync(int fd)

• fd — дескриптор файла

В случае успеха возвращает ноль.

обрезать

Обрезать файл до определенной длины.

int обрезать(constchar*дорожка,off_t длина)

• дорожка — указатель на путь к файлу
• длина — длина для усечения

В случае успеха возвращает ноль.

ftruncate

Обрезать файловый дескриптор до определенной длины.

int ftruncate(int fd,off_t длина)

• fd — дескриптор файла
• длина — длина для усечения

В случае успеха возвращает ноль.

Гетденты

Получить записи каталога из указанного файлового дескриптора.

int Гетденты(беззнаковыйint fd,структура linux_dirent *гадить,беззнаковыйint считать)

• fd — файловый дескриптор каталога
• гадить — указатель на linux_dirent структура для получения возвращаемых значений
• считать — размер гадить буфер

Возвращает байты, прочитанные в случае успеха.

struct linux_dirent {беззнаковое длинное d_ino; / * номер inode * / unsigned long d_off; / * смещение до следующего linux_dirent * / unsigned short d_reclen; / * длина этого linux_dirent * / char d_name []; / * имя файла (завершается нулем) * / char pad; / * байт заполнения * / char d_type; / * тип файла (см. типы ниже) * / }

типы

• DT_BLK — блочное устройство
• DT_CHR — зарядное устройство
• DT_DIR — справочник
• DT_FIFO — Именованный канал FIFO
• DT_LNK — символическая ссылка
• DT_REG — обычный файл
• DT_SOCK — сокет UNIX
• DT_UNKNOWN — неизвестный

getcwd

Получить текущий рабочий каталог

char*getcwd(char*бух,size_t размер)

• бух — указатель на буфер для приема пути
• размер — размер бух

Возвращает указатель на строку, содержащую текущий рабочий каталог.

чдир

Измените текущий каталог.

int чдир(constchar*дорожка)

• дорожка — указатель на строку с именем пути

В случае успеха возвращает ноль.

fchdir

Перейдите в текущий каталог, указанный в указанном дескрипторе файла.

int fchdir(int fd)

• fd — дескриптор файла

В случае успеха возвращает ноль.

переименовать

Переименуйте или переместите файл.

• старый путь — указатель на строку со старым путем / именем
• новый путь — указатель на строку с новым путем / именем

В случае успеха возвращает ноль.

mkdir

Сделайте каталог.

int mkdir(constchar*путь, mode_t режим)

• путь — указатель на строку с именем каталога
• Режим — режим разрешений файловой системы

В случае успеха возвращает ноль.

rmdir

Удалить каталог.

int rmdir(constchar*путь)

• путь — указатель на строку с именем каталога

В случае успеха возвращает ноль.

Creat

Создайте файл или устройство.

int Creat(constchar*путь, mode_t режим)

• путь — указатель на строку с именем файла или устройства
• Режим — режим разрешений файловой системы

В случае успеха возвращает дескриптор файла.

Создает жесткую ссылку на файл.

int ссылка на сайт(constchar*старый путь,constchar*новый путь)

• старый путь — указатель на строку со старым именем файла
• новый путь — указатель на строку с новым именем файла

В случае успеха возвращает ноль.

Удалить файл.

int разорвать связь(constchar*путь)

• путь — указатель на строку с именем пути

В случае успеха вернуть ноль.

Создайте символическую ссылку.

int символическая ссылка(constchar*старый путь,constchar*новый путь)

• старый путь — указатель на строку со старым именем пути
• новый путь — указатель на строку с новым именем пути

В случае успеха вернуть ноль.

Вернуть имя символьной ссылки.

ssize_t ссылка для чтения(constchar*дорожка,char*бух,size_t Bufsiz)

• дорожка — указатель на строку с именем символической ссылки
• бух — указатель на буфер с результатом
• Bufsiz — размер буфера для результата

Возвращает количество байтов, помещенных в бух.

chmod

Установите разрешение для файла или устройства.

int chmod(constchar*дорожка, mode_t режим)

• дорожка — указатель на строку с именем файла или устройства
• Режим — новый режим разрешений

В случае успеха возвращает ноль.

fchmod

Такой же как chmod но устанавливает разрешения для файла или устройства, на которые ссылается файловый дескриптор.

int fchmod(int fd, mode_t режим)

• fd — дескриптор файла
• Режим — новый режим разрешений

В случае успеха возвращает ноль.

Chown

Измените владельца файла или устройства.

int Chown(constchar*дорожка, uid_t владелец, группа gid_t)

• дорожка — указатель на строку с именем файла или устройства
• владелец — новый владелец файла или устройства
• группа — новая группа файла или устройства

В случае успеха возвращает ноль.

Fchown

Такой же как Chown но устанавливает владельца и группу для файла или устройства, на которые ссылается файловый дескриптор.

int Fchown(int fd, uid_t владелец, группа gid_t)

• fd — дескриптор файла
• владелец — новый владелец
• группа — новая группа

В случае успеха возвращает ноль.

lchown

Такой же как Chown но не ссылается на символические ссылки.

int lchown(constchar*дорожка, uid_t владелец, группа gid_t)

• дорожка — указатель на строку с именем файла или устройства
• владелец — новый владелец
• группа — новая группа

В случае успеха возвращает ноль.

маска

Устанавливает маску, используемую для создания новых файлов.

mode_t umask(mode_t маска)

• маска — маска для новых файлов

Системный вызов всегда будет успешным и вернет предыдущую маску.

gettimeofday

int gettimeofday(структура время *Телевизор,структура часовой пояс *tz)

• Телевизор — указатель на структуру timeval для получения времени
• tz — указатель на структуру часового пояса для получения часового пояса

struct timeval {time_t tv_sec; / * секунды * / suseconds_t tv_usec; / * микросекунды * / };

часовой пояс структуры {int tz_minuteswest; / * минуты к западу от GMT * / int tz_dsttime; / * Тип коррекции летнего времени * / };

В случае успеха возвращает ноль.

getrlimit

Получите текущие ограничения ресурсов.

int getrlimit(int ресурс,структура rlimit *Rlim)

• ресурс — флаг ресурса
• Rlim — указатель на структуру rlimit

struct rlimit {rlim_t rlim_cur; / * мягкий лимит * / rlim_t rlim_max; / * жесткий лимит * / };

Возвращает ноль в случае успеха и заполняет Rlim структура с результатами.

флаги ресурсов

• RLIMIT_AS — максимальный размер виртуальной памяти процесса
• RLIMIT_CORE — максимальный размер основного файла
• RLIMIT_CPU — максимальное время процессора, в секундах
• RLIMIT_DATA — максимальный размер сегмента данных процесса
• RLIMIT_FSIZE — максимальный размер файлов, которые разрешено создавать процессу
• RLIMIT_LOCKS — Макс стадо и fcntl аренда разрешена
• RLIMIT_MEMLOCK — максимальное количество байтов ОЗУ, разрешенное для блокировки
• RLIMIT_MSGQUEUE — максимальный размер очередей сообщений POSIX
• RLIMIT_NICE — максимальное значение nice
• RLIMIT_NOFILE — максимальное количество файлов, разрешенных для открытия, плюс один
• RLIMIT_NPROC — максимальное количество процессов или потоков
• RLIMIT_RSS — максимальное количество резидентных страниц
• RLIMIT_RTPRIO — потолок приоритета в реальном времени
• RLIMIT_RTTIME — ограничение в микросекундах планирования ЦП в реальном времени
• RLIMIT_SIGPENDING — максимальное количество сигналов в очереди
• RLIMIT_STACK — максимальный размер стека процессов

Getrusage

Получите использование ресурсов.

int Getrusage(int ВОЗ,структура ржавчина *использование)

• ВОЗ — целевой флаг
• использование — указатель на ржавчина структура

struct rusage {struct timeval ru_utime; / * используемое процессорное время пользователя * / struct timeval ru_stime; / * используемое процессорное время системы * / long ru_maxrss; / * максимальный RSS * / long ru_ixrss; / * размер разделяемой памяти * / long ru_idrss; / * размер неразделенных данных * / long ru_isrss; / * размер неразделенного стека * / long ru_minflt; / * программные ошибки страницы * / long ru_majflt; / * аппаратные ошибки страницы * / long ru_nswap; / * свопы * / long ru_inblock; / * блокировать операции ввода * / long ru_oublock; / * блокировать операции вывода * / long ru_msgsnd; / * отправлено # сообщений IPC * / long ru_msgrcv; / * получено # сообщений IPC * / long ru_nsignals; / * количество полученных сигналов * / long ru_nvcsw; / * произвольное переключение контекста * / long ru_nivcsw; / * непроизвольное переключение контекста * / };

В случае успеха возвращает ноль.

кто нацелен

• RUSAGE_SELF — получить статистику использования для вызывающего процесса
• RUSAGE_CHILDREN — получить статистику использования для всех дочерних процессов вызывающего процесса
• RUSAGE_THREAD — получить статистику использования для вызывающего потока

sysinfo

Вернуть информацию о системе.

int sysinfo(структура sysinfo *Информация)

• Информация — указатель на sysinfo структура

struct sysinfo {длительное время безотказной работы; / * секунды с момента загрузки * / беззнаковые длинные загрузки [3]; / * Средняя загрузка 1/5/15 минут * / длинная беззнаковая totalram; / * общий объем используемой памяти * / длинная свободная память без знака; / * доступная память * / unsigned long sharedram; / * объем разделяемой памяти * / unsigned long bufferram; / * использование буферной памяти * / unsigned long totalswap; / * размер области подкачки * / unsigned long freeswap; / * доступное пространство подкачки * / unsigned short procs; / * общее количество текущих процессов * / unsigned long totalhigh; / * общий максимальный размер памяти * / unsigned long freehigh; / * доступный большой объем памяти * / unsigned int mem_unit; / * размер блока памяти в байтах * / char _f [20-2 * sizeof (long) -sizeof (int)]; / * заполнение до 64 байтов * / };

Возвращает ноль в случае успеха и помещает системную информацию в sysinfo структура.

раз

Получите время обработки.

clock_t раз(структура tms *бух)

• бух — указатель на tms структура

struct tms {clock_t tms_utime; / * пользовательское время * / clock_t tms_stime; / * системное время * / clock_t tms_cutime; / * дочернее пользовательское время * / clock_t tms_cstime; / * дочернее системное время * / };

Возвращает такты часов с произвольной точки в прошлом и может переполниться. tms структура наполнена ценностями.

ptrace

Отслеживайте процесс.

долго ptrace(перечислить __ptrace_request запрос, pid_t pid,пустота*адрес,пустота*данные)

• запрос — определить тип трассировки для выполнения
• пид — идентификатор процесса для отслеживания
• адрес — указатель на буфер для определенных значений ответа
• данные — указатель на буфер, используемый в некоторых типах трасс

По запросу возвращает ноль, помещая данные трассировки в адрес и / или данные, в зависимости от деталей трассировки во флагах запроса.

флаги запроса

• PTRACE_TRACEME — указать процесс, отслеживаемый родителем
• PTRACE_PEEKTEXT и PTRACE_PEEKDATA — прочитать слово на адрес и вернуться в результате звонка
• PTRACE_PEEKUSER — прочитать слово на адрес в ПОЛЬЗОВАТЕЛЬ область памяти отслеживаемого процесса
• PTRACE_POKETEXT и PTRACE_POKEDATA — копировать данные в адрес в памяти отслеживаемого процесса
• PTRACE_POKEUSER — копировать данные в адрес в отслеживаемом процессе ПОЛЬЗОВАТЕЛЬ область в памяти
• PTRACE_GETREGS — копировать общие регистры отслеживаемой программы в данные
• PTRACE_GETFPREGS — копировать регистры с плавающей запятой отслеживаемой программы в данные
• PTRACE_GETREGSET — читать регистры отслеживаемой программы архитектурно-независимым способом
• PTRACE_SETREGS — изменять общие регистры отслеживаемой программы
• PTRACE_SETFPREGS — изменить регистры с плавающей запятой отслеживаемой программы
• PTRACE_SETREGSET — изменять регистры отслеживаемой программы (архитектурно-независимый)
• PTRACE_GETSIGINFO — получить информацию о сигнале, вызвавшем остановку siginfo_t структура
• PTRACE_SETSIGINFO — установить информацию о сигнале путем копирования siginfo_t структура из данные в отслеживаемую программу
• PTRACE_PEEKSIGINFO — получать siginfo_t структуры без удаления сигналов в очереди
• PTRACE_GETSIGMASK — скопировать маску заблокированных сигналов в данные который будет sigset_t структура
• PTRACE_SETSIGMASK — изменить маску заблокированных сигналов на значение в данные который должен быть sigset_t структура
• PTRACE_SETOPTIONS — установить параметры из данные, куда данные это битовая маска следующих опций:
  • PTRACE_O_EXITKILL — Отправить СИГКИЛЛ в отслеживаемую программу, если программа отслеживания существует
  • PTRACE_O_TRACECLONE — остановить отслеживаемую программу на следующем клон syscall и начать отслеживать новый процесс
  • PTRACE_O_TRACEEXEC — остановить отслеживаемую программу на следующем Execve системный вызов
  • PTRACE_O_TRACEEXIT — остановить отслеживаемую программу при выходе
  • PTRACE_O_TRACEFORK— остановить отслеживаемую программу на следующем вилка и начать отслеживать разветвленный процесс
  • PTRACE_O_TRACESYSGOOD — установить бит 7 в номере сигнала (SIGTRAP | 0x80) при отправке ловушек системных вызовов
  • PTRACE_O_TRACEVFORK — остановить отслеживаемую программу на следующем vfork и начать отслеживать новый процесс
  • PTRACE_O_TRACEVFORKDONE — остановить отслеживаемую программу после следующей vfork
  • PTRACE_O_TRACESECCOMP — остановить отслеживаемую программу, когда seccomp правило срабатывает
  • PTRACE_O_SUSPEND_SECCOMP — приостановить защиту seccomp отслеживаемой программы
• PTRACE_GETEVENTMSG — получить сообщение о последних ptrace событие и положить в данные программы розыска
• PTRACE_CONT — перезапустить отслеживаемый процесс, который был остановлен и если данные не равно нулю, отправьте ему номер сигнала
• PTRACE_SYSCALL и PTRACE_SIGNELSTEP — перезапустить отслеживаемый процесс, который был остановлен, но остановится при входе или выходе из следующего системного вызова
• PTRACE_SYSEMU — продолжить, затем остановиться при входе для следующего системного вызова (но не выполнять его)
• PTRACE_SYSEMU_SINGLESTEP — такой же как PTRACE_SYSEMU но один шаг, если инструкция не является системным вызовом
• PTRACE_LISTEN — перезапустить отслеживаемую программу, но запретить выполнение (аналогично SIGSTOP)
• PTRACE_INTERRUPT — остановить отслеживаемую программу
• PTRACE_ATTACH — прикрепить к процессу пид
• PTRACE_SEIZE прикрепить к процессу пид но не останавливай процесс
• PTRACE_SECCOMP_GET_FILTER — позволяет выводить классические фильтры BPF трассируемой программы, где адрес индекс фильтра и данные указатель на структуру sock_filter
• PTRACE_DETACH — отсоединить и перезапустить остановленную отслеживаемую программу
• PTRACE_GET_THREAD_AREA — читает запись TLS в GDT с индексом, указанным адрес, размещение копии структуры user_desc в данные
• PTRACE_SET_THREAD_AREA — устанавливает запись TLS в GTD с индексом, указанным адрес, присвоив ему структуру user_desc в данные
• PTRACE_GET_SYSCALL_INFO — получить информацию о системном вызове, вызвавшем остановку и размещение структуры ptrace_syscall_info в данные, куда адрес размер буфера

struct ptrace_peeksiginfo_args {u64 off; / * позиция в очереди для начала копирования сигналов * / u32 flags; / * PTRACE_PEEKSIGINFO_SHARED или 0 * / s32 nr; / * количество сигналов для копирования * / };

struct ptrace_syscall_info {__u8 op; / * тип остановки системных вызовов * / __u32 arch; / * AUDIT_ARCH_ * значение * / __u64struction_pointer; / * Указатель инструкции процессора * / __u64 stack_pointer; / * Указатель стека ЦП * / union {struct {/ * op == PTRACE_SYSCALL_INFO_ENTRY * / __u64 nr; / * номер системного вызова * / __u64 args [6]; / * аргументы системного вызова * /} запись; struct {/ * op == PTRACE_SYSCALL_INFO_EXIT * / __s64 rval; / * возвращаемое значение системного вызова * / __u8 is_error; / * флаг ошибки системного вызова * /} exit; struct {/ * op == PTRACE_SYSCALL_INFO_SECCOMP * / __u64 nr; / * номер системного вызова * / __u64 args [6]; / * аргументы системного вызова * / __u32 ret_data; / * SECCOMP_RET_DATA часть возвращаемого значения SECCOMP_RET_TRACE * /} seccomp; }; }; 

Getuid

Получить UID вызывающего процесса.

uid_t getuid(пустота)

Возвращает UID. Всегда получается.

системный журнал

Прочитать или очистить буфер сообщений ядра.

int системный журнал(int тип,char*bufp,int len)

• тип — функция для выполнения
• bufp — указатель на буфер (используется для чтения)
• len — длина буфера

Возвращает прочитанные байты, доступные для чтения, общий размер буфера ядра или 0, в зависимости от флага типа.

тип флаг

• SYSLOG_ACTION_READ — читать len байт сообщений ядра регистрируются в bufp, возвращает количество прочитанных байтов
• SYSLOG_ACTION_READ_ALL — прочитать весь журнал сообщений ядра в bufp, чтение последнее len байты из ядра, возвращающие прочитанные байты
• SYSLOG_ACTION_READ_CLEAR — прочтите, затем очистите журнал сообщений ядра в bufp, вплоть до len байтов, возвращая прочитанные байты
• SYSLOG_ACTION_CLEAR — очистить буфер журнала сообщений ядра, в случае успеха возвращает ноль
• SYSLOG_ACTION_CONSOLE_OFF — предотвращает отправку сообщений ядра на консоль
• SYSLOG_ACTION_CONSOLE_ON — разрешает отправку сообщений ядра на консоль
• SYSLOG_ACTION_CONSOLE_LEVEL — устанавливает уровень журнала сообщений (значения от 1 до 8 через len), чтобы разрешить фильтрацию сообщений
• SYSLOG_ACTION_SIZE_UNREAD — возвращает количество байтов, доступных для чтения в журнале сообщений ядра
• SYSLOG_ACTION_SIZE_BUFFER — возвращает размер буфера сообщений ядра

Getgid

Получить GID вызывающего процесса.

gid_t getgid(пустота)

Возвращает GID. Всегда получается.

Setuid

Установить UID вызывающего процесса.

int Setuid(uid_t uid)

• uid — новый UID

В случае успеха возвращает ноль.

сетгид

Установить GID вызывающего процесса.

int сетгид(gid_t gid)

• гид — новый GID

В случае успеха возвращает ноль.

geteuid

Получите эффективный UID вызывающего процесса.

uid_t geteuid(пустота)

Возвращает эффективный UID. Всегда получается.

Getegid

Получите эффективный GID вызывающего процесса.

gid_t getegid(пустота)

Возвращает действующий GID. Всегда получается.

setpgid

Установите идентификатор группы процессов для процесса.

int setpgid(pid_t pid, pid_t pgid)

• пид — идентификатор процесса
• pgid — идентификатор группы процессов

В случае успеха возвращает ноль.

Getppid

Получить идентификатор группы процессов для процесса.

pid_t getpgid(pid_t pid)

• пид — идентификатор процесса

Возвращает идентификатор группы процессов.

getpgrp

Получить идентификатор группы процессов вызывающего процесса.

pid_t getpgrp(пустота)

Вернуть идентификатор группы процесса.

SetSid

Создайте сеанс, если вызывающий процесс не является лидером группы процессов.

pid_t setsid(пустота)

Возвращает созданный идентификатор сеанса.

Setreuid

Установите реальный и эффективный UID для вызывающего процесса.

int Setreuid(uid_t ruid, uid_t euid)

• руд — настоящий UID
• euid — эффективный UID

В случае успеха возвращает ноль.

Setregid

Установите реальный и эффективный GID для вызывающего процесса.

int Setregid(gid_t rgid, gid_t egid)

• rgid — настоящий GID
• egid — эффективный GID

В случае успеха возвращает ноль.

getgroups

Получите список дополнительных идентификаторов групп для вызывающего процесса.

int getgroups(int размер, список gid_t[])

• размер — размер массива список
• список — массив gid_t получить список

Возвращает количество идентификаторов дополнительных групп, возвращенных в список.

setgroups

Установить список идентификаторов дополнительных групп для вызывающего процесса.

int setgroups(size_t размер,const gid_t *список)

• размер — размер массива список
• список — массив gid_t установить список

В случае успеха возвращает ноль.

Setresuid

Устанавливает реальный, эффективный и сохраненный UID.

int Setresuid(uid_t ruid, uid_t euid, uid_t suid)

• руд — настоящий UID
• euid — эффективный UID
• Suid — сохраненный UID

В случае успеха возвращает ноль.

Сетресгид

Устанавливает реальный, эффективный и сохраненный GID.

int Сетресгид(gid_t rgid, gid_t egid, gid_t sgid)

• rgid — настоящий GID
• egid — эффективный GID
• SGID — сохраненный GID

В случае успеха возвращает ноль.

getresuid

Получите реальный, эффективный и сохраненный UID.

int getresuid(uid_t *руд, uid_t *euid, uid_t *Suid)

• руд — настоящий UID
• euid — эффективный UID
• Suid — сохраненный UID

В случае успеха возвращает ноль.

Getresgid

Получите настоящий, эффективный и сохраненный GID.

int getresuid(gid_t *rgid, gid_t *egid, gid_t *SGID)

• rgid — настоящий GID
• egid — эффективный GID
• SGID — сохраненный GID

В случае успеха возвращает ноль.

getpgid

Получить идентификатор группы процессов для процесса.

pid_t getpgid(pid_t pid)

• пид — идентификатор процесса

Возвращает идентификатор группы процессов.

setfsuid

Установите UID для проверки файловой системы.

int setfsuid(uid_t fsuid)

Всегда возвращает предыдущий UID файловой системы.

setfsgid

Установите GID для проверки файловой системы.

int setfsgid(uid_t fsgid)

Всегда возвращает GID предыдущей файловой системы.

Getid

Получите идентификатор сеанса.

pid_t getsid(pid_t pid)

Возвращает идентификатор сеанса.

Capget

Получите возможности потока.

int Capget(cap_user_header_t hdrp, cap_user_data_t карта данных)

• HDRP — структура заголовка возможности
• карта данных — структура данных о возможностях

typedef struct __user_cap_header_struct {__u32 version; int pid; } * cap_user_header_t; 

typedef struct __user_cap_data_struct {__u32 эффективный; __u32 разрешено; __u32 наследуемый; } * cap_user_data_t; 

В случае успеха возвращает ноль.

капсет

Установите возможности потока.

int капсет(cap_user_header_t hdrp,const cap_user_data_t карта данных)

• HDRP — структура заголовка возможности
• карта данных — структура данных о возможностях

typedef struct __user_cap_header_struct {__u32 version; int pid; } * cap_user_header_t; 

typedef struct __user_cap_data_struct {__u32 эффективный; __u32 разрешено; __u32 наследуемый; } * cap_user_data_t; 

В случае успеха возвращает ноль.

rt_sigpending

Набор сигналов возврата, ожидающих доставки в вызывающий процесс или поток.

int знак(sigset_t *задавать)

• задавать — указатель на sigset_t структура для получения маски сигналов.

rt_sigtimedwait

Приостановить выполнение (до тайм-аут) вызывающего процесса или потока до тех пор, пока не появится сигнал, указанный в задавать находится на рассмотрении.

int sigtimedwait(const sigset_t *задавать, siginfo_t *Информация,constструктура время *тайм-аут)

• задавать — указатель на sigset_t структура для определения сигналов ожидания
• Информация — если не ноль, указатель на siginfo_t структура с информацией о сигнале
• тайм-аут — а время структура, устанавливающая максимальное время ожидания перед возобновлением выполнения

struct timespec {long tv_sec; / * время в секундах * / long tv_nsec; / * время в наносекундах * / }

rt_sigqueueinfo

Поставьте сигнал в очередь.

int rt_sigqueueinfo(pid_t tgid,int сиг, siginfo_t *Информация)

• tgid — идентификатор группы потоков
• сиг — сигнал для отправки
• Информация — указатель на структуру siginfo_t

В случае успеха возвращает ноль.

rt_sigsuspend

Ждите сигнала.

int sigsuspend(const sigset_t *маска)

• маска — указатель на sigset_t структура (определена в подписание)

Всегда возвращается с -1.

сигальтовая стопка

Установить / получить контекст стека сигналов.

int сигальтовая стопка(const stack_t *SS, stack_t *осс)

• SS — указатель на stack_t структура, представляющая новый стек сигналов
• осс — указатель на stack_t структура, используемая для получения информации о текущем стеке сигналов

typedef struct {void * ss_sp; / * базовый адрес стека * / int ss_flags; / * флаги * / size_t ss_size; / * байты в стеке * / } stack_t;

В случае успеха возвращает ноль.

время

Измените время последнего доступа и модификации файла.

int время(constchar*имя файла,constструктура утимбуф *раз)

• имя файла — указатель на строку с именем файла
• раз — указатель на структуру утимбуф структура

struct utimbuf {time_t actime; / * время доступа * / time_t modtime; / * время модификации * / };

В случае успеха возвращает ноль.

mknod

Создайте специальный файл (обычно используется для файлов устройства).

int mknod(constchar*путь, mode_t режим, dev_t dev)

• путь — указатель на строку с полным путем к создаваемому файлу
• Режим — разрешения и тип файла
• разработчик — номер устройства

В случае успеха возвращает ноль.

uselib

Загрузите общую библиотеку.

int uselib(constchar*библиотека)

• библиотека — указатель на строку с полным путем к файлу библиотеки

В случае успеха вернуть ноль.

личность

Установить домен выполнения процесса (личность)

int личность(беззнаковыйдолго персона)

• персона — домен персонажа

Возвращает предыдущий персонаж в случае успеха, если персона установлен на 0xFFFFFFFF.

устат

Получить статистику файловой системы

int устат(dev_t dev,структура устат *убуф)

• разработчик — номер устройства с смонтированной файловой системой
• убуф — указатель на устат структура для возвращаемых значений

struct ustat {daddr_t f_tfree; / * свободные блоки * / ino_t f_tinode; / * свободные inodes * / char f_fname [6]; / * имя файловой системы * / char f_fpack [6]; / * имя пакета файловой системы * / };

Возвращает ноль в случае успеха и устат структура, на которую ссылается убуф наполнен статистикой.

statfs

Получите статистику файловой системы.

int statfs(constchar*дорожка,структура statfs *бух)

• дорожка — указатель на строку с именем любого файла в смонтированной файловой системе
• бух — указатель на statfs структура

struct statfs {__SWORD_TYPE f_type; / * тип файловой системы * / __SWORD_TYPE f_bsize; / * оптимальный размер блока передачи * / fsblkcnt_t f_blocks; / * всего блоков * / fsblkcnt_t f_bfree; / * свободные блоки * / fsblkcnt_t f_bavail; / * бесплатные блоки доступны непривилегированному пользователю * / fsfilcnt_t f_files; / * общее количество файловых узлов * / fsfilcnt_t f_ffree; / * свободные файловые узлы * / fsid_t f_fsid; / * идентификатор файловой системы * / __SWORD_TYPE f_namelen; / * максимальная длина имен файлов * / __SWORD_TYPE f_frsize; / * размер фрагмента * / __SWORD_TYPE f_spare [5]; }; 

В случае успеха возвращает ноль.

fstatfs

Работает так же, как statfs except предоставляет статистику файловой системы через файловый дескриптор.

int fstatfs(int fd,структура statfs *бух)

• fd — дескриптор файла
• бух — указатель на statfs структура

В случае успеха возвращает ноль.

sysfs

Получить информацию о типе файловой системы.

int sysfs (параметр int, const char * fsname) int sysfs (параметр int, unsigned int fs_index, char * buf) int sysfs (параметр int)

• вариант — при установке на 3, возвращает количество типов файловой системы в ядре или может быть 1 или 2 как указано ниже
• fsname — указатель на строку с именем файловой системы (установить вариант к 1)
• fs_index — индексировать строку идентификатора файловой системы с завершающим нулем, записанную в буфер по адресу бух (задавать вариант к 2)
• бух — указатель на буфер

Возвращает индекс файловой системы, когда вариант является 1, ноль для 2, и количество типов файловых систем в ядре для 3.

получить приоритет

Получите приоритет процесса.

int получить приоритет(int который,int ВОЗ)

• который — флаг, определяющий, какой приоритет получить
• ВОЗ — PID процесса

Возвращает приоритет указанного процесса.

который

• PRIO_PROCESS — процесс
  * PRIO_PGRP — группа процессов
• PRIO_USER — Логин пользователя

Установить приоритет

Установите приоритет процесса.

int Установить приоритет(int который,int ВОЗ,int прио)

• который — флаг, определяющий, какой приоритет установить
• ВОЗ — PID процесса
• прио — значение приоритета (-20 к 19)

В случае успеха возвращает ноль.

sched_setparam

Установите параметры планирования процесса.

int sched_setparam(pid_t pid,constструктура sched_param *парам)

• пид — PID процесса
• парам — указатель на sched_param структура

В случае успеха возвращает ноль.

sched_getparam

int sched_getparam(pid_t pid,структура sched_param *парам)

• пид — PID процесса
• парам — указатель на sched_param структура

В случае успеха возвращает ноль.

sched_setscheduler

Установите параметры планирования для процесса.

int sched_setscheduler(pid_t pid,int политика,constструктура sched_param *парам)

• пид — PID процесса
• политика — флаг политики
• парам — указатель на sched_param структура

В случае успеха возвращает ноль.

политика

• SCHED_OTHER — стандартная циклическая политика разделения времени
• SCHED_FIFO — политика планирования в порядке очереди
• SCHED_BATCH — выполняет процессы в пакетном режиме
• SCHED_IDLE — означает, что процесс будет установлен на низкий приоритет (фон)

sched_getscheduler

Получить параметры планирования для процесса.

int sched_getscheduler(pid_t pid)

• пид — PID процесса

Возврат политика флаг (см. sched_setscheduler).

sched_get_priority_max

Получите максимум статического приоритета.

int sched_get_priority_max(int политика)

• политика — флаг политики (см. sched_setscheduler)

Возвращает максимальное значение приоритета для указанной политики.

sched_get_priority_min

Получите статический приоритет минимум.

int sched_get_priority_min(int политика)

• политика — флаг политики (см. sched_setscheduler)

Возвращает минимальное значение приоритета для указанной политики.

sched_rr_get_interval

Получать SCHED_RR интервал для процесса.

int sched_rr_get_interval(pid_t pid,структура время *tp)

• пид — PID процесса
• tp — указатель на время структура

Возвращает ноль в случае успеха и заполняет tp с интервалами для пид если SCHED_RR это политика планирования.

mlock

Заблокируйте всю или часть памяти вызывающего процесса.

int mlock(constпустота*адрес,size_t len)

• адрес — указатель на начало адресного пространства
• len — длина адресного пространства для блокировки

В случае успеха возвращает ноль.

мунлок

Разблокировать всю или часть памяти вызывающего процесса.

int мунлок(constпустота*адрес,size_t len)

• адрес — указатель на начало адресного пространства
• len — длина адресного пространства для разблокировки

В случае успеха возвращает ноль.

торговый центр

Заблокируйте все адресное пространство памяти вызывающего процесса.

int торговый центр(int флаги)

• флаги — флаги, определяющие дополнительное поведение

флаги

• MCL_CURRENT — заблокировать все страницы на момент вызова этого системного вызова
• MCL_FUTURE — заблокировать все страницы, которые будут сопоставлены этому процессу в будущем
• MCL_ONFAULT — отметить все текущее (или будущее вместе с MCL_FUTURE) когда они ошибаются страницы

munlockall

Разблокировать все адресное пространство памяти вызывающего процесса.

int munlockall(пустота)

В случае успеха возвращает ноль.

Vhangup

Отправить на текущий терминал сигнал «зависнуть».

int Vhangup(пустота)

В случае успеха возвращает ноль.

modify_ldt

Чтение или запись в локальную таблицу дескрипторов для процесса

int modify_ldt(int func,пустота*ptr,беззнаковыйдолго bytecount)

• func – 0 для чтения, 1 для записи
• ptr — указатель на LDT
• bytecount — байтов для чтения или для записи, размер user_desc структура

struct user_desc {unsigned int entry_number; беззнаковый int base_addr; беззнаковый предел int; беззнаковый int seg_32bit: 1; беззнаковое int содержимое: 2; беззнаковый int read_exec_only: 1; беззнаковый int limit_in_pages: 1; беззнаковое int seg_not_present: 1; беззнаковое int пригодное для использования: 1; }; 

Возвращает прочитанные байты или ноль в случае успеха при записи.

pivot_root

Измените корневое крепление.

int pivot_root(constchar*new_root,constchar*put_old)

• new_root — указатель на строку с путем к новому монтированию
• put_old — указатель на строку с путем для старого монтирования

В случае успеха возвращает ноль.

prctl

int prctl(int вариант,беззнаковыйдолго arg2,беззнаковыйдолго arg3,беззнаковыйдолго arg4,
беззнаковыйдолго arg5)

• вариант — указать флаг операции
• arg2, arg3, arg4, и arg5 — используемые переменные в зависимости от вариант, видеть вариант флаги

вариант

• PR_CAP_AMBIENT — чтение / изменение внешней возможности вызова значения ссылки потока в arg2, в отношении:
  • PR_CAP_AMBIENT_RAISE — возможность в arg3 добавлен в окружающий набор
  • PR_CAP_AMBIENT_LOWER — возможность в arg3 удален из окружающего набора
  • PR_CAP_AMBIENT_IS_SET — возвращает 1 если возможность в arg3 находится в окружающем наборе, 0 если не
  • PR_CAP_AMBIENT_CLEAR_ALL — убрать все возможности из окружающего набора, установить arg3 к 0
• PR_CAPBSET_READ — возвращение 1 если возможность указана в arg2 вызывает набор ограничений возможностей потока, 0 если не
• PR_CAPBSET_DROP — если вызывающий поток имеет CAP_SETPCAP возможность в пространстве имен пользователя, возможность перетащить в arg2 из набора ограничений возможностей для вызывающего процесса
• PR_SET_CHILD_SUBREAPER — если arg2 не равно нулю, установить атрибут «дочерний субжатник» для вызывающего процесса, если arg2 равно нулю, не установлено
• PR_GET_CHILD_SUBREAPER — вернуть настройку «дочернего поджатка» вызывающего процесса в месте, указанном arg2
• PR_SET_DUMPABLE — установить состояние флага сброса через arg2
• PR_GET_DUMPABLE — вернуть текущий сбрасываемый флаг для вызывающего процесса
• PR_SET_ENDIAN — установить порядок байтов вызывающего процесса на arg2 через PR_ENDIAN_BIG, PR_ENDIAN_LITTLE, или PR_ENDIAN_PPC_LITTLE
• PR_GET_ENDIAN — вернуть порядковый номер вызывающего процесса в место, указанное arg2
• PR_SET_KEEPCAPS — установить состояние флага «сохранить возможности» вызывающего процесса через arg2
• PR_GET_KEEPCAPS — вернуть текущее состояние флага «сохранить возможности» вызывающего процесса
• PR_MCE_KILL — установить политику уничтожения повреждения памяти при проверке машины для вызова процесса через arg2
• PR_MCE_KILL_GET — вернуть текущую политику уничтожения проверки машины для каждого процесса
• PR_SET_MM — изменить поля дескриптора карты памяти ядра вызывающего процесса, где arg2 является одним из следующих вариантов и arg3 новое значение, которое нужно установить.
  • PR_SET_MM_START_CODE — установить адрес, над которым может запускаться текст программы
  • PR_SET_MM_END_CODE — установить адрес, ниже которого можно запускать текст программы
  • PR_SET_MM_START_DATA — установить адрес, над которым помещаются инициализированные и неинициализированные данные
  • PR_SET_MM_END_DATA — установить адрес, ниже которого помещаются инициализированные и неинициализированные данные
  • PR_SET_MM_START_STACK — установить начальный адрес стека
  • PR_SET_MM_START_BRK — установить адрес, выше которого куча программы может быть расширена с помощью BRK
  • PR_SET_MM_BRK — установить ток BRK стоимость
  • PR_SET_MM_ARG_START — установить адрес, над которым размещается командная строка
  • PR_SET_MM_ARG_END — установить адрес, под которым размещается командная строка
  • PR_SET_MM_ENV_START — установить адрес, над которым размещается окружение
  • PR_SET_MM_ENV_END — установить адрес, ниже которого помещается окружение
  • PR_SET_MM_AUXV — установить новый вектор aux, с arg3 предоставление нового адреса и arg4 содержащий размер вектора
  • PR_SET_MM_EXE_FILE — Заменить /proc/pid/exe символическая ссылка с новой, указывающей на дескриптор файла в arg3
  • PR_SET_MM_MAP — предоставить одноразовый доступ ко всем адресам, передав структуру prctl_mm_map указатель в arg3 с размером в arg4
  • PR_SET_MM_MAP_SIZE — возвращает размер prctl_mm_map структура, где arg4 это указатель на беззнаковое int
• PR_MPX_ENABLE_MANAGEMENT — включить управление ядром расширений защиты памяти
• PR_MPX_DISABLE_MANAGEMENT — отключить управление ядром расширений защиты памяти
• PR_SET_NAME — установить имя вызывающего процесса в строку с нулевым символом в конце, на которую указывает arg2
• PR_GET_NAME — получить имя вызывающего процесса в строке с завершающим нулем в буфер размером до 16 байт, на который ссылается указатель в arg2
• PR_SET_NO_NEW_PRIVS — установить атрибут no_new_privs вызывающего процесса в значение в arg2
• PR_GET_NO_NEW_PRIVS — возвращаемое значение no_new_privs для вызывающего процесса
• PR_SET_PDEATHSIG — установить родительский сигнал о смерти вызывающего процесса на arg2
• PR_GET_PDEATHSIG — вернуть значение сигнала родитель-смерть в arg2
• PR_SET_SECCOMP — установить режим «seccomp» для вызова процесса через arg2
• PR_GET_SECCOMP — получить режим вызова «seccomp»
• PR_SET_SECUREBITS — установить флаги «securebits» вызывающего потока на значение в arg2
• PR_GET_SECUREBITS — возвращать «securebits» флаги вызывающего процесса
• PR_GET_SPECULATION_CTRL — вернуть состояние спекуляции с ошибкой, указанное в arg2
• PR_SET_SPECULATION_CTRL — установить состояние ошибки спекуляции, указанное в arg2
• PR_SET_THP_DISABLE — установить состояние флага «THP disable» для вызывающего процесса
• PR_TASK_PERF_EVENTS_DISABLE — отключить все счетчики производительности для вызывающего процесса
• PR_TASK_PERF_EVENTS_ENABLE — включить счетчики производительности для вызывающего процесса
• PR_GET_THP_DISABLE — вернуть текущую настройку флага «THP disable»
• PR_GET_TID_ADDRESS — возвращение clear_child_tid адрес установлен set_tid_address
• PR_SET_TIMERSLACK — устанавливает текущее значение задержки таймера для вызывающего процесса
• PR_GET_TIMERSLACK — вернуть текущее значение задержки таймера для вызывающего процесса
• PR_SET_TIMING — установить статистическую синхронизацию процесса или точную синхронизацию процесса на основе временных меток с помощью флага в arg2 (PR_TIMING_STATISTICAL или PR_TIMING_TIMESTAMP)
• PR_GET_TIMING — метод возврата процесса синхронизации в использовании
• PR_SET_TSC — установить состояние флага, определяющего, может ли счетчик отметок времени быть прочитан процессом в arg2 (PR_TSC_ENABLE или PR_TSC_SIGSEGV)
• PR_GET_TSC — вернуть состояние флага, определяющего, может ли счетчик отметок времени быть прочитан в месте, указанном arg2

Возвращает ноль в случае успеха или значение, указанное в вариант флаг.

arch_prctl

Установите состояние потока, зависящее от архитектуры.

int arch_prctl(int код,беззнаковыйдолго адрес)

• код — определяет дополнительное поведение
• адрес или * адрес — адрес или указатель в случае операций «get»
• ARCH_SET_FS — установить 64-битную базу для регистра FS в адрес
• ARCH_GET_FS — вернуть 64-битное базовое значение для регистра FS текущего процесса в памяти, на которую ссылается адрес
• ARCH_SET_GS — установить 64-битный базовый адрес регистра GS на адрес
• ARCH_GET_GS — вернуть 64-битное базовое значение регистра GS текущего процесса в памяти, на которую ссылается адрес

В случае успеха возвращает ноль.

adjtimex

Настраивает часы ядра.

int adjtimex(структура timex *бух)

• бух — указатель на буфер с timex структура

struct timex {режимы int; / * селектор режима * / длинное смещение; / * смещение времени в наносекундах, если установлен флаг STA_NANO, иначе в микросекундах * / long freq; / * смещение частоты * / long maxerror; / * максимальная ошибка в микросекундах * / long esterror; /* стандартное восточное время. ошибка в микросекундах * / int status; / * команда часов / статус * / длинная константа; / * Постоянная времени ФАПЧ * / long precision; / * точность часов в микросекундах, только для чтения * / длинный допуск; / * допуск тактовой частоты, только для чтения * / struct timeval time; / * текущее время (только для чтения, кроме ADJ_SETOFFSET) * / длинный тик; / * микросекунды между тактами часов * / long ppsfreq; / * Частота PPS (импульсов в секунду), только чтение * / long jitter; / * Джиттер PPS, только для чтения, в наносекундах, если установлен флаг STA_NANO, в противном случае - в микросекундах * / int shift; / * Длительность интервала PPS в секундах, только для чтения * / long stable; / * Стабильность PPS, только чтение * / long jitcnt; / * Количество PPS событий превышения лимита джиттера, только для чтения * / long calcnt; / * PPS количество интервалов калибровки, только для чтения * / long errcnt; / * Количество ошибок калибровки PPS, только для чтения * / long stbcnt; / * PPS количество событий превышения предела стабильности, только чтение * / int tai; / * Смещение TAI, установленное предыдущими операциями ADJ_TAI, в секундах, только для чтения * / / * байты заполнения для разрешения будущего расширения * / };

Вернуть состояние часов, либо TIME_OK, TIME_INS, TIME_DEL, TIME_OOP, ВРЕМЯ ЖДЕТ, или TIME_ERROR.

setrlimit

Установите ограничения ресурсов.

int setrlimit(int ресурс,constструктура rlimit *Rlim)

• ресурс — тип устанавливаемого ресурса (см. getrlimit для списка)
• Rlim — указатель на rlimit структура

struct rlimit {rlim_t rlim_cur; / * мягкий лимит * / rlim_t rlim_max; / * жесткий лимит * / };

В случае успеха возвращает ноль.

chroot

Измените корневой каталог.

int chroot(constchar*дорожка)

• дорожка — указатель на строку, содержащую путь к новому монтированию

В случае успеха возвращает ноль.

синхронизировать

Сбросить кеш файловой системы на диск.

пустота синхронизировать(пустота)

В случае успеха возвращает ноль.

acct

Переключить учет процесса.

int acct(constchar*имя файла)

• имя файла — указатель на строку с существующим файлом

В случае успеха возвращает ноль.

время дня

Установите время суток.

int время дня(constструктура время *Телевизор,constструктура часовой пояс *tz)

• Телевизор — указатель на время структура нового времени (см. gettimeofday для структуры)
• tz — указатель на часовой пояс структура (см. gettimeofday для структуры)

В случае успеха возвращает ноль.

устанавливать

Смонтируйте файловую систему.

int устанавливать(constchar*источник,constchar*цель,constchar*тип файловой системы,
беззнаковыйдолго mountflags,constпустота*данные)

• источник — указатель на строку, содержащую путь к устройству
• цель — указатель на строку, содержащую целевой путь монтирования
• тип файловой системы — указатель на тип файловой системы (см. /proc/filesystems для поддерживаемых файловых систем)
• mountflags — флаги или варианты крепления
• данные — обычно разделенный запятыми список опций, понятных типу файловой системы

В случае успеха возвращает ноль.

mountflags

• MS_BIND — выполнить монтирование привязки, сделав файл или поддерево видимым в другой точке файловой системы.
• MS_DIRSYNC — сделать изменения каталога синхронными
• MS_MANDLOCK — разрешить принудительную блокировку
• MS_MOVE — переместить поддерево, источник указывает существующую точку монтирования, а цель указывает новое местоположение
• MS_NOATIME — не обновлять время доступа
• MS_NODEV — не разрешать доступ к специальным файлам
• MS_NODIRATIME — не обновлять время доступа к каталогам
• MS_NOEXEC — не позволять запускать программы
• MS_NOSUID — не учитывать биты SUID или SGID при запуске программ
• MS_RDONLY — монтировать только для чтения
• MS_RELATIME — обновить время последнего доступа, если текущее значение atime меньше или равно mtime или ctime
• MS_REMOUNT — перемонтировать существующее крепление
• MS_SILENT — запретить вывод предупреждений printk () в журнал ядра
• MS_STRICTATIME — всегда обновлять время при доступе
• MS_SYNCHRONOUS — сделать запись синхронной

umount2

Размонтируйте файловую систему.

int umount2(constchar*цель,int флаги)

• цель — указатель на строку с файловой системой для размонтирования
• флаги — дополнительные опции

В случае успеха возвращает ноль.

флаги

• MNT_FORCE — принудительное отключение, даже если занято, что может привести к потере данных
• MNT_DETACH — выполнить ленивое отключение и сделать точку монтирования недоступной для нового доступа, а затем фактически размонтировать, когда монтирование не занято
• MNT_EXPIRE — пометить точку монтирования как истекшую
• UMOUNT_NOFOLLOW — не разыменовывать цель, если символическая ссылка

обменять

Начать переключение на указанное устройство.

int обменять(constchar*дорожка,int поменять флагами)

• дорожка — указатель на строку с путем к устройству
• поменять флагами — флажки для дополнительных опций

В случае успеха возвращает ноль.

поменять флагами

• SWAP_FLAG_PREFER — новая область подкачки будет иметь более высокий приоритет, чем уровень приоритета по умолчанию
• SWAP_FLAG_DISCARD — удалить или обрезать освобожденные страницы подкачки (для SSD)

обмен

Прекратить переключение на указанное устройство.

int обмен(constchar*дорожка)

• дорожка — указатель на строку с путем к устройству

В случае успеха возвращает ноль.

перезагружать

Перезагрузите систему.

int перезагружать(int магия,int magic2,int cmd,пустота*аргумент)

• магия — должен быть установлен на LINUX_REBOOT_MAGIC1 или LINUX_REBOOT_MAGIC2A для этого призыва к работе
• magic2 — должен быть установлен на LINUX_REBOOT_MAGIC2 или LINUX_REBOOT_MAGIC2C для этого призыва к работе
• аргумент — указатель на флаг дополнительного аргумента

Не возвращается при успехе, возвращается -1 при неудаче.

аргумент

• LINUX_REBOOT_CMD_CAD_OFF — CTRL + ALT + DELETE отключен, а CTRL + ALT + DELETE отправит SIGINT к в этом
• LINUX_REBOOT_CMD_CAD_ON — CTRL + ALT + DELETE включен
• LINUX_REBOOT_CMD_HALT — остановить систему и отобразить «Система остановлена».
• LINUX_REBOOT_CMD_KEXEC — выполнить ранее загруженное ядро ​​с kexec_load, требует CONFIG_KEXEC в ядре
• LINUX_REBOOT_CMD_POWER_OFF — система отключения питания
• LINUX_REBOOT_CMD_RESTART — перезапустите систему и отобразите «Перезапуск системы».
• LINUX_REBOOT_CMD_RESTART2 — перезапустите систему и отобразите «Перезапуск системы с помощью команды aq% saq».

sethostname

Задайте имя хоста машины.

int sethostname(constchar*название,size_t len)

• название — указатель на строку с новым именем
• len — длина нового имени

В случае успеха возвращает ноль.

setdomainname

Установите доменное имя NIS.

int setdomainname(constchar*название,size_t len)

• название — указатель на строку с новым именем
• len — длина нового имени

В случае успеха вернуть ноль.

iopl

Изменить уровень привилегий ввода-вывода

int iopl(int уровень)

• уровень — новый уровень привилегий

В случае успеха возвращает ноль.

иопермия

Установите разрешения ввода-вывода.

int иопермия(беззнаковыйдолго из,беззнаковыйдолго число,int включи)

• из — адрес начального порта
• число — количество бит
• включи — ноль или ненулевое значение означает, что включен или выключен

В случае успеха возвращает ноль.

init_module

Загрузить модуль в ядро ​​с файлом модуля, заданным файловым дескриптором.

int init_module(пустота*module_image,беззнаковыйдолго len,constchar*param_values)

• module_image — указатель на буфер с бинарным образом загружаемого модуля
• len — размер буфера
• param_values — указатель на строку с параметрами для ядра

В случае успеха возвращает ноль.

delete_module

Выгрузите модуль ядра.

int delete_module(constchar*название,int флаги)

• название — указатель на строку с именем модуля
• флаги — изменить поведение разгрузки

В случае успеха вернуть ноль.

флаги

• O_NONBLOCK — немедленно вернуться из системного вызова
• O_NONBLOCK | O_TRUNC — выгрузить модуль немедленно, даже если счетчик ссылок не равен нулю

quotactl

Измените дисковые квоты.

int quotactl(int cmd,constchar*особый,int я бы, caddr_t адрес)

• cmd — флаг команды
• особый — указатель на строку с путем к смонтированному блочному устройству
• я бы — идентификатор пользователя или группы
• адрес — адрес структуры данных, необязательный для некоторых cmd флаги

cmd

• Q_QUOTAON — включить квоты для файловой системы, на которую ссылается особый, с я бы указание формата квоты для использования:
  • QFMT_VFS_OLD — исходный формат
  • QFMT_VFS_V0 — стандартный формат VFS v0
  • QFMT_VFS_V1 — формат с поддержкой 32-битных UID и GID
• Q_QUOTAOFF — отключить квоты для файловой системы, на которую ссылается особый
• Q_GETQUOTA — получить лимиты квот и использование для идентификатора пользователя или группы, на которые ссылается я бы, куда адрес указатель на dqblk структура
• Q_GETNEXTQUOTA — такой же как Q_GETQUOTA но возвращает информацию для следующего идентификатора, большего или равного идентификатору, для которого установлена ​​квота, где адрес указывает на nextdqblk структура
• Q_SETQUOTA — установить информацию о квоте для идентификатора пользователя или группы, используя dqblk структура, на которую ссылается адрес
• Q_GETINFO — получить информацию о файле котировок, где адрес указывает на dqinfo структура
• Q_SETINFO — установить информацию о котировочном файле, где адрес указывает на dqinfo структура
• Q_GETFMT — получить формат квоты, используемый в файловой системе, на которую ссылается особый, куда адрес указывает на 4-байтовый буфер, в котором будет храниться номер формата
• Q_SYNC — обновить на диске копию использования квоты для файловой системы
• Q_GETSTATS — получить статистику по подсистеме квот, где адрес указывает на dqstats структура
• Q_XQUOTAON — включить квоты для файловой системы XFS
• Q_XQUOTAOFF — отключить квоты в файловой системе XFS
• Q_XGETQUOTA — в файловых системах XFS получить ограничения дисковой квоты и использование для идентификатора пользователя, указанного я бы, куда адрес указывает на fs_disk_quota структура
• Q_XGETNEXTQUOTA — такой же как Q_XGETQUOTA но возвращается fs_disk_quota на который ссылается адрес для следующего идентификатора, большего или равного идентификатору, для которого установлена ​​квота
• Q_XSETQLIM — в файловых системах XFS установить дисковую квоту для UID, где адрес ссылки указатель на fs_disk_quota структура
• Q_XGETQSTAT — возвращает информацию о квотах XFS в fs_quota_stat на который ссылается адрес
• Q_XGETQSTATV — возвращает информацию о квотах XFS в fs_quota_statv на который ссылается адрес
• Q_XQUOTARM — в файловых системах XFS свободное дисковое пространство, используемое квотами, где адрес ссылается на значение unsigned int, содержащее флаги (то же, что и d_flaags поле fs_disk_quota структура)

struct dqblk {uint64_t dqb_bhardlimit; / * абсолютный лимит на выделение блоков квот * / uint64_t dqb_bsoftlimit; / * предпочтительный лимит квотных блоков * / uint64_t dqb_curspace; / * используемое текущее пространство в байтах * / uint64_t dqb_ihardlimit; / * максимальное количество выделенных inodes * / uint64_t dqb_isoftlimit; / * предпочтительный лимит inode * / uint64_t dqb_curinodes; / * текущие выделенные inodes * / uint64_t dqb_btime; / * ограничение по времени для превышения квоты * / uint64_t dqb_itime; / * ограничение по времени для избыточных файлов * / uint32_t dqb_valid; / * битовая маска констант QIF_ * * / };

struct nextdqblk {uint64_t dqb_bhardlimit; uint64_t dqb_bsoftlimit; uint64_t dqb_curspace; uint64_t dqb_ihardlimit; uint64_t dqb_isoftlimit; uint64_t dqb_curinodes; uint64_t dqb_btime; uint64_t dqb_itime; uint32_t dqb_valid; uint32_t dqb_id; }; 

struct dqinfo {uint64_t dqi_bgrace; / * время до того, как мягкое ограничение станет жестким * / uint64_t dqi_igrace; / * время до того, как мягкое ограничение inode станет жестким * / uint32_t dqi_flags; / * флаги для quotafile * / uint32_t dqi_valid; }; 

struct fs_disk_quota {int8_t d_version; / * версия структуры * / int8_t d_flags; / * XFS_ {ПОЛЬЗОВАТЕЛЬ, ПРОЕКТ, ГРУППА} _QUOTA * / uint16_t d_fieldmask; / * спецификатор поля * / uint32_t d_id; / * проект, UID или GID * / uint64_t d_blk_hardlimit; / * абсолютный лимит на дисковые блоки * / uint64_t d_blk_softlimit; / * предпочтительный лимит на дисковые блоки * / uint64_t d_ino_hardlimit; / * максимальное количество выделенных inodes * / uint64_t d_ino_softlimit; / * предпочтительный лимит inode * / uint64_t d_bcount; / * # принадлежащих пользователю дисковых блоков * / uint64_t d_icount; / * # индексных дескрипторов, принадлежащих пользователю * / int32_t d_itimer; / * ноль, если в пределах inode * / int32_t d_btimer; / * как указано выше для дисковых блоков * / uint16_t d_iwarns; / * # выдано предупреждений относительно # индексных дескрипторов * / uint16_t d_bwarns; / * # выдано предупреждение о дисковых блоках * / int32_t d_padding2; / * заполнение * / uint64_t d_rtb_hardlimit; / * абсолютный лимит на количество дисковых блоков в реальном времени * / uint64_t d_rtb_softlimit; / * предпочтительное ограничение на количество дисковых блоков в реальном времени * / uint64_t d_rtbcount; / * # принадлежащих блоков реального времени * / int32_t d_rtbtimer; / * как указано выше, но для дисковых блоков реального времени * / uint16_t d_rtbwarns; / * # выдано # предупреждений относительно блоков диска в реальном времени * / int16_t d_padding3; / * заполнение * / char d_padding4 [8]; / * заполнение * / };

struct fs_quota_stat {int8_t qs_version; / * версия для будущих изменений * / uint16_t qs_flags; / * XFS_QUOTA_ {U, P, G} DQ_ {ACCT, ENFD} * / int8_t qs_pad; / * заполнение * / struct fs_qfilestat qs_uquota; / * информация о хранилище квоты пользователя * / struct fs_qfilestat qs_gquota; / * информация о групповой квоте хранилища * / uint32_t qs_incoredqs; / * количество точек в ядре * / int32_t qs_btimelimit; / * ограничение для таймера блоков * / int32_t qs_itimelimit; / * ограничение таймера inodes * / int32_t qs_rtbtimelimit; / * ограничение таймера блоков реального времени * / uint16_t qs_bwarnlimit; / * ограничение на количество предупреждений * / uint16_t qs_iwarnlimit; / * ограничение на количество предупреждений * / };

struct fs_qfilestatv {uint64_t qfs_ino; / * номер inode * / uint64_t qfs_nblks; / * количество ББ (блоки по 512 байт) * / uint32_t qfs_nextents; / * количество экстентов * / uint32_t qfs_pad; / * прокладка для 8-байтового выравнивания * / };

struct fs_quota_statv {int8_t qs_version; / * версия для будущих изменений * / uint8_t qs_pad1; / * площадка для 16-битного выравнивания * / uint16_t qs_flags; / * XFS_QUOTA _. * Flags * / uint32_t qs_incoredqs; / * количество учетных записей * / struct fs_qfilestatv qs_uquota; / * информация о пользовательской квоте * / struct fs_qfilestatv qs_gquota; / * информация о групповой квоте * / struct fs_qfilestatv qs_pquota; / * информация о квоте проекта * / int32_t qs_btimelimit; / * ограничение для таймера блоков * / int32_t qs_itimelimit; / * ограничение таймера inodes * / int32_t qs_rtbtimelimit; / * ограничение таймера блоков реального времени * / uint16_t qs_bwarnlimit; / * ограничение на количество предупреждений * / uint16_t qs_iwarnlimit; / * ограничение на количество предупреждений * / uint64_t qs_pad2 [8]; / * заполнение * / };

В случае успеха возвращает ноль.

Gettid

Получите идентификатор потока.

pid_t gettid(пустота)

Возвращает идентификатор потока вызывающего процесса.

читать вперед

Прочитать файл в кеш страницы.

ssize_t readahead(int fd, off64_t смещение,size_t считать)

• fd — файловый дескриптор файла для упреждающего чтения
• компенсировать — смещение от начала файла для чтения
• считать — количество байтов для чтения

В случае успеха возвращает ноль.

setxattr

Установите расширенное значение атрибута.

int setxattr(constchar*дорожка,constchar*название,constпустота*стоимость,
size_t размер,int флаги)

• дорожка — указатель на строку с именем файла
• название — указатель на строку с именем атрибута
• стоимость — указатель на строку со значением атрибута
• размер — размер стоимость
• флаги — установлен в XATTR_CREATE создать атрибут, XATTR_REPLACE заменить

В случае успеха возвращает ноль.

lsetxattr

Установить значение расширенного атрибута символьной ссылки.

int lsetxattr(constchar*дорожка,constchar*название,constпустота*стоимость,
size_t размер,int флаги)

• дорожка — указатель на строку с символической ссылкой
• название — указатель на строку с именем атрибута
• стоимость — указатель на строку со значением атрибута
• размер — размер стоимость
• флаги — установлен в XATTR_CREATE создать атрибут, XATTR_REPLACE заменить

В случае успеха возвращает ноль.

fsetxattr

Установить значение расширенного атрибута файла, на который ссылается файловый дескриптор.

int fsetxattr(int fd,constchar*название,constпустота*стоимость,size_t размер,int флаги)

• fd — файловый дескриптор рассматриваемого файла
• название — указатель на строку с именем атрибута
• стоимость — указатель на строку со значением атрибута
• размер — размер стоимость
• флаги — установлен в XATTR_CREATE создать атрибут, XATTR_REPLACE заменить

В случае успеха возвращает ноль.

getxattr

Получить расширенное значение атрибута.

ssize_t getxattr(constchar*дорожка,constchar*название,пустота*стоимость,size_t размер)

• дорожка — указатель на строку с именем файла
• название — указатель на строку с именем атрибута
• стоимость — указатель на строку со значением атрибута
• размер — размер стоимость

Возвращает размер расширенного значения атрибута.

lgetxattr

Получить расширенное значение атрибута из символической ссылки.

ssize_t lgetxattr(constchar*дорожка,constchar*название,пустота*стоимость,size_t размер)

• дорожка — указатель на строку с символической ссылкой
• название — указатель на строку с именем атрибута
• стоимость — указатель на строку со значением атрибута
• размер — размер стоимость

Возвращает размер расширенного значения атрибута.

fgetxattr

Получить значение расширенного атрибута из файла, на который ссылается файловый дескриптор.

ssize_t fgetxattr(int fd,constchar*название,пустота*стоимость,size_t размер)

• fd — файловый дескриптор рассматриваемого файла
• название — указатель на строку с именем атрибута
• стоимость — указатель на строку со значением атрибута
• размер — размер стоимость

Возвращает размер расширенного значения атрибута.

listxattr

Список расширенных имен атрибутов.

ssize_t listxattr(constchar*дорожка,char*список,size_t размер)

• дорожка — указатель на строку с именем файла
• список — указатель на список имен атрибутов
• размер — размер буфера списка

Возвращает размер списка имен.

llistxattr

Список расширенных имен атрибутов для символической ссылки.

ssize_t llistxattr(constchar*дорожка,char*список,size_t размер)

• дорожка — указатель на строку с символической ссылкой
• список — указатель на список имен атрибутов
• размер — размер буфера списка

Возвращает размер списка имен.

Flistxattr

Список расширенных имен атрибутов для файла, на который ссылается файловый дескриптор.

ssize_t flistxattr(int fd,char*список,size_t размер)

• fd — файловый дескриптор рассматриваемого файла
• список — указатель на список имен атрибутов
• размер — размер буфера списка

Возвращает размер списка имен.

removexattr

Удалите расширенный атрибут.

int removexattr(constchar*дорожка,constchar*название)

• дорожка — указатель на строку с именем файла
• название — указатель на строку с именем удаляемого атрибута

В случае успеха возвращает ноль.

lremovexattr

Удалите расширенный атрибут символической ссылки.

int lremovexattr(constchar*дорожка,constchar*название)

• дорожка — указатель на строку с именем файла
• название — указатель на строку с именем удаляемого атрибута

В случае успеха возвращает ноль.

fremovexattr

Удалите расширенный атрибут файла, на который ссылается файловый дескриптор.

int fremovexattr(int fd,constchar*название)

• fd — файловый дескриптор рассматриваемого файла
• название — указатель на строку с именем удаляемого атрибута

В случае успеха возвращает ноль.

tkill

Отправить сигнал в ветку.

int tkill(int tid,int сиг)

• tid — идентификатор потока
• сиг — сигнал для отправки

В случае успеха возвращает ноль.

время

Узнайте время в секундах.

• т — если не NULL, возвращаемое значение также сохраняется в указанном адресе памяти

Возвращает время (в секундах) с момента UNIX Epoch.

фьютекс

Быстрая блокировка пользовательского пространства.

int фьютекс(int*uaddr,int op,int вал,constструктура время *тайм-аут,
int*uaddr2,int val3)

• uaddr — указатель на адрес значения для отслеживания изменений
• op — флаг операции
• тайм-аут — указатель на время структура с таймаутом
• uaddr2 — указатель на целое число, используемое для некоторых операций
• val3 — дополнительный аргумент в некоторых операциях

Возвращаемое значение зависит от операции, описанной выше.

op

• FUTEX_WAIT — атомарно изменяет это uaddr все еще содержит ценность вал и спит в ожидании FUTEX_WAKE по этому адресу
• FUTEX_WAKE — просыпается самое большее вал процессы, ожидающие адреса фьютекса
• FUTEX_REQUEUE — просыпается вал обрабатывает и запрашивает всех официантов на фьютексе по адресу uaddr2
• FUTEX_CMP_REQUEUE — похожий на FUTEX_REQUEUE но сначала проверяет, есть ли местоположение uaddr содержит значение val3

sched_setaffinity

Установить маску сродства к процессору.

int sched_setaffinity(pid_t pid,size_t cpusetsize, cpu_set_t *маска)

• пид — PID процесса
• cpusetsize — длина данных в маска
• маска — указатель на маску

В случае успеха возвращает ноль.

sched_getaffinity

Получить маску соответствия процессоров процессам.

int sched_getaffinity(pid_t pid,size_t cpusetsize, cpu_set_t *маска)

• пид — PID процесса
• cpusetsize — длина данных в маска
• маска — указатель на маску

Возвращает ноль в случае успеха с маской, помещенной в память, на которую ссылается маска.

set_thread_area

Установить область локального хранения потока.

int set_thread_area(структура user_desc *u_info)

• u_info — указатель на user_desc структура

В случае успеха возвращает ноль.

io_setup

Создайте контекст асинхронного ввода-вывода.

int io_setup(беззнаковый nr_events, aio_context_t *ctx_idp)

• nr_events — общее количество событий для получения
• ctx_idp — указатель ссылки на созданный дескриптор

В случае успеха возвращает ноль.

io_destroy

Уничтожить контекст асинхронного ввода-вывода.

int io_destroy(aio_context_t ctx_id)

• ctx_id — ID контекста для уничтожения

В случае успеха возвращает ноль.

io_getevents

Чтение событий асинхронного ввода-вывода из очереди.

int io_getevents(aio_context_t ctx_id,долго min_nr,долго номер,структура io_event
*события, время *тайм-аут)

• ctx_id — ID контекста AIO
• min_nr — минимальное количество событий для чтения
• номер — количество событий для чтения
• события — указатель на io_event структура
• тайм-аут — указатель на время структура тайм-аута

Возвращает количество прочитанных событий или ноль, если событий нет или их число меньше min_nr.

io_submit

Отправьте блоки асинхронного ввода-вывода для обработки.

int io_submit(aio_context_t ctx_id,долго nrstruct, iocb *iocbpp)

• ctx_id — ID контекста AIO
• nrstruct — количество строений
• iocbpp — указатель на iocb структура

Возвращает количество iocb Отправлено.

io_cancel

Отменить ранее отправленную операцию асинхронного ввода-вывода.

int io_cancel(aio_context_t ctx_id,структура iocb *iocb,структура io_event *результат)

• ctx_id — ID контекста AIO
• iocb — указатель на iocb структура
• результат — указатель на io_event структура

Возвращает ноль в случае успеха и копирует событие в память, на которую ссылается результат.

get_thread_area

Получите локальную область хранения потока.

int get_thread_area(структура user_desc *u_info)

• u_info — указатель на user_desc структура для приема данных

В случае успеха возвращает ноль.

lookup_dcookie

Вернуть путь к записи каталога.

int lookup_dcookie(u64 cookie,char*буфер,size_t len)

• печенье — уникальный идентификатор записи в справочнике
• буфер — указатель на буфер с полным путем входа в каталог
• len — длина буфера

Возвращает байты, записанные в буфер со строкой пути.

epoll_create

Откройте дескриптор файла epoll.

int epoll_create(int размер)

• размер — игнорируется, но должно быть больше 0

Возвращает дескриптор файла.

гетеросексуалы64

Получить записи каталога.

int Гетденты(беззнаковыйint fd,структура linux_dirent *гадить,беззнаковыйint считать)

• fd — файловый дескриптор каталога
• гадить — указатель на linux_dirent структура результатов
• считать — размер гадить буфер

struct linux_dirent {беззнаковое длинное d_ino; / * номер inode * / unsigned long d_off; / * смещение до следующего linux_dirent * / unsigned short d_reclen; / * длина этого linux_dirent * / char d_name []; / * имя файла с завершающим нулем * / char pad; / * нулевой байт заполнения * / char d_type; /* тип файла */ }

Возвращает прочитанные байты, а в конце каталога возвращает ноль.

set_tid_address

Установите указатель на идентификатор потока.

долго set_tid_address(int*тидптр)

• тидптр — указатель на ID потока

Возвращает PID вызывающего процесса.

restart_syscall

Перезапустите системный вызов.

долго sys_restart_syscall(пустота)

Возвращает значение системного вызова, который он перезапускает.

семимедоп

То же, что и семоп syscall, кроме случаев, когда вызывающий поток спит, duraton ограничен тайм-аутом.

int семимедоп(int полусухой,структура сембуф *подачки,беззнаковый nsops,структура время *тайм-аут)

• полусухой — идентификатор семафора
• подачки — указатель на сембуф структура для операций
• nsops — количество операций
• тайм-аут — тайм-аут для вызова потока и время, прошедшее после возврата из системного вызова, помещается в структуру

В случае успеха возвращает ноль.

fadvise64

Предварительно объявить шаблон доступа для файловых данных, чтобы позволить ядру оптимизировать операции ввода-вывода.

int posix_fadvise(int fd,off_t компенсировать,off_t len,int совет)

• fd — файловый дескриптор рассматриваемого файла
• компенсировать — смещение, что доступ начнется
• len — продолжительность предполагаемого доступа, или 0 до конца файла
• совет — совет отдать ядро

В случае успеха возвращает ноль.

совет

• POSIX_FADV_NORMAL — в приложении нет конкретных советов
• POSIX_FADV_SEQUENTIAL — приложение ожидает доступа к данным последовательно
• POSIX_FADV_RANDOM — данные будут доступны случайным образом
• POSIX_FADV_NOREUSE — данные будут доступны только один раз
• POSIX_FADV_WILLNEED — данные потребуются в ближайшее время
• POSIX_FADV_DONTNEED — данные не понадобятся в ближайшее время

timer_create

Создайте таймер POSIX для каждого процесса.

int timer_create(clockid_t clockid,структура sigevent *севп, timer_t *timerid)

• Clockid — тип используемых часов
• севп — указатель на структуру sigevent, объясняющий, как вызывающий абонент будет уведомлен по истечении таймера
• timerid — указатель на буфер, который получит идентификатор таймера

В случае успеха возвращает ноль.

союз sigval {int sival_int; void * sival_ptr; }; 

struct sigevent {int sigev_notify; / * способ уведомления * / int sigev_signo; / * сигнал уведомления * / union sigval sigev_value; / * данные для передачи с уведомлением * / void (* sigev_notify_function) (union sigval); / * Функция, используемая для уведомления потока * / void * sigev_notify_attributes; / * атрибуты для потока уведомлений * / pid_t sigev_notify_thread_id; / * идентификатор потока для сигнала * / };

Clockid

• CLOCK_REALTIME — настраиваемые общесистемные часы реального времени
• CLOCK_MONOTONIC — ненастраиваемое монотонно увеличивающееся время измерения часов с неустановленной точки в прошлом
• CLOCK_PROCESS_CPUTIME_ID — часы, измеряющие время процессора, потребляемое вызывающим процессом и его потоками
• CLOCK_THREAD_CPUTIME_ID — часы, измеряющие время процессора, потребляемое вызовом потока

timer_settime

Включите или выключите таймер POSIX для каждого процесса.

int timer_settime(timer_t timerid,int флаги,constструктура itimerspec *новое_значение,
структура itimerspec *old_value)

• timerid — id таймера
• флаги — уточнить TIMER_ABSTIME обрабатывать new_value-> it_value как абсолютная величина
• новое_значение — указатель на itimerspec структура, определяющая новый начальный и новый интервалы для таймера
• old_value — указатель на структуру для получения сведений о предыдущем таймере

struct itimerspec {struct timepec it_interval; / * интервал * / struct timespec it_value; / * срок действия * / };

В случае успеха возвращает ноль.

timer_gettime

Возвращает время до следующего истечения срока из таймера POSIX для каждого процесса.

int timer_gettime(timer_t timerid,структура itimerspec *curr_value)

• timerid — id таймера
• curr_value — указатель на itimerspec структура, в которой возвращаются текущие значения таймера

В случае успеха возвращает ноль.

timer_getoverrun

Получите счетчик переполнения на таймере POSIX для каждого процесса.

int timer_getoverrun(timer_t timerid)

• timerid — id таймера

Возвращает счетчик переполнения указанного таймера.

timer_delete

Удалите таймер POSIX для каждого процесса.

int timer_delete(timer_t timerid)

• timerid — id таймера

В случае успеха возвращает ноль.

clock_settime

Установите указанные часы.

int clock_settime(clockid_t clk_id,constструктура время *tp)

• clk_id — идентификатор часов
• tp — указатель на время структура с часами detais

В случае успеха возвращает ноль.

clock_gettime

Получить время по указанным часам.

int clock_gettime(clockid_t clk_id,структура время *tp)

• clk_id — идентификатор часов
• tp — указатель на время структура вернулась с часами detais

В случае успеха возвращает ноль.

clock_getres

Получить разрешение указанных часов.

int clock_getres(clockid_t clk_id,структура время *res)

• clk_id — идентификатор часов
• res — указатель на время структура возвращена с деталями

В случае успеха возвращает ноль.

clock_nanosleep

Сон высокого разрешения с указанием часов.

int clock_nanosleep(clockid_t clock_id,int флаги,constструктура время
*запрос,структура время *оставаться)

• clock_id — тип используемых часов
• флаги — уточнить TIMER_ABSTIME обрабатывать запрос интерпретируется как абсолютное значение
• оставаться — указатель на время структура для получения оставшегося времени на сон

Возвращает ноль после интервала ожидания.

exit_group

Закройте все потоки в процессе.

пустота exit_group(int статус)

• статус — код статуса для возврата

Не возвращается.

epoll_wait

Дождитесь события ввода-вывода в файловом дескрипторе epoll.

int epoll_wait(int э.п.п.м.,структура epoll_event *События,int maxevents,int тайм-аут)

• э.п.п.м. — файловый дескриптор epoll
• События — указатель на epoll_event структура с событиями, доступными вызывающему процессу
• maxevents — максимальное количество событий, должно быть больше нуля
• тайм-аут — таймаут в миллисекундах

typedef union epoll_data {void * ptr; int fd; uint32_t u32; uint64_t u64; } epoll_data_t; 

struct epoll_event {события uint32_t; / * события epoll * / epoll_data_t data; / * переменная пользовательских данных * / };

Возвращает количество файловых дескрипторов, готовых для запрошенного ввода-вывода, или ноль, если тайм-аут произошел до того, как какие-либо из них были доступны.

epoll_ctl

Интерфейс управления файловым дескриптором epoll.

int epoll_ctl(int э.п.п.м.,int op,int fd,структура epoll_event *событие)

• э.п.п.м. — файловый дескриптор epoll
• op — флаг операции
• fd — файловый дескриптор для целевого файла
• событие — указатель на epoll_event структура с событием, цель изменена op

В случае успеха возвращает ноль.

op

• EPOLL_CTL_ADD — добавлять fd список интересов
• EPOLL_CTL_MOD — изменить настройки, связанные с fd в списке интересов к новым настройкам, указанным в событие
• EPOLL_CTL_DEL — удалить дескриптор целевого файла fd из списка интересов, с событие аргумент проигнорирован

tgkill

Отправить сигнал в поток.

int tgkill(int tgid,int tid,int сиг)

• tgid — идентификатор группы потоков
• tid — идентификатор потока
• сиг — сигнал для отправки

В случае успеха возвращает ноль.

время

Изменить время последнего доступа и модификации файла.

int время(constchar*имя файла,constструктура время[2])

• имя файла — указатель на строку с рассматриваемым файлом
• раз — массив время структура, где раз [0] указывает новое время доступа, где раз [1] указывает новое время модификации

В случае успеха возвращает ноль.

mbind

Установите политику памяти NUMA для диапазона памяти.

долго mbind(пустота*адрес,беззнаковыйдолго len,int Режим,constбеззнаковыйдолго
*маска узла,беззнаковыйдолго maxnode,беззнаковый флаги)

• адрес — указатель на начальный адрес памяти
• len — длина сегмента памяти
• Режим — Режим NUMA
• маска узла — указатель на маску, определяющую узлы, к которым применяется режим
• maxnode — максимальное количество бит для маска узла
• флаги — задавать MPOL_F_STATIC_NODES указать физические узлы, MPOL_F_RELATIVE_NODES для указания идентификаторов узлов относительно набора, разрешенного потоками текущего процессора

В случае успеха возвращает ноль.

Режим

• MPOL_DEFAULT — удалить любую политику, отличную от политики по умолчанию, и восстановить поведение по умолчанию
• MPOL_BIND — указать политику, ограничивающую выделение памяти узлу, указанному в маска узла
• MPOL_INTERLEAVE — указать, что распределение страниц должно чередоваться по набору узлов, указанных в маска узла
• MPOL_PREFERRED — установить предпочтительный узел для распределения
• MPOL_LOCAL — режим определяет «локальное выделение» — память выделяется на узле ЦП, который запускает выделение

set_mempolicy

Установите политику памяти NUMA по умолчанию для потока и его потомков.

долго set_mempolicy(int Режим,constбеззнаковыйдолго*маска узла,
беззнаковыйдолго maxnode)

• Режим — Режим NUMA
• маска узла — указатель на маску, определяющую узел, к которому применяется режим
• maxnode — максимальное количество бит для маска узла

В случае успеха вернуть ноль.

get_mempolicy

Получите политику памяти NUMA для потока и его потомков.

долго get_mempolicy(int*Режим,беззнаковыйдолго*маска узла,беззнаковыйдолго maxnode,
пустота*адрес,беззнаковыйдолго флаги)

• Режим — Режим NUMA
• маска узла — указатель на маску, определяющую узел, к которому применяется режим
• maxnode — максимальное количество бит для маска узла
• адрес — указатель на область памяти
• флаги — определяет поведение звонка

В случае успеха вернуть ноль.

флаги

• MPOL_F_NODE или 0 (предпочтительно ноль) — получить информацию о политике вызывающего потока по умолчанию и сохранить в маска узла буфер
• MPOL_F_MEMS_ALLOWED – Режим аргумент игнорируется, и последующие вызовы возвращают набор узлов, которые поток может указать, возвращается в маска узла
• MPOL_F_ADDR — получить информацию о политике для адрес

mq_open

Создает новую или открывает существующую очередь сообщений POSIX.

mqd_t mq_open(constchar*название,int офлаг)
mqd_t mq_open(constchar*название,int офлаг, mode_t режим,структура mq_attr *attr)

• название — указатель на строку с именем очереди
• офлаг — определить операцию вызова
• Режим — разрешения на постановку в очередь
• attr — указатель на mq_attr структура для определения параметров очереди

struct mq_attr {длинные mq_flags; / * флаги (не используются для mq_open) * / long mq_maxmsg; / * максимальное количество сообщений в очереди * / long mq_msgsize; / * максимальный размер сообщения в байтах * / long mq_curmsgs; / * сообщения в очереди (не используются для mq_open) * / };

офлаг

• O_RDONLY — открыть очередь только для приема сообщений
• O_WRONLY — открытая очередь для отправки сообщений
• O_RDWR — открытая очередь для отправки и получения
• O_CLOEXEC — установить флаг закрытия при выполнении для дескриптора очереди сообщений
• O_CREAT — создать очередь сообщений, если ее не существует
• O_EXCL — если O_CREAT указана и очередь уже существует, сбой с EEXIST
• O_NONBLOCK — открыть очередь в неблокирующем режиме

Удалить очередь сообщений.

int mq_unlink(constchar*название)

• название — указатель на строку с именем очереди

В случае успеха возвращает ноль.

mq_timedsend

Отправить сообщение в очередь сообщений.

int mq_send(mqd_t mqdes,constchar*msg_ptr,size_t msg_len,беззнаковый msg_prio,
constструктура время *abs_timeout)

• mqdes — дескриптор, указывающий на очередь сообщений
• msg_ptr — указатель на сообщение
• msg_len — длина сообщения
• msg_prio — приоритет сообщения
• abs_timeout — указатель на время структура, определяющая тайм-аут

В случае успеха возвращает ноль.

mq_timedreceive

Получите сообщение из очереди сообщений.

ssize_t mq_receive(mqd_t mqdes,char*msg_ptr,size_t msg_len,беззнаковый*msg_prio)

• mqdes — дескриптор, указывающий на очередь сообщений
• msg_ptr — указатель на буфер для приема сообщения
• msg_len — длина сообщения

Вернуть количество байтов в полученном сообщении.

mq_notify

Зарегистрируйтесь, чтобы получать уведомления, когда сообщение доступно в очереди сообщений.

int mq_notify(mqd_t mqdes,constструктура sigevent *севп)

• mqdes — дескриптор, указывающий на очередь сообщений
• севп — указатель на sigevent структура

В случае успеха возвращает ноль.

kexec_load

Загрузите новое ядро ​​для выполнения в более позднее время.

долго kexec_load(беззнаковыйдолго Вход,беззнаковыйдолго nr_segments,структура
kexec_segment *сегменты,беззнаковыйдолго флаги)

• Вход — адрес входа в образ ядра
• nr_segments — количество сегментов, на которые ссылается сегменты указатель
• сегменты — указатель на kexec_segment структура, определяющая структуру ядра
• флаги — изменить поведение вызова

struct kexec_segment {void * buf; / * буфер пользовательского пространства * / size_t bufsz; / * длина буфера пользовательского пространства * / void * mem; / * физический адрес ядра * / size_t memsz; / * длина физического адреса * / };

В случае успеха возвращает ноль.

флаги

• KEXEC_FILE_UNLOAD — выгрузить загруженное в данный момент ядро
• KEXEC_FILE_ON_CRASH — загрузить новое ядро ​​в область памяти, зарезервированную для аварийного ядра
• KEXEC_FILE_NO_INITRAMFS — укажите, что загрузка initrd / initramfs необязательна

waitid

Дождитесь изменения состояния в процессе.

int waitid(idtype_t idtype, id_t id, siginfo_t *информация,int опции)

• idtype — определяет я бы сфера, указав P_PID для идентификатора процесса, P_PGID идентификатор группы процессов, или P_ALL ждать любого ребенка, где я бы игнорируется
• я бы — идентификатор процесса или группы процессов, определяемый idtype
• информация — указатель на siginfo_t структура, заполненная по возврату
• опции — изменяет поведение системного вызова

В случае успеха возвращает ноль.

опции

• WNOHANG — немедленно вернуться, если ни один ребенок не вышел
• ГЛАВНЫЙ — также вернуть, если дочерний элемент остановлен, но не отслеживается
• ПРОДОЛЖАЕТСЯ — также возвращается, если остановленный ребенок возобновил работу через SIGCONT
• WIFEXITED — возвращает истину, если потомок был завершен нормально
• WEXITSTATUS — возвращает существующий статус ребенка
• WIFSIGNALED — возвращает истину, если дочерний процесс завершен сигналом
• WTERMSIG — возвращает сигнал, вызвавший завершение дочернего процесса
• WCOREDUMP — возвращает истину, если дочерний дамп произвел дамп памяти
• WIFSTOPPED — возвращает истину, если дочерний процесс остановлен доставкой сигнала
• WSTOPSIG — возвращает номер сигнала, который заставил ребенка остановиться
• WIF ПРОДОЛЖАЕТСЯ — возвращает истину, если дочерний процесс был возобновлен через SIGCONT
• WEXITED — дождаться прекращенных детей
• WSTOPPED — ждать остановившихся детей по сигналу
• ПРОДОЛЖАЕТСЯ — ждать ранее остановленных детей, которые были возобновлены через SIGCONT
• ПОДПИСАТЬСЯ — оставить ребенка в состоянии ожидания

add_key

Добавьте ключ в управление ключами ядра.

key_serial_t add_key(constchar*тип,constchar*описание,constпустота
*полезная нагрузка,size_t пленка, key_serial_t связка ключей)

• тип — указатель на строку с типом ключа
• описание — указатель на строку с описанием ключа
• полезная нагрузка — ключ для добавления
• пленка — длина ключа
• брелок для ключей — серийный номер брелока или специального флажка

Возвращает серийный номер созданного ключа.

брелок для ключей

• KEY_SPEC_THREAD_KEYRING — указывает связку ключей, зависящую от потока вызывающего абонента
• KEY_SPEC_PROCESS_KEYRING — указывает связку ключей вызывающего процесса
• KEY_SPEC_SESSION_KEYRING — указывает связку ключей вызывающего абонента для конкретного сеанса
• KEY_SPEC_USER_KEYRING — указывает связку ключей, зависящую от UID вызывающего абонента
• KEY_SPEC_USER_SESSION_KEYRING — указывает связку ключей сеанса UID вызывающего абонента

request_key

Запросить ключ в системе управления ключами ядра.

key_serial_t request_key(constchar*тип,constchar*описание,
constchar*callout_info, key_serial_t связка ключей)

• тип — указатель на строку с типом ключа
• описание — указатель на строку с описанием ключа
• callout_info — указатель на строку устанавливается, если ключ не найден
• брелок для ключей — серийный номер брелока или специального флажка

Возвращает серийный номер ключа, найденного в случае успеха.

keyctl

Манипулировать управлением ключами ядра.

долго keyctl(int cmd, …)

• cmd — флаг команды, изменяющий поведение системного вызова
• ... — дополнительные аргументы на cmd флаг

Возвращает серийный номер ключа, найденного в случае успеха.

cmd

• KEYCTL_GET_KEYRING_ID — запросить идентификатор брелка
• KEYCTL_JOIN_SESSION_KEYRING — присоединиться или начать именованную связку ключей сеанса
• KEYCTL_UPDATE — обновить ключ
• KEYCTL_REVOKE — отозвать ключ
• KEYCTL_CHOWN — установить владение ключом
• KEYCTL_SETPERM — установить разрешения на ключ
• KEYCTL_DESCRIBE — описать ключ
• KEYCTL_CLEAR — очистить содержимое брелка
• KEYCTL_LINK — связать ключ с брелоком
• KEYCTL_UNLINK — отвязать ключ от связки ключей
• KEYCTL_SEARCH — поиск ключа в связке ключей
• KEYCTL_READ — прочитать содержимое ключа или брелка
• KEYCTL_INSTANTIATE — создать экземпляр частично сконструированного ключа
• KEYCTL_NEGATE — отрицать частично построенный ключ
• KEYCTL_SET_REQKEY_KEYRING — установить брелок ключа запроса по умолчанию
• KEYCTL_SET_TIMEOUT — установить тайм-аут на ключе
• KEYCTL_ASSUME_AUTHORITY — принять полномочия на создание экземпляра ключа

ioprio_set

Установите класс планирования ввода-вывода и приоритет.

int ioprio_set(int который,int ВОЗ,int ioprio)

• который — флаг, указывающий цель ВОЗ
• ВОЗ — идентификатор определяется который флаг
• ioprio — битовая маска, определяющая класс планирования и приоритет для назначения ВОЗ процесс

В случае успеха возвращает ноль.

который

• IOPRIO_WHO_PROCESS – ВОЗ это идентификатор процесса или потока, или 0 использовать вызывающий поток
• IOPRIO_WHO_PGRP – ВОЗ — это идентификатор процесса, идентифицирующий всех членов группы процессов, или 0 для работы с группой процессов, членом которой является вызывающий процесс
• IOPRIO_WHO_USER – ВОЗ является UID, идентифицирующим все процессы, у которых есть совпадающий реальный UID

ioprio_get

Получите класс планирования ввода-вывода и приоритет.

int ioprio_get(int который,int ВОЗ)

• который — флаг, указывающий цель ВОЗ
• ВОЗ — идентификатор определяется который флаг

Возвращение ioprio значение процесса с наивысшим приоритетом ввода-вывода из совпадающих процессов.

inotify_init

Инициализировать экземпляр inotify.

int inotify_init(пустота)

Возвращает файловый дескриптор новой очереди событий inotify.

inotify_add_watch

Добавьте часы в инициализированный экземпляр inotify.

int inotify_add_watch(int fd,constchar*путь,uint32_t маска)

• fd — дескриптор файла, относящийся к экземпляру inodify с изменяемым списком наблюдения
• путь — указатель на строку с путем для мониторинга
• маска — маска отслеживаемых событий

В случае успеха возвращает дескриптор часов.

inotify_rm_watch

Удалите существующие часы из экземпляра inotify.

int inotify_rm_watch(int fd,int wd)

• fd — дескриптор файла, связанный с часами
• wd — дескриптор часов

В случае успеха возвращает ноль.

migrate_pages

Перемещайте незавершенные страницы в другой набор узлов.

долго migrate_pages(int пид,беззнаковыйдолго maxnode,constбеззнаковыйдолго
*старые_узлы,constбеззнаковыйдолго*new_nodes)

• пид — PID рассматриваемого процесса
• maxnode — максимальное количество узлов в старые_узлы и new_nodes маски
• старые_узлы — указатель на маску номеров узлов, из которых нужно перейти
• new_nodes — указатель на маску номеров узлов, к которым нужно перейти

Возвращает количество страниц, которые нельзя переместить.

открывать

Открыть файл относительно дескриптора файла каталога.

int открывать(int dirfd,constchar*путь,int флаги)
int открывать(int dirfd,constchar*путь,int флаги, mode_t режим)

• dirfd — файловый дескриптор каталога
• путь — указатель на строку с именем пути
• флаги — видеть открыто системный вызов
• Режим — видеть открыто системный вызов

В случае успеха возвращает новый файловый дескриптор.

мкдират

Создать каталог относительно дескриптора файла каталога.

int мкдират(int dirfd,constchar*путь, mode_t режим)

• dirfd — файловый дескриптор каталога
• путь — указатель на строку с именем пути
• Режим — видеть mkdir системный вызов

В случае успеха возвращает ноль.

mknodat

Создайте специальный файл относительно дескриптора файла каталога.

int mknodat(int dirfd,constchar*путь, mode_t режим, dev_t dev)

• dirfd — файловый дескриптор каталога
• путь — указатель на строку с именем пути
• Режим — видеть mknod системный вызов
• разработчик — номер устройства

В случае успеха возвращает ноль.

Fchownat

Измените владельца файла относительно дескриптора файла каталога.

int Fchownat(int dirfd,constchar*путь, uid_t владелец, группа gid_t,int флаги)

• dirfd — файловый дескриптор каталога
• путь — указатель на строку с именем пути
• владелец — идентификатор пользователя (UID)
• группа — идентификатор группы (GID)
• флаги — если AT_SYMLINK_NOFOLLOW указан, не разыменовывать символические ссылки

Удалите имя и, возможно, файл, на который оно ссылается.

int отсоединить(int dirfd,constchar*путь,int флаги)

• dirfd — файловый дескриптор каталога
• путь — указатель на строку с именем пути
• флаги — видеть разорвать связь или rmdir

В случае успеха возвращает ноль.

переименовать

Измените имя или расположение файла относительно дескриптора файла каталога.

int переименовать(int olddirfd,constchar*старый путь,int newdirfd,constchar*новый путь)

• olddirfd — файловый дескриптор каталога с исходным кодом
• старый путь — указатель на строку с именем пути к источнику
• newdirfd — файловый дескриптор каталога с целью
• новый путь — указатель на строку с именем пути к цели

В случае успеха возвращает ноль.

Создайте жесткую ссылку относительно дескриптора файла каталога.

int линкат(int olddirfd,constchar*старый путь,int newdirfd,constchar*новый путь,int флаги)

• olddirfd — файловый дескриптор каталога с исходным кодом
• старый путь — указатель на строку с именем пути к источнику
• newdirfd — файловый дескриптор каталога с целью
• новый путь — указатель на строку с именем пути к цели
• флаги — видеть ссылка на сайт

В случае успеха возвращает ноль.

Создайте символическую ссылку относительно дескриптора файла каталога.

int символическая ссылка(constchar*цель,int newdirfd,constchar*путь ссылки)

• цель — указатель на строку с целью
• newdirfd — файловый дескриптор каталога с целью
• путь ссылки — указатель на строку с источником

В случае успеха возвращает ноль.

Прочтите содержимое пути символьной ссылки относительно дескриптора файла каталога.

ssize_t readlinkat(int dirfd,constchar*путь,char*бух,size_t Bufsiz)

• dirfd — дескриптор файла относительно символической ссылки
• путь — указатель на строку с путем символьной ссылки
• бух — указатель на буфер, принимающий путь символьной ссылки
• Bufsiz — размер бух

Возвращает количество байтов, помещенных в бух об успехе.

fchmodat

Измените права доступа к файлу относительно дескриптора файла каталога.

int fchmodat(int dirfd,constchar*путь, mode_t режим,int флаги)

• dirfd — файловый дескриптор каталога
• путь — указатель на строку с рассматриваемым файлом
• Режим — маска разрешений
• флаги — видеть chmod

В случае успеха возвращает ноль.

факс

Проверьте права пользователя для данного файла относительно дескриптора файла каталога.

int факс(int dirfd,constchar*путь,int Режим,int флаги)

• dirfd — файловый дескриптор каталога
• путь — указатель на строку с рассматриваемым файлом
• Режим — указать проверку для выполнения
• флаги — видеть доступ

Возвращает ноль, если разрешения предоставлены.

pselect6

Мультиплексирование синхронного ввода / вывода. Работает так же, как Выбрать с измененным таймаутом и сигнальной маской.

int pselect6(int нфд, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
constструктура время *тайм-аут,const sigset_t *сигмаска)

• нфд — количество описаний файлов для мониторинга (добавить 1)
• readfds — исправлен буфер со списком файловых дескрипторов для ожидания доступа на чтение
• writefds — исправлен буфер со списком файловых дескрипторов для ожидания доступа на запись
• exceptfds — исправлен буфер со списком файловых дескрипторов для ожидания исключительных условий
• тайм-аут — временная структура со временем ожидания перед возвратом
• сигмаска — указатель на маску сигнала

Возвращает количество файловых дескрипторов, содержащихся в возвращенных наборах дескрипторов.

ppoll

Дождитесь события в файловом дескрипторе, например голосование но позволяет сигналу прерывать тайм-аут.

int ppoll(структура опрос *fds, nfds_t nfds,constструктура время *timeout_ts,
const sigset_t *сигмаска)

• fds — указатель на массив опрос конструкции (описаны ниже)
• нфд — количество опрос предметы в fds множество
• timeout_ts — устанавливает количество миллисекунд, которое системный вызов должен блокировать (отрицательные силы голосование немедленно вернуться)
• сигмаска — сигнальная маска

Возвращает количество структур, имеющих ненулевое значение. возрождает полей или ноль по истечении времени ожидания.

не делиться

Отсоедините части контекста выполнения процесса.

int не делиться(int флаги)

• флаги — определить поведение звонка

флаги

• CLONE_FILES — таблица файловых дескрипторов unsuare, поэтому вызывающий процесс больше не разделяет файловые дескрипторы с другими процессами
• CLONE_FS — запретить общий доступ к атрибутам файловой системы, чтобы вызывающий процесс больше не делился своим корневым или текущим каталогом или umask с другими процессами
• CLONE_NEWIPC — запретить совместное использование пространства имен System V IPC, чтобы вызывающий процесс имел частную копию пространства имен System V IPC, не объединенную с другими процессами
• CLONE_NEWNET — не разделять сетевое пространство имен, поэтому вызывающий процесс перемещается в новое сетевое пространство имен, не совместно используемое с другими процессами
• CLONE_NEWNS — неуверенное пространство имен монтирования
• CLONE_NEWUTS — пространство имен UTS IPC unsuare
• CLONE_SYSVSEM — не делиться значениями отмены семпафоров System V

set_robust_list

Установить список надежных фьютексов.

долго set_robust_list(структура robust_list_head *голова,size_t len)

• пид — идентификатор потока / процесса, или если 0 текущий идентификатор процесса используется
• голова — указатель на расположение заголовка списка
• len_ptr — длина head_ptr

В случае успеха возвращает ноль.

get_robust_list

Получите список надежных фьютексов.

долго get_robust_list(int пид,структура robust_list_head **head_ptr,size_t*len_ptr)

• пид — идентификатор потока / процесса, или если 0 текущий идентификатор процесса используется
• голова — указатель на расположение заголовка списка
• len_ptr — длина head_ptr

В случае успеха возвращает ноль.

сращивание

Данные для соединения с трубой.

сращивание(int fd_in, loff_t *off_in,int fd_out, loff_t *off_out,size_t len,беззнаковыйint флаги)

• fd_in — файловый дескриптор, ссылающийся на канал для ввода
• fd_out — файловый дескриптор, ссылающийся на канал для вывода
• off_in — ноль, если fd_in относится к каналу, в противном случае указывает на смещение для чтения
• off_out— ноль, если fd_out относится к каналу, в противном случае указывает на смещение для записи
• len — всего байтов для передачи
• флаги — определяет дополнительное поведение, связанное с системным вызовом

Возвращает количество байтов, соединенных с конвейером или от него.

флаги

• SPLICE_F_MOVE — попробуйте перемещать страницы вместо копирования
• SPLICE_F_NONBLOCK — постарайтесь не блокировать ввод / вывод
• SPLICE_F_MORE — сообщить ядру, что при последующем соединении будет поступать больше данных
• SPLICE_F_GIFT — только для vmsplice, подарить пользовательские страницы ядру

тройник

Повторяющееся содержимое трубы.

тройник(int fd_in,int fd_out,size_t len,беззнаковыйint флаги)

• fd_in — файловый дескриптор, ссылающийся на канал для ввода
• fd_out — файловый дескриптор, ссылающийся на канал для вывода
• len — всего байтов для передачи
• флаги — определяет дополнительное поведение, связанное с системным вызовом (см. Флаги для сращивание)

Возвращает количество байтов, дублированных между конвейерами.

sync_file_range

Синхронизировать файловый сегмент с диском.

int sync_file_range(int fd, off64_t смещение, off64_t nbytes, nsigned int флаги)

• fd — файловый дескриптор рассматриваемого файла
• компенсировать — смещение для начала синхронизации
• nbytes — количество байтов для синхронизации
• флаги — определяет дополнительное поведение

В случае успеха возвращает ноль.

флаги

• SYNC_FILE_RANGE_WAIT_BEFORE — подождите после записи всех страниц в диапазоне, уже отправленных в драйвер устройства, прежде чем выполнять любую запись
• SYNC_FILE_RANGE_WRITE — записать все грязные страницы в диапазоне, которые уже не отправлены на запись
• SYNC_FILE_RANGE_WAIT_AFTER — подождите после записи всех страниц в диапазоне перед выполнением любой записи

vmsplice

Объединяйте пользовательские страницы в канал.

ssize_t vmsplice(int fd,constструктура iovec *iov,беззнаковыйдолго nr_segs,беззнаковыйint
 флаги)

• fd — файловый дескриптор канала
• iovec — указатель на массив iovec структуры
• nr_segs — диапазоны пользовательской памяти
• флаги — определяет дополнительное поведение (см. сращивание)

Вернуть количество байтов, переданных в канал.

move_pages

Перенести страницы процесса на другой узел.

долго move_pages(int пид,беззнаковыйдолго считать,пустота**страницы,constint
*узлы,int*статус,int флаги)

• пид — идентификатор процесса
• страницы — массив указателей на страницы для перемещения
• узлы — массив целых чисел, определяющих место для перемещения каждой страницы
• статус — массив целых чисел для получения статуса каждой страницы
• флаги — определяет дополнительное поведение

В случае успеха возвращает ноль.

флаги

• MPOL_MF_MOVE — перемещать только страницы в исключительном использовании
• MPOL_MF_MOVE_ALL — страницы, общие для нескольких процессов, также можно перемещать

utimensat

Изменяйте временные метки с точностью до наносекунды.

int utimensat(int dirfd,constchar*путь,constструктура время
 раз[2],int флаги)

• dirfd — дескриптор файла каталога
• путь — указатель на строку с путем к файлу
• раз — массив временных меток, где раз [0] новое время последнего доступа и раз [1] новое время последней модификации
• флаги — если AT_SYMLINK_NOFOLLOW указано, обновить временные метки на символической ссылке

В случае успеха возвращает ноль.

epoll_pwait

Дождитесь события ввода-вывода в файловом дескрипторе epoll. Такой же как epoll_wait с сигнальной маской.

int epoll_pwait(int э.п.п.м.,структура epoll_event *События,int maxevents,int тайм-аут,
const sigset_t *сигмаска)

• э.п.п.м. — файловый дескриптор epoll
• События — указатель на epoll_event структура с событиями, доступными вызывающему процессу
• maxevents — максимальное количество событий, должно быть больше нуля
• тайм-аут — таймаут в миллисекундах
• сигмаска — сигнальная маска для ловли

Возвращает количество файловых дескрипторов, готовых для запрошенного ввода-вывода, или ноль, если тайм-аут произошел до того, как какие-либо из них были доступны.

signalfd

Создайте дескриптор файла, который может принимать сигналы.

int signalfd(int fd,const sigset_t *маска,int флаги)

• fd — если -1, создать новый дескриптор файла, в противном случае использовать существующий дескриптор файла
• маска — сигнальная маска
• флаги — установлен в SFD_NONBLOCK назначить O_NONBLOCK на новый дескриптор файла или SFD_CLOEXEC устанавливать FD_CLOEXEC флаг на новом дескрипторе файла

В случае успеха возвращает описание файла.

timerfd_create

Создайте таймер, который уведомляет файловый дескриптор.

int timerfd_create(int Clockid,int флаги)

• Clockid — уточнить CLOCK_REALTIME или CLOCK_MONOTONIC
• флаги — установлен в TFD_NONBLOCK назначить O_NONBLOCK на новый дескриптор файла или TFD_CLOEXEC устанавливать FD_CLOEXEC флаг на новом дескрипторе файла

Возвращает новый дескриптор файла.

eventfd

Создайте дескриптор файла для уведомления о событии.

int eventfd(беззнаковыйint initval,int флаги)

• initval — счетчик поддерживается ядром
• флаги — определить дополнительное поведение

Возвращает новый eventfd файловый дескриптор.

флаги

• EFD_CLOEXEC — установить флаг закрытия при запуске на новый дескриптор файла (FD_CLOEXEC)
• EFD_NONBLOCK — задавать O_NONBLOCK на новый дескриптор файла, сохраняя дополнительный вызов fcntl установить этот статус
• EFD_SEMAPHORE — выполнять семантическую семантику для чтения из нового файлового дескриптора

сбиваться

Выделить место для файла.

int сбиваться(int fd,int Режим,off_t компенсировать,off_t len)

• fd — рассматриваемый файловый дескриптор
• Режим — определяет поведение
• компенсировать — начальный диапазон размещения
• len — продолжительность выделения

Режим

• FALLOC_FL_KEEP_SIZE — не изменять размер файла, даже если offset + len больше исходного размера файла
• FALLOC_FL_PUNCH_HOLE — освободить место в указанном диапазоне, обнулить блоки

timerfd_settime

Таймер постановки или снятия с охраны, на который ссылается fd.

int timerfd_settime(int fd,int флаги,constструктура itimerspec *новое_значение,
структура itimerspec *old_value)

• fd — дескриптор файла
• флаги — установлен в 0 для запуска относительного таймера, или TFD_TIMER_ABSTIME использовать абсолютный таймер
• новое_значение — указатель на itimerspec структура для установки значения
• old_value — указатель на itimerspec структура для получения предыдущего значения после успешного обновления

В случае успеха возвращает ноль.

timerfd_gettime

Получить текущую настройку таймера, на который ссылается fd.

int timerfd_gettime(int fd,структура itimerspec *curr_value)

• fd — дескриптор файла
• curr_value — указатель на itimerspec структура с текущим значением таймера

В случае успеха возвращает ноль.

accept4

Такой же как принимать системный вызов.

signalfd4

Такой же как signalfd системный вызов.

eventfd2

Такой же как eventfd без флаги аргумент.

epoll_create1

Такой же как epoll_create без флаги аргумент.

dup3

Такой же как dup2 за исключением того, что вызывающая программа может принудительно установить флаг закрытия при выполнении для нового дескриптора файла.

pipe2

Такой же как трубка.

inotify_init1

Такой же как inotify_init без флаги аргумент.

Preadv

Такой же как Readv но добавляет компенсировать аргумент для обозначения начала ввода.

pwritev

Такой же как написать но добавляет компенсировать аргумент для обозначения начала вывода.

rt_tgsigqueueinfo

Не предназначен для использования в приложениях. Вместо этого используйте rt_sigqueue.

perf_event_open

Начать мониторинг производительности.

int perf_event_open(структура perf_event_attr *attr, pid_t pid,int ЦПУ,int group_fd,
беззнаковыйдолго флаги)

• attr — указатель на perf_event_attr структура для дополнительной настройки
• пид — идентификатор процесса
• ЦПУ — идентификатор процессора
• group_fd — создавать группы событий
• флаги — определяет дополнительные параметры поведения

struct perf_event_attr {тип __u32; / * тип события * / __u32 size; / * размер структуры атрибута * / __u64 config; / * зависящая от типа конфигурация * / union {__u64 sample_period; / * период выборки * / __u64 sample_freq; /* частота дискретизации */ }; __u64 sample_type; / * указываем значения, включенные в образец * / __u64 read_format; / * указать значения, возвращаемые при чтении * / __u64 disabled: 1, / * отключено по умолчанию * / inherit: 1, / * наследуется дочерними элементами * / pinned: 1, / * всегда должно быть в PMU * / эксклюзив: 1, / * только группа на PMU * / exclude_user: 1, / * не считать пользователя * / exclude_kernel: 1, / * не учитывать ядро ​​* / exclude_hv: 1, / * не учитывать гипервизор * / exclude_idle: 1, / * не учитывать подсчет в режиме ожидания * / mmap: 1, / * включить данные mmap * / comm: 1, / * включить данные связи * / freq: 1, / * использовать частоту, а не период * / inherit_stat: 1, / * на количество задач * / enable_on_exec: 1, / * следующий запуск включает * / task: 1, / * трассировка fork / exit * / watermark: 1, / * wakeup_watermark * / Precision_ip: 2, / * ограничение скольжения * / mmap_data: 1, / * данные mmap без выполнения * / sample_id_all: 1, / * sample_type все события * / exclude_host: 1, / * не учитываются на хосте * / exclude_guest: 1, / * не учитываются в гостях * / exclude_callchain_kernel: 1, / * исключают цепочки вызовов ядра * / exclude_callchain_user: 1, / * исключают пользовательские цепочки вызовов * / __reserved_1: 41; союз {__u32 wakeup_events; / * каждые x событий, пробуждение * / __u32 wakeup_watermark; / * байты до пробуждения * /}; __u32 bp_type; / * тип точки останова * / union {__u64 bp_addr; / * адрес точки останова * / __u64 config1; / * расширение конфига * /}; союз {__u64 bp_len; / * длина точки останова * / __u64 config2; / * расширение config1 * /}; __u64 branch_sample_type; / * перечисление perf_branch_sample_type * / __u64 sample_regs_user; / * пользовательские регистры для сброса на образцы * / __u32 sample_stack_user; / * размер стека для дампа сэмплов * / __u32 __reserved_2; / * выравниваем по u64 * /}; 

В случае успеха возвращает новый дескриптор открытого файла.

флаги

• PERF_FLAG_FD_NO_GROUP — позволяет создавать событие в составе группы событий без лидера
• PERF_FLAG_FD_OUTPUT — перенаправить вывод от события к лидеру группы
• PERF_FLAG_PID_CGROUP — активировать мониторинг всей системы для каждого контейнера

recvmmsg

Получите несколько сообщений в сокете с помощью одного системного вызова.

int recvmmsg(int sockfd,структура mmsghdr *msgvec,беззнаковыйint влен,беззнаковыйint флаги,
структура время *тайм-аут)

• sockfd — файловый дескриптор сокета
• msgvec — указатель на массив mmsghdr структуры
• влен -размер msgvec множество
• флаги — указать флаги из recvmsg или укажите MSG_WAITFORONE активировать MSG_DONTWAIT после получения первого сообщения
• тайм-аут — указатель на время время ожидания определения структуры

Возвращает количество сообщений, полученных в msgvec об успехе.

fanotify_init

Создать группу fanotify.

int fanotify_init(беззнаковыйint флаги,беззнаковыйint event_f_flags)

• флаги — определяет дополнительные параметры
• event_f_flags — определяет флаги состояния файла, установленные для файловых дескрипторов, созданных для событий fanotify

В случае успеха возвращает новый файловый дескриптор.

флаги

• FAN_CLASS_PRE_CONTENT — разрешить получение событий, уведомляющих о доступе или попытке доступа к файлу, прежде чем он будет содержать окончательный контент
• FAN_CLASS_CONTENT — разрешить получение событий, уведомляющих о доступе или попытке доступа к файлу, содержащему окончательный контент
• FAN_REPORT_FID — разрешить получение событий, содержащих информацию о файловой системе, связанной с событием
• FAN_CLASS_NOTIF — значение по умолчанию, разрешающее только получение событий, уведомляющих о доступе к файлу

event_f_flags

• O_RDONLY — доступ только для чтения
• O_WRONLY — доступ только для записи
• O_RDWR — доступ для чтения / записи
• O_LARGEFILE — поддержка файлов размером более 2 ГБ
• O_CLOEXEC — включить флаг закрытия при запуске для файлового дескриптора

fanotify_mark

Добавить / удалить / изменить фантазировать отметка на файле.

int fanotify_mark(int fanotify_fd,беззнаковыйint флаги,uint64_t маска,
int dirfd,constchar*путь)

• fanotify_fd — дескриптор файла из fanotify_init
• флаги — определяет дополнительное поведение
• маска — маска файла
• dirfd — использование зависит от флаги и путь, видеть dirfd ниже

В случае успеха возвращает ноль.

dirfd

• Если путь является ЗНАЧЕНИЕ NULL, dirfd это дескриптор файла, который нужно пометить
• Если путь является ЗНАЧЕНИЕ NULL и dirfd является AT_FDCWD тогда текущий рабочий каталог помечается
• Если путь это абсолютный путь, dirfd игнорируется
• Если путь относительный путь и dirfd не является AT_FDCWD, потом путь и dirfd определить файл, который нужно пометить
• Если путь относительный путь и dirfd является AT_FDCWD, потом путь используется для определения файла, который нужно пометить

флаги

• FAN_MARK_ADD — события в маска добавляются для отметки или игнорирования маски
• FAN_MARK_REMOVE — события в маска удаляются из отметки или игнорируют маску
• FAN_MARK_FLUSH — удалить все маски для файловых систем, для монтирования или все отметки для файлов и каталогов из фантазировать группа
• FAN_MARK_DONT_FOLLOW — если путь это символическая ссылка, отметьте ссылку вместо файла, на который она ссылается
• FAN_MARK_ONLYDIR — если отмеченный объект не является каталогом, возникает ошибка
• FAN_MARK_MOUNT — отметить точку монтирования, указанную путь
• FAN_MARK_FILESYSTEM — пометить файловую систему, указанную путь
• FAN_MARK_IGNORED_MASK — события в маска будет добавлен или удален из маски игнорирования
• FAN_MARK_IGNORED_SURV_MODIFY — маска игнорирования переживет модифицирующие события
• FAN_ACCESS — создавать событие при обращении к файлу или директории
• FAN_MODIFY — создать событие при изменении файла
• FAN_CLOSE_WRITE — создать событие, когда файл, доступный для записи, закрыт
• FAN_CLOSE_NOWRITE — создать событие, когда файл доступен только для чтения или закрывается каталог
• FAN_OPEN — создать событие при открытии файла или каталога
• FAN_OPEN_EXEC — создать событие при открытии файла для выполнения
• FAN_ATTRIB — создать событие при изменении метаданных файла или каталога
• FAN_CREATE — создать событие, когда файл или каталог создается в отмеченном каталоге
• FAN_DELETE — создать событие при удалении файла или каталога в отмеченном каталоге
• FAN_DELETE_SELF — создавать событие при удалении отмеченного файла или каталога
• FAN_MOVED_FROM — создать событие, когда файл или каталог перемещается в отмеченный каталог
• FAN_MOVED_TO — создать событие, когда файл или каталог был перемещен в отмеченный каталог
• FAN_MOVE_SELF — создавать событие при перемещении отмеченного файла или каталога
• FAN_Q_OVERFLOW — создавать событие при переполнении очереди событий
• FAN_OPEN_PERM — создать событие, когда процесс запрашивает разрешение на открытие файла или каталога
• FAN_OPEN_EXEC_PERM — создать событие, когда процесс запрашивает разрешение на открытие файла для выполнения
• FAN_ACCESS_PERM — создать событие, когда процесс запрашивает разрешение на чтение файла или каталога
• FAN_ONDIR — создание событий для самих каталогов
• FAN_EVENT_ON_CHILD — создавать события, применяемые к непосредственным дочерним элементам отмеченных каталогов

name_to_handle_at

Возвращает дескриптор файла и идентификатор монтирования для файла, указанного dirfd и путь.

int name_to_handle_at(int dirfd,constchar*путь,структура file_handle
*справиться,int*mount_id,int флаги)

• dirfd — дескриптор файла каталога
• путь — указатель на строку с полным путем к файлу
• file_handle — указатель на file_handle структура
• mount_id — указатель на монтирование файловой системы, содержащий путь

Возвращает ноль в случае успеха и mount_id заселен.

open_by_handle_at

Открывает файл, соответствующий дескриптору, возвращаемому из name_to_handle_at системный вызов.

int open_by_handle_at(int mount_fd,структура file_handle *справиться,int флаги)

• mount_fd — дескриптор файла
• справиться — указатель на file_handle структура
• флаги — такие же флаги для открыто системный вызов

struct file_handle {unsigned int handle_bytes; / * размер f_handle (вход / выход) * / int handle_type; / * тип дескриптора (выход) * / unsigned char f_handle [0]; / * идентификатор файла (размер по вызывающему) (выход) * / };

Возвращает дескриптор файла.

syncfs

Очистить кеш файловой системы, указанный дескриптором файла.

int syncfs(int fd)

• fd — файловый дескриптор, находящийся на диске для очистки

В случае успеха возвращает ноль.

sendmmsg

Отправить несколько сообщений через сокет.

int sendmmsg(int sockfd,структура mmsghdr *msgvec,беззнаковыйint влен,int флаги)

• sockfd — файловый дескриптор, определяющий сокет
• msgvec — указатель на mmsghdr структура
• влен — количество сообщений для отправки
• флаги — флаги, определяющие операцию (то же, что и Отправить флаги)

struct mmsghdr {struct msghdr msg_hdr; / * заголовок сообщения * / unsigned int msg_len; / * байты для передачи * / };

Возвращает количество сообщений, отправленных из msgvec.

Setns

Повторно свяжите поток с пространством имен.

int Setns(int fd,int nstype)

• fd — дескриптор файла, определяющий пространство имен
• nstype — указать тип пространства имен (0 позволяет любое пространство имен)

В случае успеха возвращает ноль.

nsflag

• CLONE_NEWCGROUP — дескриптор файла должен ссылаться на пространство имен cgroup
• CLONE_NEWIPC — дескриптор файла должен ссылаться на пространство имен IPC
• CLONE_NEWNET — файловый дескриптор должен ссылаться на сетевое пространство имен
• CLONE_NEWNS — дескриптор файла должен ссылаться на пространство имен монтирования
• CLONE_NEWPID — дескриптор файла должен ссылаться на пространство имен потомков PID
• CLONE_NEWUSER — дескриптор файла должен ссылаться на пространство имен пользователя
• CLONE_NEWUTS — дескриптор файла должен ссылаться на пространство имен UTS

getcpu

Вернуть узел CPU / NUMA для вызова процесса или потока.

int getcpu(беззнаковый*ЦПУ,беззнаковый*узел,структура getcpu_cache *tcache)

• ЦПУ — указатель на номер процессора
• узел — указатель на номер узла NUMA
• tcache — установлен в NULL (больше не используется)

В случае успеха возвращает ноль.

process_vm_readv

Копирование данных между удаленным (другим) процессом и локальным (вызывающим) процессом.

ssize_t process_vm_readv(pid_t pid,constструктура iovec *local_iov,беззнаковыйдолго живой,
constструктура iovec *remote_iov,беззнаковыйдолго Rivcnt,беззнаковыйдолго флаги)

• пид — идентификатор исходного процесса
• local_iov — указатель на iovec структура с подробностями о локальном адресном пространстве
• живой — количество элементов в local_iov
• remote_iov — указатель на iovec структура с подробностями об удаленном адресном пространстве
• Rivcnt— количество элементов в remote_iov
• флаги — не используется, установлено на 0

Возвращает количество прочитанных байтов.

process_vm_writev

Скопируйте данные из локального (вызывающего) процесса в удаленный (другой) процесс.

ssize_t process_vm_writev(pid_t pid,constструктура iovec *local_iov,беззнаковыйдолго живой,
constструктура iovec *remote_iov,беззнаковыйдолго Rivcnt,беззнаковыйдолго флаги)

• пид — идентификатор исходного процесса
• local_iov — указатель на iovec структура с подробностями о локальном адресном пространстве
• живой — количество элементов в local_iov
• remote_iov — указатель на iovec структура с подробностями об удаленном адресном пространстве
• Rivcnt— количество элементов в remote_iov
• флаги — не используется, установлено на ноль

struct iovec {void * iov_base; / * начальный адрес * / size_t iov_len; / * байты для передачи * / };

Возвращает количество записанных байтов.

KCMP

Сравните два процесса, чтобы увидеть, разделяют ли они ресурсы в ядре.

int KCMP(pid_t pid1, pid_t pid2,int тип,беззнаковыйдолго idx1,беззнаковыйдолго idx2)

• pid1 — идентификатор первого процесса
• pid2 — второй идентификатор процесса
• тип — тип ресурса для сравнения
• idx1 — указатель ресурсов для конкретного флага
• idx2 — указатель ресурсов для конкретного флага

Возвращает ноль, если процессы используют один и тот же ресурс.

типовые флаги

• KCMP_FILE — проверить, указаны ли файловые дескрипторы в idx1 и idx2 разделяются обоими процессами
• KCMP_FILES — проверьте, используют ли два процесса один и тот же набор дескрипторов открытых файлов (idx1 и idx2 не используются)
• KCMP_FS — проверьте, имеют ли два процесса одну и ту же информацию о файловой системе (например, корень файловой системы, маска создания режима, рабочий каталог и т. Д.)
• KCMP_IO — проверить, используют ли процессы один и тот же контекст ввода-вывода
• KCMP_SIGHAND — проверить, используют ли процессы одну и ту же таблицу расположения сигналов
• KCMP_SYSVSEM — проверить, разделяют ли процессы одни и те же операции отмены семафоров
• KCMP_VM — проверить, разделяют ли процессы одно и то же адресное пространство
• KCMP_EPOLL_TFD — проверить, упоминается ли файловый дескриптор в idx1 процесса pid1 присутствует в эполл на который ссылается idx2 процесса pid2, куда idx2 это структура kcmp_epoll_slot описание целевого файла

struct kcmp_epoll_slot {__u32 efd; __u32 tfd; __u64 toff; }; 

finit_module

Загрузить модуль в ядро ​​с файлом модуля, заданным файловым дескриптором.

int finit_module(int fd,constchar*param_values,int флаги)

• fd — файловый дескриптор файла модуля ядра для загрузки
• param_values — указатель на строку с параметрами для ядра
• флаги — флаги загрузки модуля

В случае успеха возвращает ноль.

флаги

• MODULE_INIT_IGNORE_MODVERSIONS — игнорировать хеши версий символа
• MODULE_INIT_IGNORE_VERMAGIC — игнорировать магию версии ядра