getrlimit(2)

ИМЯ
getrlimit, setrlimit, prlimit - считывает/устанавливает ограничения использования ресурсов

LIBRARY
Standard C library (libc, -lc)

СИНТАКСИС
#include <sys/resource.h>

int getrlimit(int resource, struct rlimit *rlim);
int setrlimit(int resource, const struct rlimit *rlim);

int prlimit(pid_t pid, int resource,
            const struct rlimit *_Nullable new_limit,
            struct rlimit *_Nullable old_limit);

    Требования макроса тестирования свойств для glibc (см. feature_test_macros(7)):

prlimit():
    _GNU_SOURCE

ОПИСАНИЕ
Системные вызовы getrlimit() и setrlimit() получают и устанавливают ограничения использования ресурсов. Каждому ресурсу назначается мягкое и жёсткое ограничение, определяемое структурой rlimit:

    struct rlimit {
        rlim_t rlim_cur;  /* мягкое ограничение */
        rlim_t rlim_max;  /* жёсткое ограничение (максимум для rlim_cur) */
    };

Мягким ограничением является значение, принудительно устанавливаемое ядром для соответствующего ресурса. Жёсткое ограничение работает как максимальное значение для мягкого ограничения: непривилегированные процессы могут определять только свои мягкие ограничения в диапазоне от 0 до жёсткого ограничения, то есть однозначно меньше жёсткого ограничения. Привилегированные процессы (в Linux: имеющие мандат CAP_SYS_RESOURCE в начальном пространстве имён пользователя) могут устанавливать произвольные значения в любых пределах.

Значение RLIM_INFINITY означает отсутствие ограничений для ресурса (в структуре, возвращаемой getrlimit() и в структуре, передаваемой в setrlimit()).

Значение resource должно быть одним из:

RLIMIT_AS
    Максимальный размер виртуальной памяти (адресного пространства) процесса. Данное ограничение задаётся в байтах и округляется в меньшую сторону к размеру системной страницы. Учитывается в вызовах brk(2), mmap(2) и mremap(2), которые завершатся с ошибкой ENOMEM, если будет превышено это ограничение. К тому же завершается ошибкой автоматическое расширение стека (и генерируется сигнал SIGSEGV, по которому процесс завершится, если не было создано с помощью sigaltstack(2) альтернативного стека). Так как значение имеет тип long, на машинах с 32-битным long максимальное значение ограничения будет около 2 ГиБ, или этот ресурс не ограничивается.

RLIMIT_CORE
    Максимальный размер файла core (смотрите core(5)) в байтах, который может получиться из процесса. Если значение равно 0, то файлы core не создаются. Если значение больше нуля, то создаваемые дампы обрезаются до этого размера.

RLIMIT_CPU
    Ограничение времени выполнения процесса на ЦП в секундах. Когда процесс достигает своего мягкого ограничения, то ему отправляется сигнал SIGX CPU. Действием по умолчанию для этого сигнала является завершение процесса. Однако, этот сигнал может быть перехвачен, и обработчик может передать управление в основную программу. Если процесс продолжает потреблять процессорное время, то ему будет отправляться SIGXCPU раз в секунду до тех пор, пока не будет достигнуто жёсткое ограничение, и тогда процессу будет послан сигнал SIGKILL (последний пункт описывает поведение Linux. В разных реализациях действия над потребляющими процессорное время после прохождения мягкого ограничения процессами различаются. Переносимые приложения, где требуется перехват сигнала, должны выполнять корректное завершение процесса после первого получения SIGXCPU).

RLIMIT_DATA
    Максимальный размер сегмента данных процесса (инициализированные данные, неинициализированные данные, куча). Данное ограничение задаётся в байтах и округляется в меньшую сторону к размеру системной страницы. Это ограничение учитывается в вызовах brk(2), sbrk(2) и (начиная с Linux 4.7) mmap(2), которые завершатся с ошибкой ENOMEM при достижении мягкого ограничения этого ресурса.

RLIMIT_FSIZE
    Максимальный размер (в байтах) файлов, создаваемых процессом. Попытки расширить файл сверх этого ограничения приведёт к доставке сигнала SIGXFSZ. По умолчанию по этому сигналу процесс завершается, но процесс может перехватить этот сигнал и в этом случае выполнявшийся системный вызов (например, write(2), truncate(2)) завершится с ошибкой EFBIG.

RLIMIT_LOCKS (Linux 2.4.0 to Linux 2.4.24)
    Ограничение на общее количество блокировок flock(2) и аренд fcntl(2), которое может установить процесс.

RLIMIT_MEMLOCK
    Максимальное количество байт памяти, которое может быть заблокировано в ОЗУ. В целях эффективности это ограничение округляется в меньшую сторону до ближайшего значения, кратного размеру системной страницы. Это ограничение учитывается в mlock(2), mlockall(2) и в mmap(2) при операции MAP_LOCKED. Начиная с Linux 2.6.9, оно также учитывается в shmctl(2) при операции SHM_LOCK, где определяет максимальное количество байт всех общих сегментов памяти (смотрите shmget(2)), которые могут быть заблокированы вызывающим процессом с реальным идентификатором пользователя. Блокировки по операции SHM_LOCK у shmctl(2) учитываются отдельно от попроцессных блокировок памяти, устанавливаемых mlock(2), mlockall(2) и mmap(2) с операцией MAP_LOCKED; процесс может заблокировать пространство до этого значения заданного ограничения байт в каждой из этих двух категорий.

    Before Linux 2.6.9, this limit controlled the amount of memory that could be locked by a privileged process. Since Linux 2.6.9, no limits are placed on the amount of memory that a privileged process may lock, and this limit instead governs the amount of memory that an unprivileged process may lock.

RLIMIT_MSGQUEUE (начиная с Linux 2.6.8)
    Ограничение на количество байт, которое может выделяться для очередей сообщений POSIX для вызывающего процесса с реальным идентификатором пользователя. Это ограничение учитывается в mq_open(3). Каждая очередь сообщений, которую создаёт пользователь, учитывается (пока не будет удалена) в формуле:

        Начиная Linux 3.5:

            bytes = attr.mq_maxmsg * sizeof(struct msg_msg) +
                    MIN(attr.mq_maxmsg, MQ_PRIO_MAX) *
                          sizeof(struct posix_msg_tree_node)+
                                    /* издержки */
                    attr.mq_maxmsg * attr.mq_msgsize;
                                    /* данные из сообщения */

        Linux версии 3.4 и более ранние:

            bytes = attr.mq_maxmsg * sizeof(struct msg_msg *) +
                                    /* издержки */
                    attr.mq_maxmsg * attr.mq_msgsize;
                                    /* данные из сообщения */

    где attr — структура mq_attr, указанная в четвёртом аргументе mq_open(3), а msg_msg и posix_msg_tree_node — внутренние структуры ядра.

    Дополнение «издержки» (overhead) в формуле нужно учитывает байты расходов требуемые в реализации на то, чтобы пользователь не смог создать бесконечное количество сообщений нулевой длины (для таких сообщений, тем не менее, потребляется системная память для учёта использования системных ресурсов).

RLIMIT_NICE (начиная с Linux 2.6.12, см. ДЕФЕКТЫ далее)
    Определяет максимум, до которого может быть увеличено значение уступчивости процесса с помощью setpriority(2) или nice(2). Действительный максимум значения уступчивости высчитывается по формуле: 20 - rlim_cur. Полезным диапазоном этого ограничения являются значения от 1 (соответствует значению уступчивости 19) до 40 (соответствует значению уступчивости -20). Так пришлось поступить из-за того, что отрицательные числа нельзя указывать в значениях ограничений ресурсов, так как они, обычно, имеют специальное предназначение. Например, RLIM_INFINITY, обычно равно -1. Более подробно о значениях уступчивости описано в sched(7).

RLIMIT_NOFILE
    Определяет значение, на 1 больше максимального количества дескрипторов файлов, которое может открыть этот процесс. Попытки (open(2), pipe(2), dup(2) и т.п.) превысить это ограничение приведут к ошибке EMFILE (раньше это ограничение в BSD называлось RLIMIT_OFILE).

    Начиная с Linux 4.5, это ограничение также определяет максимальное количество файловых дескрипторов, которое непривилегированный процесс (не имеющий мандата CAP_SYS_RESOURCE) может держать «пересылать» (in flight) другим процессам через доменные сокеты UNIX. Данное ограничение применяется только к системному вызову sendmsg(2). Дополнительную информацию смотрите в unix(7).

RLIMIT_NPROC
    Ограничивает количество живущих (extant) процессов (или, более точно для Linux, нитей), для реального идентификатора пользователя вызывающего процесса. Как только текущее количество процессов, принадлежащих реальному идентификатору пользователя вызывающего процесса, станет больше или равно этому ограничению fork(2) начнёт завершаться с ошибкой EAGAIN.

    The RLIMIT_NPROC limit is not enforced for processes that have either the CAP_SYS_ADMIN or the CAP_SYS_RESOURCE capability, or run with real user ID 0.

RLIMIT_RSS
    Максимальное ограничение (в байтах) размера постоянного присутствия процесса (числа виртуальных страниц, постоянно присутствующих в ОЗУ). Это ограничение учитывается только начиная с версии Linux 2.4.x, x < 30, и только в вызовах madvise(2) со значением MADV_WILLNEED.

RLIMIT_RTPRIO (начиная с Linux 2.6.12, смотрите ДЕФЕКТЫ)
    Определяет максимум для приоритета реального времени, который можно установить для процесса с помощью sched_setscheduler(2) и sched_setparam(2).

    Дополнительную информацию об алгоритмах планирования реального времени смотрите в sched(7).

RLIMIT_RTTIME (начиная с Linux 2.6.25)
    Определяет ограничение (в микросекундах) на количество времени ЦП, которое процесс может быть запланирован выполняться в условиях реального времени без выполнения блокирующего системного вызова. Для работы ограничения, всякий раз когда процесс делает блокирующий системный вызов счётчик использованного времени ЦП сбрасывается в ноль. Счётчик времени ЦП не сбрасывается, если процесс продолжает пытаться использовать ЦП, но был вытеснен, его выделенное время на исполнение истекло или он вызвал sched_yield(2).

    При достижении мягкого ограничения процессу посылается сигнал SIGXCPU. Если процесс перехватил сигнал, проигнорировал его и продолжает потреблять время ЦП, то раз в секунду будет генерироваться сигнал SIGXCPU до тех пор, пока не будет достигнуто жёсткое ограничение, и процессу не будет послан сигнал SIGKILL.

    Это ограничение предназначено для предотвращения блокировки системы вышедшими из под контроля процессами реального времени.

    Дополнительную информацию об алгоритмах планирования реального времени смотрите в sched(7).

RLIMIT_SIGPENDING (начиная с Linux 2.6.8)
    Определяет ограничение на количество сигналов, которые могут быть поставлены в очередь вызывающего процесса с реальным пользовательским идентификатором. При проверке ограничения учитываются обычные сигналы и сигналы реального времени. Однако ограничение учитывается только в sigqueue(3); всегда возможно использовать kill(2) для постановки в очередь любого сигнала, которого ещё нет в очереди процесса.

RLIMIT_STACK
    Максимальный размер стека процесса в байтах. При достижении этого ограничения генерируется сигнал SIGSEGV. Для обработки этого сигнала процесс должен использовать альтернативный стек сигналов (sigaltstack(2)).

    Начиная с Linux 2.6.23, это ограничение также определяет количество места, используемого для аргументов командной строки процесса и его переменных окружения; подробней об этом смотрите в execve(2).

  prlimit()
Системный вызов prlimit(), который есть только в Linux объединяет и расширяет функции setrlimit() и getrlimit(). Он может использоваться для задания и получения ограничений ресурсов произвольного процесса.

Аргумент resource имеет тот же смысл что и в setrlimit() и getrlimit().

Если значение аргумента new_limit не равно NULL, то структура rlimit, на которую он указывает, используется для задания новых значений мягкий и жёстких ограничений для resource. Если значение аргумента old_limit не равно NULL, то успешный вызов prlimit() помещает текущие значения мягких и жёстких ограничений для resource в структуру rlimit, на которую указывает old_limit.

В аргументе pid задаётся идентификатор процесса с которым работает вызов. Если pid равно 0, то вызов применяется к вызывающему процессу. Для установки и получения ресурсов не своего процесса, вызывающий должен иметь мандат CAP_SYS_RESOURCE в пользовательском пространстве имён процесса, ограничения ресурсов которого изменяются или реальный, эффективный и сохранённый идентификатор пользователя процесса назначения должен совпадать с реальным идентификатором пользователя вызывающего и реальный, эффективный и сохранённый идентификатор группы процесса назначения должны совпадать с реальным идентификатором группы вызывающего.

ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ
On success, these system calls return 0. On error, -1 is returned, and errno is set to indicate the error.

ОШИБКИ

EFAULT
    Аргумент-указатель указывает за пределы доступного адресного пространства.

EINVAL
    Указано некорректное значение resource; или для setrlimit() или prlimit(): rlim->rlim_cur больше чем rlim->rlim_max.

EPERM
    Непривилегированный процесс пытался увеличить жёсткое ограничение; для этого требуется мандат CAP_SYS_RESOURCE.

EPERM
    Вызывающий пытался увеличить жёсткое ограничение RLIMIT_NOFILE, превышая максимум, заданный в /proc/sys/fs/nr_open (смотрите proc(5)).

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

ESRCH
    Не удалось найти процесс с идентификатором, указанном в pid.

ВЕРСИИ
Системный вызов prlimit() появился в Linux 2.6.36. Поддержка в glibc доступна начиная с версии 2.13.

АТРИБУТЫ
Описание терминов данного раздела смотрите в attributes(7).
Интерфейс | Атрибут | Значение
getrlimit(), setrlimit(), prlimit() | Безвредность в нитях | MT-Safe

СТАНДАРТЫ
getrlimit(), setrlimit(): POSIX.1-2001, POSIX.1-2008, SVr4, 4.3BSD.

prlimit(): только в Linux.

Ограничение RLIMIT_MEMLOCK и RLIMIT_NPROC появились из BSD и их нет в POSIX.1; они есть в BSD и Linux, но реализации несколько различны. Ограничение RLIMIT_RSS появилось из BSD и его нет в POSIX.1; тем не менее оно есть в большинстве реализаций. Ограничения RLIMIT_MSGQUEUE, RLIMIT_NICE, RLIMIT_RTPRIO, RLIMIT_RTTIME и RLIMIT_SIGPENDING есть только в Linux.

ЗАМЕЧАНИЯ
Дочерний процесс, созданный fork(2), наследует ограничения ресурсов родителя. Ограничения ресурсов сохраняются при execve(2).

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

Уменьшение мягкого ограничения ресурса ниже текущего потребления процесса будет выполнено (но в дальнейшем процесс не сможет увеличить потребление ресурса).

Ограничения ресурсов интерпретатора командной строки можно устанавливать с помощью встроенной команды ulimit (limit в csh(1)). Ограничения ресурсов интерпретатора наследуются дочерними процессами, которые он создаёт при выполнении команд.

Начиная с Linux 2.6.24, ограничения ресурсов любого процесса можно узнать с помощью /proc/pid/limits; смотрите proc(5).

В старых системах была функция vlimit() с подобным setrlimit() назначением. Для обратной совместимости в glibc также есть функция vlimit(). Во всех новых приложениях должен быть использован setrlimit().

  Отличия между библиотекой C и ABI ядра
Since glibc 2.13, the glibc getrlimit() and setrlimit() wrapper functions no longer invoke the corresponding system calls, but instead employ prlimit(), for the reasons described in BUGS.

Обёрточная функция в glibc называется prlimit(); нижележащий системный вызов называется prlimit64().

ДЕФЕКТЫ
In older Linux kernels, the SIGXCPU and SIGKILL signals delivered when a process encountered the soft and hard RLIMIT_CPU limits were delivered one (CPU) second later than they should have been. This was fixed in Linux 2.6.8.

In Linux 2.6.x kernels before Linux 2.6.17, a RLIMIT_CPU limit of 0 is wrongly treated as "no limit" (like RLIM_INFINITY). Since Linux 2.6.17, setting a limit of 0 does have an effect, but is actually treated as a limit of 1 second.

A kernel bug means that RLIMIT_RTPRIO does not work in Linux 2.6.12; the problem is fixed in Linux 2.6.13.

In Linux 2.6.12, there was an off-by-one mismatch between the priority ranges returned by getpriority(2) and RLIMIT_NICE. This had the effect that the actual ceiling for the nice value was calculated as 19 - rlim_cur. This was fixed in Linux 2.6.13.

Начиная с Linux 2.6.12, если процесс имеет мягкое ограничение RLIMIT_CPU и установлен обработчик для SIGXCPU, то, помимо вызова обработчика сигнала, ядро увеличивает мягкое ограничение на одну секунду. Такое поведение повторяется, если процесс продолжает потреблять процессорное время, и происходит это до тех пор, пока не будет достигнуто жёсткое ограничение, после чего процесс будет завершён. В других реализациях мягкое ограничение RLIMIT_CPU не меняется подобным образом, и поведение Linux, вероятно, нестандартно; переносимые приложения не должны полагаться на данную специфику Linux. Ограничение Linux RLIMIT_RTTIME демонстрирует такое же поведение, при исчерпании мягкого ограничения.

Kernels before Linux 2.4.22 did not diagnose the error EINVAL for setrlimit() when rlim->rlim_cur was greater than rlim->rlim_max.

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

  Представление «больших» значений ограничений ресурсов на 32-битных платформах
The glibc getrlimit() and setrlimit() wrapper functions use a 64-bit rlim_t data type, even on 32-bit platforms. However, the rlim_t data type used in the getrlimit() and setrlimit() system calls is a (32-bit) unsigned long. Furthermore, in Linux, the kernel represents resource limits on 32-bit platforms as unsigned long. However, a 32-bit data type is not wide enough. The most pertinent limit here is RLIMIT_FSIZE, which specifies the maximum size to which a file can grow: to be useful, this limit must be represented using a type that is as wide as the type used to represent file offsets—that is, as wide as a 64-bit off_t (assuming a program compiled with _FILE_OFFSET_BITS=64).

Если программа пытается задать ограничение ресурса значением, большим чем можно представить 32-битным unsigned long, то, чтобы обойти это ограничение ядра, обёрточная функция glibc setrlimit() просто преобразует значение ограничения в RLIM_INFINITY. Иначе говоря, запрашиваемое назначение ограничения ресурса просто игнорируется.

Since glibc 2.13, glibc works around the limitations of the getrlimit() and setrlimit() system calls by implementing setrlimit() and getrlimit() as wrapper functions that call prlimit().

ПРИМЕРЫ
Представленная ниже программа показывает использование prlimit().

    #define _GNU_SOURCE
    #define _FILE_OFFSET_BITS 64
    #include <err.h>
    #include <stdint.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/resource.h>
    #include <time.h>

    int
    main(int argc, char *argv[])
    {
        pid_t          pid;
        struct rlimit  old, new;
        struct rlimit  *newp;

        if (!(argc == 2 || argc == 4)) {
            fprintf(stderr, "Использование: %s <pid> [<новое-мягкое-ограничение> "
                    "<новое-жёсткое-ограничение>]\n", argv[0]);
            exit(EXIT_FAILURE);
        }

        pid = atoi(argv[1]);        /* PID процесса назначения */

        newp = NULL;
        if (argc == 4) {
            new.rlim_cur = atoi(argv[2]);
            new.rlim_max = atoi(argv[3]);
            newp = &new;
        }

        /* Установить ограничение на время ЦП процесса назначения;
           получить и показать предыдущее ограничение */

        if (prlimit(pid, RLIMIT_CPU, newp, &old) == -1)
            err(EXIT_FAILURE, "prlimit-1");
        printf("Previous limits: soft=%jd; hard=%jd\n",
               (intmax_t) old.rlim_cur, (intmax_t) old.rlim_max);

        /* Получить и показать новое ограничение времени ЦП */

        if (prlimit(pid, RLIMIT_CPU, NULL, &old) == -1)
            err(EXIT_FAILURE, "prlimit-2");
        printf("New limits: soft=%jd; hard=%jd\n",
               (intmax_t) old.rlim_cur, (intmax_t) old.rlim_max);

        exit(EXIT_SUCCESS);
    }

СМ. ТАКЖЕ
prlimit(1), dup(2), fcntl(2), fork(2), getrusage(2), mlock(2), mmap(2), open(2), quotactl(2), sbrk(2), shmctl(2), malloc(3), sigqueue(3), ulimit(3), core(5), capabilities(7), cgroups(7), credentials(7), signal(7)

ПЕРЕВОД
Русский перевод этой страницы руководства был сделан Azamat Hackimov <azamat.hackimov@gmail.com>, Dmitry Bolkhovskikh <d20052005@yandex.ru>, Vladislav <ivladislavefimov@gmail.com>, Yuri Kozlov <yuray@komyakino.ru> и Иван Павлов <pavia00@gmail.com>

Этот перевод является бесплатной документацией; прочитайте Стандартную общественную лицензию GNU версии 3 (https://www.gnu.org/licenses/gpl-3.0.html) или более позднюю, чтобы узнать об условиях авторского права. Мы не несем НИКАКОЙ ОТВЕТСТВЕННОСТИ.

Если вы обнаружите ошибки в переводе этой страницы руководства, пожалуйста, отправьте электронное письмо на man-pages-ru-talks@lists.sourceforge.net.