.\" -*- coding: UTF-8 -*-
'\" t
.\" Copyright (c) 1992 Drew Eckhardt, March 28, 1992
.\" and Copyright (c) 2002, 2004, 2005, 2008, 2010 Michael Kerrisk
.\"
.\" SPDX-License-Identifier: Linux-man-pages-copyleft
.\"
.\" Modified by Michael Haardt <michael@moria.de>
.\" Modified 1993-07-23 by Rik Faith <faith@cs.unc.edu>
.\" Modified 1996-01-13 by Arnt Gulbrandsen <agulbra@troll.no>
.\" Modified 1996-01-22 by aeb, following a remark by
.\"          Tigran Aivazian <tigran@sco.com>
.\" Modified 1996-04-14 by aeb, following a remark by
.\"          Robert Bihlmeyer <robbe@orcus.ping.at>
.\" Modified 1996-10-22 by Eric S. Raymond <esr@thyrsus.com>
.\" Modified 2001-05-04 by aeb, following a remark by
.\"          Håvard Lygre <hklygre@online.no>
.\" Modified 2001-04-17 by Michael Kerrisk <mtk.manpages@gmail.com>
.\" Modified 2002-06-13 by Michael Kerrisk <mtk.manpages@gmail.com>
.\"     Added note on nonstandard behavior when SIGCHLD is ignored.
.\" Modified 2002-07-09 by Michael Kerrisk <mtk.manpages@gmail.com>
.\"	Enhanced descriptions of 'resource' values
.\" Modified 2003-11-28 by aeb, added RLIMIT_CORE
.\" Modified 2004-03-26 by aeb, added RLIMIT_AS
.\" Modified 2004-06-16 by Michael Kerrisk <mtk.manpages@gmail.com>
.\"     Added notes on CAP_SYS_RESOURCE
.\"
.\" 2004-11-16 -- mtk: the getrlimit.2 page, which formally included
.\" coverage of getrusage(2), has been split, so that the latter
.\" is now covered in its own getrusage.2.
.\"
.\" Modified 2004-11-16, mtk: A few other minor changes
.\" Modified 2004-11-23, mtk
.\"	Added notes on RLIMIT_MEMLOCK, RLIMIT_NPROC, and RLIMIT_RSS
.\"		to "CONFORMING TO"
.\" Modified 2004-11-25, mtk
.\"	Rewrote discussion on RLIMIT_MEMLOCK to incorporate kernel
.\"		2.6.9 changes.
.\"	Added note on RLIMIT_CPU error in older kernels
.\" 2004-11-03, mtk, Added RLIMIT_SIGPENDING
.\" 2005-07-13, mtk, documented RLIMIT_MSGQUEUE limit.
.\" 2005-07-28, mtk, Added descriptions of RLIMIT_NICE and RLIMIT_RTPRIO
.\" 2008-05-07, mtk / Peter Zijlstra, Added description of RLIMIT_RTTIME
.\" 2010-11-06, mtk: Added documentation of prlimit()
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH getrlimit 2 "17 czerwca 2024 r." "Linux man\-pages 6.9.1" 
.SH NAZWA
getrlimit, setrlimit, prlimit \- pobiera/ustawia limity zasobów
.SH BIBLIOTEKA
Standardowa biblioteka C (\fIlibc\fP, \fI\-lc\fP)
.SH SKŁADNIA
.nf
\fB#include <sys/resource.h>\fP
.P
\fBint getrlimit(int \fP\fIresource\fP\fB, struct rlimit *\fP\fIrlim\fP\fB);\fP
\fBint setrlimit(int \fP\fIresource\fP\fB, const struct rlimit *\fP\fIrlim\fP\fB);\fP
.P
\fBint prlimit(pid_t \fP\fIpid\fP\fB, int \fP\fIresource\fP\fB,\fP
\fB            const struct rlimit *_Nullable \fP\fInew_limit\fP\fB,\fP
\fB            struct rlimit *_Nullable \fP\fIold_limit\fP\fB);\fP
.P
.fi
.EX
\fBstruct rlimit {\fP
\fB    rlim_t  rlim_cur;\fP  /* ograniczenie miękkie */
\fB    rlim_t  rlim_max;\fP  /* ogr. sztywne (górna granica rlim_cur) */
\fB};\fP
.EE
.nf
.P
\fBtypedef\fP /* ... */  \fBrlim_t;\fP  /* Typ: liczba całkowita bez znaku */
.fi
.P
.RS -4
Wymagane ustawienia makr biblioteki glibc (patrz \fBfeature_test_macros\fP(7)):
.RE
.P
\fBprlimit\fP():
.nf
    _GNU_SOURCE
.fi
.SH OPIS
Wywołania systemowe \fBgetrlimit\fP() i \fBsetrlimit\fP() pobierają i ustawiają
limity zasobów. Z każdym z zasobów stowarzyszone jest miękkie i sztywne
ograniczenie zdefiniowane w strukturze \fBrlimit\fP.
.P
Ograniczenie miękkie jest wartością odpowiedniego zasobu wymuszoną przez
jądro. Ograniczenie sztywne działa jako górna granica dla ograniczenia
miękkiego: proces nieuprzywilejowany może sobie ustawić ograniczenie miękkie
tylko w zakresie od 0 do ograniczenia sztywnego oraz (nieodwracalnie)
obniżyć swoje ograniczenie sztywne. Proces uprzywilejowany (w Linuksie:
proces z przywilejem \fBCAP_SYS_RESOURCE\fP (ang. capability) w swojej
pierwotnej przestrzeni nazw użytkownika) może dowolnie zmieniać każdą z
wartości ograniczenia.
.P
Wartość \fBRLIM_INFINITY\fP określa brak ograniczenia dla zasobu (zarówno w
strukturze zwracanej przez \fBgetrlimit\fP(), jak i w strukturze przekazywanej
do \fBsetrlimit\fP()).
.P
Argument \fIresource\fP musi być jednym z:
.TP 
\fBRLIMIT_AS\fP
.\" since Linux 2.0.27 / Linux 2.1.12
Jest to maksymalny rozmiar pamięci wirtualnej procesu (przestrzeni
adresowej). Limit jest określony w bajtach i zaokrąglony w dół, do
systemowego rozmiaru strony. Limit dotyczy wywołań do \fBbrk\fP(2), \fBmmap\fP(2)
i \fBmremap\fP(2), które po jego przekroczeniu zawiodą z błędem
\fBENOMEM\fP. Dodatkowo, zawiedzie automatyczne rozszerzenie stosu (i
wygeneruje sygnał \fBSIGSEGV\fP zabijający proces, jeśli za pomocą
\fBsigaltstack\fP(2) nie stał się dostępny alternatywny stos).  Ze względu na
to, że wartość ta ma typ \fIlong\fP, na komputerach z 32\-bitowym \fIlong\fP limit
ten wynosi co najwyżej 2\ GiB lub zasób ten jest nieograniczony.
.TP 
\fBRLIMIT_CORE\fP
Maksymalny rozmiar pliku \fIcore\fP (zob. \fBcore\fP(5)) w bajtach, który może
zrzucić proces. Wartość 0 oznacza, że pliki zrzutu nie są tworzone. Gdy
wartość jest niezerowa, większe zrzuty są przycinane do wskazanego rozmiaru.
.TP 
\fBRLIMIT_CPU\fP
Limit, w sekundach, czasu procesora (CPU), jaki może użyć proces. Gdy proces
osiąga swoje ograniczenie miękkie, jest do niego wysyłany sygnał
\fBSIGXCPU\fP. Domyślną reakcją na ten sygnał jest przerwanie
procesu. Jednakże, sygnał może zostać przechwycony i procedura obsługi może
przekazać sterowanie do programu głównego. Jeśli proces nadal będzie używać
zasoby procesora, będzie do niego co sekundę wysyłany sygnał \fBSIGXCPU\fP aż
do osiągnięcia ograniczenia sztywnego, kiedy to wysyłany jest sygnał
\fBSIGKILL\fP. (Ostatni punkt opisuje zachowanie Linuksa. W zależności od
implementacji procesy kontynuujące używanie zasobów procesora po osiągnięciu
ograniczenia miękkiego są różnie traktowane. Aplikacje przenośne, które mają
potrzebę przechwycenia tego sygnału, powinny zakończyć się w sposób
kontrolowany w chwili otrzymaniu pierwszego \fBSIGXCPU\fP.)
.TP 
\fBRLIMIT_DATA\fP
.\" commits 84638335900f1995495838fe1bd4870c43ec1f67
.\" ("mm: rework virtual memory accounting"),
.\" f4fcd55841fc9e46daac553b39361572453c2b88
.\" (mm: enable RLIMIT_DATA by default with workaround for valgrind).
Maksymalny rozmiar segmentu danych procesu (dane zainicjowane, dane
niezainicjowane i sterta). Limit jest podawany w bajtach i jest zaokrąglany
w dół, do systemowego rozmiaru strony. Ograniczenie to wpływa na wywołania
\fBbrk\fP(2), \fBsbrk\fP(2) i (od Linuksa 4.7) \fBmmap\fP(2), które kończą się
niepomyślnie, zgłaszając błąd \fBENOMEM\fP w momencie natrafienia na miękkie
ograniczenie tego zasobu.
.TP 
\fBRLIMIT_FSIZE\fP
Maksymalny rozmiar plików w bajtach, jakie może utworzyć dany proces. Próba
rozszerzenia pliku ponad to ograniczenie kończy się otrzymaniem sygnału
\fBSIGXFSZ\fP. Domyślnie, sygnał ten kończy działanie procesu, ale proces może
go przechwycić. Wówczas odpowiednia funkcja systemowa (np. \fBwrite\fP(2),
\fBtruncate\fP(2)) kończy się błędem \fBEFBIG\fP.
.TP 
\fBRLIMIT_LOCKS\fP (Linux 2.4.0 do Linuksa 2.4.24)
.\" to be precise: Linux 2.4.0-test9; no longer in Linux 2.4.25 / Linux 2.5.65
Ograniczenie łącznej liczby blokad \fBflock\fP(2) i dzierżaw \fBfcntl\fP(2), które
może ustanowić proces.
.TP 
\fBRLIMIT_MEMLOCK\fP
Maksymalna liczba bajtów pamięci, które mogą być zablokowane w RAM. Limit
jest w praktyce zaokrąglany w dół do najbliższej wielokrotności systemowego
rozmiaru strony. Limit dotyczy \fBmlock\fP(2), \fBmlockall\fP(2) oraz operacji
\fBMAP_LOCKED\fP \fBmmap\fP(2). Od Linuksa 2.6.9, limit dotyczy również operacji
\fBSHM_LOCK\fP \fBshmctl\fP(2), gdzie ustawia maksymalną sumę bajtów segmentów
pamięci dzielonej (zob. \fBshmget\fP(2)), które mogą być zablokowane przez
rzeczywisty identyfikator użytkownika procesu wywołującego. Blokady
\fBSHM_LOCK\fP \fBshmctl\fP(2) są liczone oddzielnie od blokad pamięci na proces,
ustanowionych przez \fBmlock\fP(2), \fBmlockall\fP(2) i \fBMAP_LOCKED\fP \fBmmap\fP(2);
proces może zablokować bajty do tego limitu w każdej z tych dwóch kategorii.
.IP
Przed Linuksem 2.6.9, limit ten kontrolował wielkość pamięci, która mogła
być zablokowana przez proces uprzywilejowany. Od Linuksa 2.6.9, na wielkość
pamięci, jaka może być zablokowana przez proces uprzywilejowany nie są
nakładane limity, a opisywany limit dotyczy w zamian procesów
nieuprzywilejowanych.
.TP 
\fBRLIMIT_MSGQUEUE\fP (od Linuksa 2.6.8)
Limit liczby bajtów, które mogą być przydzielone kolejkom komunikatów POSIX
dla rzeczywistego identyfikatora użytkownika procesu wywołującego. Limit ten
jest wymuszony na \fBmq_open\fP(3). Każda kolejka komunikatów, którą tworzy
użytkownika wlicza się do tego limitu (do momentu jej usunięcia) zgodnie ze
wzorem:
.RS 4
.IP
Od Linuksa 3.5:
.IP
.in +4n
.EX
bytes = attr.mq_maxmsg * sizeof(struct msg_msg) +
        MIN(attr.mq_maxmsg, MQ_PRIO_MAX) *
              sizeof(struct posix_msg_tree_node)+
                     /* Do narzutu */
        attr.mq_maxmsg * attr.mq_msgsize;
                     /* Do danych komunikatów */
.EE
.in
.IP
Linux 3.4 i wcześniejsze:
.IP
.in +4n
.EX
bytes = attr.mq_maxmsg * sizeof(struct msg_msg *) +
                     /* Do narzutu */
        attr.mq_maxmsg * attr.mq_msgsize;
                     /* Do danych komunikatów */
.EE
.in
.RE
.IP
gdzie \fIattr\fP jest strukturą \fImq_attr\fP określoną jako czwarty argument do
\fBmq_open\fP(3), a struktury \fImsg_msg\fP i \fIposix_msg_tree_node\fP są
wewnętrznymi strukturami jądra.
.IP
Składowa \[Bq]narzutu\[rq] we wzorze bierze pod uwagę bajty narzutu wymagane
przez implementację i zapewnia, że użytkownik nie może utworzyć
nieskończonej liczby komunikatów o zerowej długości (takie komunikaty wciąż
zajmują nieco pamięci systemowej ze względu na narzut księgowania).
.TP 
\fBRLIMIT_NICE\fP (od Linuksa 2.6.12, lecz zob. USTERKI poniżej)
Określa górną granicę, do której można zwiększyć wartość nice procesu za
pomocą \fBsetpriority\fP(2) lub \fBnice\fP(2). Rzeczywista górna granica jest
obliczana jako \fI20\ \-\ rlim_cur\fP. Użyteczny zakres tego limitu wynosi zatem
od 1 (co odpowiada wartości nice 19) do 40 (co odpowiada wartości nice
\-20). Ten nietypowy zakres był konieczny, ponieważ liczby ujemne nie mogą
stanowić wartości limitów zasobów, gdyż zwykle mają specjalne znaczenie. Na
przykład \fBRLIM_INFINITY\fP jest zwykle równoważne \-1. Więcej szczegółów na
temat wartości nice można znaleźć w podręczniku \fBsched\fP(7).
.TP 
\fBRLIMIT_NOFILE\fP
Określa wartość o jeden większą niż maksymalna liczba deskryptorów plików,
które dany proces może otworzyć. Próby (\fBopen\fP(), \fBpipe\fP(), \fBdup\fP() itd.)
przekroczenia tego limitu dają błąd \fBEMFILE\fP (historycznie limit ten nosił
nazwę \fBRLIMIT_OFILE\fP na BSD).
.IP
Od Linuksa 4.5, limit ten definiuje również maksymalną liczbę deskryptorów
pliku, jakie proces nieuprzywilejowany (bez przywileju \fBCAP_SYS_RESOURCE\fP
(ang. capability)) może mieć \[Bq]w locie\[rq] do innych procesów, przy
przekazywaniu za pomocą gniazd domeny Uniksa. Limit ten dotyczy wywołania
systemowego \fBsendmsg\fP(2). Więcej szczegółów w podręczniku \fBunix\fP(7).
.TP 
\fBRLIMIT_NPROC\fP
Limit liczby istniejących procesów (lub, precyzyjniej w Linuksie, wątków)
dla rzeczywistego identyfikatora użytkownika procesu wywołującego. Jeśli
liczba bieżących procesów, będących własnością rzeczywistego identyfikatora
użytkownika tego procesu, jest większa lub równa limitowi, \fBfork\fP()
zawiedzie z błędem \fBEAGAIN\fP.
.IP
Limit \fBRLIMIT_NPROC\fP nie jest wymuszany na procesach z przywilejem
\fBCAP_SYS_ADMIN\fP lub \fBCAP_SYS_RESOURCE\fP (ang. capability) i procesach z
rzeczywistym identyfikatorem użytkownika równym 0.
.TP 
\fBRLIMIT_RSS\fP
.\" As at Linux 2.6.12, this limit still does nothing in Linux 2.6 though
.\" talk of making it do something has surfaced from time to time in LKML
.\"       -- MTK, Jul 05
Limit (w bajtach) rezydentnych stron procesu (liczba stron pamięci
wirtualnej pozostających w RAM). Ograniczenie to działa tylko w Linuksie
2.4.x, gdzie x < 30, i dotyczy jedynie wywołań \fBmadvise\fP(2) z użyciem
\fBMADV_WILLNEED\fP.
.TP 
\fBRLIMIT_RTPRIO\fP (od Linuksa 2.6.12, lecz zob. USTERKI)
Górna granica, jaką można ustawić dla priorytetu czasu rzeczywistego, dla
danego procesu, za pomocą \fBsched_setscheduler\fP(2) i \fBsched_setparam\fP(2).
.IP
Więcej informacji o politykach szeregowania zadań czasu rzeczywistego
opisano w podręczniku \fBsched\fP(7).
.TP 
\fBRLIMIT_RTTIME\fP (od Linuksa 2.6.25)
Limit (w mikrosekundach) czasu procesora, jaki proces korzystający z
szeregowania zadań czasu rzeczywistego może użyć, bez czynienia blokującego
wywołania systemowego. Do celu tego limitu, za każdym razem, gdy proces
tworzy blokujące wywołanie systemowe, licznik użytego czasu procesora jest
resetowany do zera. Licznik czasu procesora nie jest resetowany, jeśli
proces kontynuuje próbę użycia procesora, lecz jest wywłaszczony,
przydzielona mu jednostka czasu wyczerpała się lub wywoła \fBsched_yield\fP(2).
.IP
Po osiągnięciu limitu miękkiego, do procesu wysyłany jest sygnał
\fBSIGXCPU\fP. Jeśli proces go przechwyci lub zignoruje i będzie kontynuował
używanie czasu procesora, sygnał \fBSIGXCPU\fP będzie generowany co sekundę, do
momentu osiągnięcia limitu sztywnego, gdy proces otrzyma sygnał \fBSIGKILL\fP.
.IP
Limit ten ma na celu zapobiegnięcie zablokowania systemu przez zbiegłe
procesy czasu rzeczywistego.
.IP
Więcej informacji o politykach szeregowania zadań czasu rzeczywistego
opisano w podręczniku \fBsched\fP(7).
.TP 
\fBRLIMIT_SIGPENDING\fP (od Linuksa 2.6.8)
.\" This replaces the /proc/sys/kernel/rtsig-max system-wide limit
.\" that was present in Linux <= 2.6.7.  MTK Dec 04
Limit liczby sygnałów, jakie mogą być zakolejkowane dla rzeczywistego
identyfikatora użytkownika procesu wywołującego. Do celu sprawdzania tego
limitu liczą się sygnały zwykłe i czasu rzeczywistego. Limit jest jednak
wymuszany jedynie dla \fBsigqueue\fP(3); można zawsze skorzystać z \fBkill\fP(2),
aby zakolejkować po jednym z każdego sygnału, który nie występuje w kolejce
do procesu.
.TP 
\fBRLIMIT_STACK\fP
Maksymalny rozmiar stosu procesu w bajtach. W chwili osiągnięcia tego
ograniczenia, generowany jest sygnał \fBSIGSEGV\fP. W celu obsłużenia tego
sygnału proces musi założyć alternatywny stos dla sygnałów
(\fBsigaltstack\fP(2)).
.IP
Od Linuksa 2.6.23, limit ten określa również wielkość przestrzeni używanej
dla argumentów wiersza polecenia oraz zmiennych środowiskowych procesu;
więcej szczegółów w podręczniku \fBexecve\fP(2).
.SS prlimit()
.\" commit c022a0acad534fd5f5d5f17280f6d4d135e74e81
.\" Author: Jiri Slaby <jslaby@suse.cz>
.\" Date:   Tue May 4 18:03:50 2010 +0200
.\"
.\"     rlimits: implement prlimit64 syscall
.\"
.\" commit 6a1d5e2c85d06da35cdfd93f1a27675bfdc3ad8c
.\" Author: Jiri Slaby <jslaby@suse.cz>
.\" Date:   Wed Mar 24 17:06:58 2010 +0100
.\"
.\"     rlimits: add rlimit64 structure
.\"
Typowo linuksowe wywołanie systemowe \fBprlimit\fP() łączy i rozszerza
funkcjonalność \fBsetrlimit\fP() i \fBgetrlimit\fP(). Można go używać do
ustawienia i pobrania limitów zasobów dowolnego procesu.
.P
Argument \fIresource\fP ma takie samo znaczenie jak w przypadku \fBsetrlimit\fP()
i \fBgetrlimit\fP().
.P
Jeśli argument \fInew_limit\fP nie wynosi NULL, to struktura \fIrlimit\fP, na
którą on wskazuje, jest używana do ustawienia nowych wartości limitów
miękkich i sztywnych \fIresource\fP. Jeśli argument \fIold_limit\fP nie wynosi
NULL, to pomyślne wywołanie \fBprlimit\fP() umieszcza poprzednie limity miękkie
i sztywne \fIresource\fP w strukturze \fIrlimit\fP, na którą wskazuje
\fIold_limit\fP.
.P
.\" FIXME . this permission check is strange
.\" Asked about this on LKML, 7 Nov 2010
.\"     "Inconsistent credential checking in prlimit() syscall"
Argument \fIpid\fP określa identyfikator procesu, na którym wywołanie ma
operować. Jeśli \fIpid\fP wynosi 0, to wywołanie stosuje się do procesu
wywołującego. Aby ustawić lub pobrać zasoby procesu innego niż własny,
wywołujący musi mieć przywilej \fBCAP_SYS_RESOURCE\fP (ang. capability) w
przestrzeni nazw użytkownika procesu, którego limity zasobów są zmieniane
lub identyfikatory: rzeczywisty, efektywny i zapisany suid procesu
docelowego muszą odpowiadać identyfikatorowi rzeczywistemu procesu
wywołującego \fIoraz\fP identyfikatory: rzeczywisty, efektywny i zapisany suid
procesu docelowego muszą odpowiadać rzeczywistemu identyfikatorowi grupy
wywołującego.
.SH "WARTOŚĆ ZWRACANA"
W przypadku powodzenia, te wywołania zwracają 0. W razie wystąpienia błędu
zwracane jest \-1 i ustawiane \fIerrno\fP, wskazując błąd.
.SH BŁĘDY
.TP 
\fBEFAULT\fP
Argument wskaźnika wskazuje na położenie poza dostępną przestrzeń adresową.
.TP 
\fBEINVAL\fP
WArtość określona w \fIresource\fP nie jest prawidłowa; albo \[em] w przypadku
\fBsetrlimit\fP() lub \fBprlimit\fP(): \fIrlim\->rlim_cur\fP był większy niż
\fIrlim\->rlim_max\fP.
.TP 
\fBEPERM\fP
Proces nieuprzywilejowany próbował zwiększyć limit sztywny; do dokonania
tego konieczny jest przywilej \fBCAP_SYS_RESOURCE\fP (ang. capability).
.TP 
\fBEPERM\fP
Wywołujący próbował zwiększyć limit sztywny \fBRLIMIT_NOFILE\fP ponad wartość
maksymalną określoną w \fI/proc/sys/fs/nr_open\fP (zob. \fBproc\fP(5))
.TP 
\fBEPERM\fP
(\fBprlimit\fP())  Proces wywołujący nie miał uprawnień do ustawiania limitów
dla procesu podanego w \fIpid\fP.
.TP 
\fBESRCH\fP
Nie udało się znaleźć procesu o identyfikatorze podanym w \fIpid\fP.
.SH ATRYBUTY
Informacje o pojęciach używanych w tym rozdziale można znaleźć w podręczniku
\fBattributes\fP(7).
.TS
allbox;
lbx lb lb
l l l.
Interfejs	Atrybut	Wartość
T{
.na
.nh
\fBgetrlimit\fP(),
\fBsetrlimit\fP(),
\fBprlimit\fP()
T}	Bezpieczeństwo wątkowe	MT\-bezpieczne
.TE
.SH STANDARDY
.TP 
\fBgetrlimit\fP()
.TQ
\fBsetrlimit\fP()
POSIX.1\-2008.
.TP 
\fBprlimit\fP()
Linux.
.P
\fBRLIMIT_MEMLOCK\fP i \fBRLIMIT_NPROC\fP pochodzą z BSD i nie są określone w
POSIX.1; są obecne w systemach BSD i Linux, ale z różnymi
implementacjami. \fBRLIMIT_RSS\fP pochodzi z BSD i nie jest określone w
POSIX.1; jest jednak obecne w większości implementacji.
\fB\%RLIMIT_MSGQUEUE\fP, \fBRLIMIT_NICE\fP, \fBRLIMIT_RTPRIO\fP, \fBRLIMIT_RTTIME\fP i
\fB\%RLIMIT_SIGPENDING\fP są typowo linuksowe.
.SH HISTORIA
.TP 
\fBgetrlimit\fP()
.TQ
\fBsetrlimit\fP()
POSIX.1\-2001, SVr4, 4.3BSD.
.TP 
\fBprlimit\fP()
Linux 2.6.36, glibc 2.13.
.SH UWAGI
Proces potomny utworzony za pomocą \fBfork\fP(2) dziedziczy limity zasobów
swojego procesu macierzystego. Limity zasobów są zachowywane przez
\fBexecve\fP(2).
.P
Limity zasobów są atrybutami przypisanymi procesowi i są dzielone przez
wszystkie wątki procesu.
.P
Zmniejszenie miękkiego limitu zasobu poniżej jego aktualnego użycia przez
proces powiedzie się (lecz zapobiegnie dalszemu zwiększeniu użycia zasobu
przez proces).
.P
Można ustawić limity zasobów powłoki za pomocą wbudowanego polecenia
\fIulimit\fP (\fIlimit\fP w \fBcsh\fP(1)). Limity zasobów powłoki są dziedziczone
przez procesy tworzone do wykonywania poleceń powłoki.
.P
Od Linuksa 2.6.24, limity zasobów dowolnego procesu można sprawdzić za
pomocą \fI/proc/\fPpid\fI/limits\fP; zob. \fBproc\fP(5).
.P
Dawne systemy udostępniały funkcję \fBvlimit\fP() o podobnym zastosowaniu do
\fBsetrlimit\fP(). Ze względu na kompatybilność wsteczną, glibc również
udostępnia \fBvlimit\fP(). Wszystkie nowe aplikacje powinny używać wyłącznie
\fBsetrlimit\fP().
.SS "Różnice ABI biblioteki C/jądra"
Od glibc 2.13, funkcje opakowujące \fBgetrlimit\fP() i \fBsetrlimit\fP() z glibc
nie przywołują już odpowiadających im wywołań systemowych, lecz używają
\fBprlimit\fP(), ze względów opisanych w USTERKACH.
.P
Nazwą opakowującej funkcji z glibc jest \fBprlimit\fP(); nazwą wywołania
systemowego jest \fBprlimit64\fP().
.SH USTERKI
W starszych jądrach Linux, sygnały \fBSIGXCPU\fP i \fBSIGKILL\fP dostarczane, gdy
proces napotkał miękkie i sztywne limity \fBRLIMIT_CPU\fP, dostarczano jedną
sekundę (procesorową) później, niż powinno to nastąpić. Poprawiono to w
Linuksie 2.6.8.
.P
.\" see http://marc.theaimsgroup.com/?l=linux-kernel&m=114008066530167&w=2
W jądrach Linux 2.6.x wcześniejszych niż Linux 2.6.17, limit \fBRLIMIT_CPU\fP
wynoszący 0 był nieprawidłowo traktowany jako \[Bq]brak limitu\[rq] (jak
\fBRLIM_INFINITY\fP). Od Linuksa 2.6.17, ustawienie limitu 0 jest stosowane,
ale faktycznie skutkuje limitem 1 sekundy.
.P
.\" See https://lwn.net/Articles/145008/
Błąd jądra powodował, że \fBRLIMIT_RTPRIO\fP nie działał w Linuksie 2.6.12;
problem poprawiono w Linuksie 2.6.13.
.P
.\" see http://marc.theaimsgroup.com/?l=linux-kernel&m=112256338703880&w=2
W Linuksie 2.6.12, istniała niezgodność o jeden pomiędzy zakresami
priorytetów zwracanymi przez \fBgetpriority\fP(2) i \fBRLIMIT_NICE\fP. Dawało te
efekt, że faktyczna górna granica wartości nice była obliczana jako \fI19\ \-\ rlim_cur\fP. Poprawiono to w Linuksie 2.6.13.
.P
.\" The relevant patch, sent to LKML, seems to be
.\" http://thread.gmane.org/gmane.linux.kernel/273462
.\" From: Roland McGrath <roland <at> redhat.com>
.\" Subject: [PATCH 7/7] make RLIMIT_CPU/SIGXCPU per-process
.\" Date: 2005-01-23 23:27:46 GMT
.\" Tested Solaris 10, FreeBSD 9, OpenBSD 5.0
.\" FIXME . https://bugzilla.kernel.org/show_bug.cgi?id=50951
Od Linuksa 2.6.12, jeśli proces osiąga swój miękki limit \fBRLIMIT_CPU\fP i
posiada procedurę obsługi \fBSIGXCPU\fP, to, oprócz przywołania procedury
obsługi, jądro zwiększa miękki limit o jedną sekundę. Zachowanie to powtarza
się, jeśli proces kontynuuje używanie czasu procesora, aż do osiągnięcia
limitu sztywnego, gdy proces jest zabijany. Inne implementacje nie zmieniają
miękkiego limitu \fBRLIMIT_CPU\fP w ten sposób, a zachowanie Linuksa
prawdopodobnie nie jest zgodne ze standardami; przenośne aplikacje powinny
unikać polegania na tym typowo linuksowym zachowaniu. Typowo linuksowy limit
\fBRLIMIT_RTTIME\fP działa w ten sam sposób, gdy osiągnie się miękki limit.
.P
.\" d3561f78fd379a7110e46c87964ba7aa4120235c
Jądra przed Linuksem 2.4.22 nie diagnozują błędu \fBEINVAL\fP w przypadku
\fBsetrlimit\fP(), gdy \fIrlim\->rlim_cur\fP było większe niż
\fIrlim\->rlim_max\fP.
.P
.\"
Ze względu na kompatybilność, Linux nie zwraca błędu, gdy próba ustawienia
\fBRLIMIT_CPU\fP zawodzi.
.SS "Reprezentacja \[Bq]dużych\[rq] wartości limitu zasobu na platformach 32\-bitowych"
.\" Linux still uses long for limits internally:
.\" c022a0acad534fd5f5d5f17280f6d4d135e74e81
.\" kernel/sys.c:do_prlimit() still uses struct rlimit which
.\" uses kernel_ulong_t for its members, i.e. 32-bit  on 32-bit kernel.
.\" https://bugzilla.kernel.org/show_bug.cgi?id=5042
.\" https://www.sourceware.org/bugzilla/show_bug.cgi?id=12201
Funkcje opakowujące \fBgetrlimit\fP() i \fBsetrlimit\fP() z glibc używają
64\-bitowego typu danych \fIrlim_t\fP, nawet na platformach
32\-bitowych. Jednakże typ danych \fIrlim_t\fP używany w wywołaniach systemowych
\fBgetrlimit\fP() i \fBsetrlimit\fP() jest (32\-bitowym) \fIunsigned long\fP. Co
więcej, w Linuksie jądro reprezentuje limit zasobów na platformach
32\-bitowych jako \fIunsigned long\fP. Jednak 32\-bitowy typ danych nie jest
wystarczająco szeroki. Najtrudniejsza sytuacja występuje odnośnie limitu
\fB\%RLIMIT_FSIZE\fP określającego maksymalny rozmiar, do jakiego może zostać
zwiększony plik: aby być użytecznym, limit ten musi być reprezentowany przez
typ, który jest tak szeroki, jak typ używany do reprezentowania przesunięć
pliku tj. tak szeroki jak 64\-bitowe \fBoff_t\fP (zakładając, że program
skompilowano z \fI_FILE_OFFSET_BITS=64\fP).
.P
Aby obejść to ograniczenie, w przypadku gdy program próbował ustawić limit
zasobów na wartość większą niż może być reprezentowana w 32\-bitowym
\fIunsigned long\fP, funkcja opakowująca \fBsetrlimit\fP() z glibc po cichu
konwertowała wartość limitu na \fBRLIM_INFINITY\fP. Innymi słowy, żądany limit
zasobów był po cichu ignorowany.
.P
.\" https://www.sourceware.org/bugzilla/show_bug.cgi?id=12201
OD glibc 2.13, glibc obchodzi to ograniczenie wywołań systemowych
\fB\%getrlimit\fP() i \fBsetrlimit\fP() implementując \fBsetrlimit\fP() i
\fB\%getrlimit\fP() jako funkcje opakowujące wywołujące \fBprlimit\fP().
.SH PRZYKŁADY
Poniższy program demonstruje użycie \fBprlimit\fP().
.P
.\" SRC BEGIN (getrlimit.c)
.EX
#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, "Użycie: %s <pid> [<nowy\-limit\-miękki> "
                "<nowy\-limit\-sztywny>]\[rs]n", argv[0]);
        exit(EXIT_FAILURE);
    }
\&
    pid = atoi(argv[1]);        /* PID procesu docelowego */
\&
    newp = NULL;
    if (argc == 4) {
        new.rlim_cur = atoi(argv[2]);
        new.rlim_max = atoi(argv[3]);
        newp = &new;
    }
\&
    /* Ustawia limit czasu procesora procesu docelowego; pobiera
       i wyświetla poprzedni limit */
\&
    if (prlimit(pid, RLIMIT_CPU, newp, &old) == \-1)
        err(EXIT_FAILURE, "prlimit\-1");
    printf("Poprzednie limity: miękki=%jd; sztywny=%jd\[rs]n",
           (intmax_t) old.rlim_cur, (intmax_t) old.rlim_max);
\&
    /* Pobiera i wyświetla nowy limit czasu procesora */
\&
    if (prlimit(pid, RLIMIT_CPU, NULL, &old) == \-1)
        err(EXIT_FAILURE, "prlimit\-2");
    printf("Nowe limity: miękki=%jd; sztywny=%jd\[rs]n",
           (intmax_t) old.rlim_cur, (intmax_t) old.rlim_max);
\&
    exit(EXIT_SUCCESS);
}
.EE
.\" SRC END
.SH "ZOBACZ TAKŻE"
\fBprlimit\fP(1), \fBdup\fP(2), \fBfcntl\fP(2), \fBfork\fP(2), \fBgetrusage\fP(2),
\fBmlock\fP(2), \fBmmap\fP(2), \fBopen\fP(2), \fBquotactl\fP(2), \fBsbrk\fP(2),
\fBshmctl\fP(2), \fBmalloc\fP(3), \fBsigqueue\fP(3), \fBulimit\fP(3), \fBcore\fP(5),
\fBcapabilities\fP(7), \fBcgroups\fP(7), \fBcredentials\fP(7), \fBsignal\fP(7)
.PP
.SH TŁUMACZENIE
Autorami polskiego tłumaczenia niniejszej strony podręcznika są:
Przemek Borys <pborys@dione.ids.pl>,
Andrzej Krzysztofowicz <ankry@green.mf.pg.gda.pl>
i
Michał Kułach <michal.kulach@gmail.com>
.
.PP
Niniejsze tłumaczenie jest wolną dokumentacją. Bliższe informacje o warunkach
licencji można uzyskać zapoznając się z
.UR https://www.gnu.org/licenses/gpl-3.0.html
GNU General Public License w wersji 3
.UE
lub nowszej. Nie przyjmuje się ŻADNEJ ODPOWIEDZIALNOŚCI.
.PP
Błędy w tłumaczeniu strony podręcznika prosimy zgłaszać na adres listy
dyskusyjnej
.MT manpages-pl-list@lists.sourceforge.net
.ME .
