.\" -*- 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 .\" Modified 1993-07-23 by Rik Faith .\" Modified 1996-01-13 by Arnt Gulbrandsen .\" Modified 1996-01-22 by aeb, following a remark by .\" Tigran Aivazian .\" Modified 1996-04-14 by aeb, following a remark by .\" Robert Bihlmeyer .\" Modified 1996-10-22 by Eric S. Raymond .\" Modified 2001-05-04 by aeb, following a remark by .\" Håvard Lygre .\" Modified 2001-04-17 by Michael Kerrisk .\" Modified 2002-06-13 by Michael Kerrisk .\" Added note on nonstandard behavior when SIGCHLD is ignored. .\" Modified 2002-07-09 by Michael Kerrisk .\" 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 .\" 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 \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 .\" Date: Tue May 4 18:03:50 2010 +0200 .\" .\" rlimits: implement prlimit64 syscall .\" .\" commit 6a1d5e2c85d06da35cdfd93f1a27675bfdc3ad8c .\" Author: Jiri Slaby .\" 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 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 #include #include #include #include #include \& 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 [ " "]\[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 Tłumaczenie niniejszej strony podręcznika: Przemek Borys , Andrzej Krzysztofowicz i Michał Kułach . .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 .