Provided by: manpages-pl-dev_4.23.1-1_all 
NAZWA
getrlimit, setrlimit, prlimit - pobiera/ustawia limity zasobów
BIBLIOTEKA
Standardowa biblioteka C (libc, -lc)
SKŁADNIA
#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);
Wymagane ustawienia makr biblioteki glibc (patrz feature_test_macros(7)):
prlimit():
_GNU_SOURCE
OPIS
Wywołania systemowe getrlimit() i setrlimit() pobierają i ustawiają limity zasobów. Z
każdym z zasobów stowarzyszone jest miękkie i sztywne ograniczenie zdefiniowane w
strukturze rlimit:
struct rlimit {
rlim_t rlim_cur; /* ograniczenie miękkie */
rlim_t rlim_max; /* ogr. sztywne (górna granica rlim_cur) */
};
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 CAP_SYS_RESOURCE (ang. capability) w
swojej pierwotnej przestrzeni nazw użytkownika) może dowolnie zmieniać każdą z wartości
ograniczenia.
Wartość RLIM_INFINITY określa brak ograniczenia dla zasobu (zarówno w strukturze zwracanej
przez getrlimit(), jak i w strukturze przekazywanej do setrlimit()).
Argument resource musi być jednym z:
RLIMIT_AS
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 brk(2), mmap(2) i mremap(2), które po jego przekroczeniu
zawiodą z błędem ENOMEM. Dodatkowo, zawiedzie automatyczne rozszerzenie stosu (i
wygeneruje sygnał SIGSEGV zabijający proces, jeśli za pomocą sigaltstack(2) nie
stał się dostępny alternatywny stos). Ze względu na to, że wartość ta ma typ long,
na komputerach z 32-bitowym long limit ten wynosi co najwyżej 2 GiB lub zasób ten
jest nieograniczony.
RLIMIT_CORE
Maksymalny rozmiar pliku core (zob. core(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.
RLIMIT_CPU
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ł SIGXCPU. 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ł
SIGXCPU aż do osiągnięcia ograniczenia sztywnego, kiedy to wysyłany jest sygnał
SIGKILL. (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 SIGXCPU.)
RLIMIT_DATA
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 brk(2), sbrk(2) i (od Linuksa
4.7) mmap(2), które kończą się niepomyślnie, zgłaszając błąd ENOMEM w momencie
natrafienia na miękkie ograniczenie tego zasobu.
RLIMIT_FSIZE
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 SIGXFSZ.
Domyślnie, sygnał ten kończy działanie procesu, ale proces może go przechwycić.
Wówczas odpowiednia funkcja systemowa (np. write(2), truncate(2)) kończy się błędem
EFBIG.
RLIMIT_LOCKS (Linux 2.4.0 do Linuksa 2.4.24)
Ograniczenie łącznej liczby blokad flock(2) i dzierżaw fcntl(2), które może
ustanowić proces.
RLIMIT_MEMLOCK
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 mlock(2), mlockall(2) oraz operacji MAP_LOCKED mmap(2). Od
Linuksa 2.6.9, limit dotyczy również operacji SHM_LOCK shmctl(2), gdzie ustawia
maksymalną sumę bajtów segmentów pamięci dzielonej (zob. shmget(2)), które mogą być
zablokowane przez rzeczywisty identyfikator użytkownika procesu wywołującego.
Blokady SHM_LOCK shmctl(2) są liczone oddzielnie od blokad pamięci na proces,
ustanowionych przez mlock(2), mlockall(2) i MAP_LOCKED mmap(2); proces może
zablokować bajty do tego limitu w każdej z tych dwóch kategorii.
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.
RLIMIT_MSGQUEUE (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 mq_open(3). Każda kolejka komunikatów, którą tworzy użytkownika wlicza
się do tego limitu (do momentu jej usunięcia) zgodnie ze wzorem:
Od Linuksa 3.5:
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 */
Linux 3.4 i wcześniejsze:
bytes = attr.mq_maxmsg * sizeof(struct msg_msg *) +
/* Do narzutu */
attr.mq_maxmsg * attr.mq_msgsize;
/* Do danych komunikatów */
gdzie attr jest strukturą mq_attr określoną jako czwarty argument do mq_open(3), a
struktury msg_msg i posix_msg_tree_node są wewnętrznymi strukturami jądra.
Składowa „narzutu” 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).
RLIMIT_NICE (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ą
setpriority(2) lub nice(2). Rzeczywista górna granica jest obliczana jako
20 - rlim_cur. 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 RLIM_INFINITY jest zwykle równoważne
-1. Więcej szczegółów na temat wartości nice można znaleźć w podręczniku sched(7).
RLIMIT_NOFILE
Określa wartość o jeden większą niż maksymalna liczba deskryptorów plików, które
dany proces może otworzyć. Próby (open(), pipe(), dup() itd.) przekroczenia tego
limitu dają błąd EMFILE (historycznie limit ten nosił nazwę RLIMIT_OFILE na BSD).
Od Linuksa 4.5, limit ten definiuje również maksymalną liczbę deskryptorów pliku,
jakie proces nieuprzywilejowany (bez przywileju CAP_SYS_RESOURCE (ang. capability))
może mieć „w locie” do innych procesów, przy przekazywaniu za pomocą gniazd domeny
Uniksa. Limit ten dotyczy wywołania systemowego sendmsg(2). Więcej szczegółów w
podręczniku unix(7).
RLIMIT_NPROC
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, fork() zawiedzie z błędem EAGAIN.
Limit RLIMIT_NPROC nie jest wymuszany na procesach z przywilejem CAP_SYS_ADMIN lub
CAP_SYS_RESOURCE (ang. capability) i procesach z rzeczywistym identyfikatorem
użytkownika równym 0.
RLIMIT_RSS
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ń madvise(2) z użyciem MADV_WILLNEED.
RLIMIT_RTPRIO (od Linuksa 2.6.12, lecz zob. USTERKI)
Górna granica, jaką można ustawić dla priorytetu czasu rzeczywistego, dla danego
procesu, za pomocą sched_setscheduler(2) i sched_setparam(2).
Więcej informacji o politykach szeregowania zadań czasu rzeczywistego opisano w
podręczniku sched(7).
RLIMIT_RTTIME (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 sched_yield(2).
Po osiągnięciu limitu miękkiego, do procesu wysyłany jest sygnał SIGXCPU. Jeśli
proces go przechwyci lub zignoruje i będzie kontynuował używanie czasu procesora,
sygnał SIGXCPU będzie generowany co sekundę, do momentu osiągnięcia limitu
sztywnego, gdy proces otrzyma sygnał SIGKILL.
Limit ten ma na celu zapobiegnięcie zablokowania systemu przez zbiegłe procesy
czasu rzeczywistego.
Więcej informacji o politykach szeregowania zadań czasu rzeczywistego opisano w
podręczniku sched(7).
RLIMIT_SIGPENDING (od Linuksa 2.6.8)
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 sigqueue(3); można zawsze skorzystać z kill(2), aby zakolejkować po jednym z
każdego sygnału, który nie występuje w kolejce do procesu.
RLIMIT_STACK
Maksymalny rozmiar stosu procesu w bajtach. W chwili osiągnięcia tego ograniczenia,
generowany jest sygnał SIGSEGV. W celu obsłużenia tego sygnału proces musi założyć
alternatywny stos dla sygnałów (sigaltstack(2)).
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 execve(2).
prlimit()
Typowo linuksowe wywołanie systemowe prlimit() łączy i rozszerza funkcjonalność
setrlimit() i getrlimit(). Można go używać do ustawienia i pobrania limitów zasobów
dowolnego procesu.
Argument resource ma takie samo znaczenie jak w przypadku setrlimit() i getrlimit().
Jeśli argument new_limit nie wynosi NULL, to struktura rlimit, na którą on wskazuje, jest
używana do ustawienia nowych wartości limitów miękkich i sztywnych resource. Jeśli
argument old_limit nie wynosi NULL, to pomyślne wywołanie prlimit() umieszcza poprzednie
limity miękkie i sztywne resource w strukturze rlimit, na którą wskazuje old_limit.
Argument pid określa identyfikator procesu, na którym wywołanie ma operować. Jeśli pid
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 CAP_SYS_RESOURCE (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 oraz identyfikatory:
rzeczywisty, efektywny i zapisany suid procesu docelowego muszą odpowiadać rzeczywistemu
identyfikatorowi grupy wywołującego.
WARTOŚĆ ZWRACANA
W przypadku powodzenia, te wywołania zwracają 0. W razie wystąpienia błędu zwracane jest
-1 i ustawiane errno, wskazując błąd.
BŁĘDY
EFAULT Argument wskaźnika wskazuje na położenie poza dostępną przestrzeń adresową.
EINVAL WArtość określona w resource nie jest prawidłowa; albo — w przypadku setrlimit()
lub prlimit(): rlim->rlim_cur był większy niż rlim->rlim_max.
EPERM Proces nieuprzywilejowany próbował zwiększyć limit sztywny; do dokonania tego
konieczny jest przywilej CAP_SYS_RESOURCE (ang. capability).
EPERM Wywołujący próbował zwiększyć limit sztywny RLIMIT_NOFILE ponad wartość maksymalną
określoną w /proc/sys/fs/nr_open (zob. proc(5))
EPERM (prlimit()) Proces wywołujący nie miał uprawnień do ustawiania limitów dla procesu
podanego w pid.
ESRCH Nie udało się znaleźć procesu o identyfikatorze podanym w pid.
ATRYBUTY
Informacje o pojęciach używanych w tym rozdziale można znaleźć w podręczniku
attributes(7).
┌────────────────────────────────────────────────┬────────────────────────┬───────────────┐
│Interfejs │ Atrybut │ Wartość │
├────────────────────────────────────────────────┼────────────────────────┼───────────────┤
│getrlimit(), setrlimit(), prlimit() │ Bezpieczeństwo wątkowe │ MT-bezpieczne │
└────────────────────────────────────────────────┴────────────────────────┴───────────────┘
STANDARDY
getrlimit()
setrlimit()
POSIX.1-2008.
prlimit()
Linux.
RLIMIT_MEMLOCK i RLIMIT_NPROC pochodzą z BSD i nie są określone w POSIX.1; są obecne w
systemach BSD i Linux, ale z różnymi implementacjami. RLIMIT_RSS pochodzi z BSD i nie jest
określone w POSIX.1; jest jednak obecne w większości implementacji. RLIMIT_MSGQUEUE,
RLIMIT_NICE, RLIMIT_RTPRIO, RLIMIT_RTTIME i RLIMIT_SIGPENDING są typowo linuksowe.
HISTORIA
getrlimit()
setrlimit()
POSIX.1-2001, SVr4, 4.3BSD.
prlimit()
Linux 2.6.36, glibc 2.13.
UWAGI
Proces potomny utworzony za pomocą fork(2) dziedziczy limity zasobów swojego procesu
macierzystego. Limity zasobów są zachowywane przez execve(2).
Limity zasobów są atrybutami przypisanymi procesowi i są dzielone przez wszystkie wątki
procesu.
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).
Można ustawić limity zasobów powłoki za pomocą wbudowanego polecenia ulimit (limit w
csh(1)). Limity zasobów powłoki są dziedziczone przez procesy tworzone do wykonywania
poleceń powłoki.
Od Linuksa 2.6.24, limity zasobów dowolnego procesu można sprawdzić za pomocą
/proc/pid/limits; zob. proc(5).
Dawne systemy udostępniały funkcję vlimit() o podobnym zastosowaniu do setrlimit(). Ze
względu na kompatybilność wsteczną, glibc również udostępnia vlimit(). Wszystkie nowe
aplikacje powinny używać wyłącznie setrlimit().
Różnice ABI biblioteki C/jądra
Od glibc 2.13, funkcje opakowujące getrlimit() i setrlimit() z glibc nie przywołują już
odpowiadających im wywołań systemowych, lecz używają prlimit(), ze względów opisanych w
USTERKACH.
Nazwą opakowującej funkcji z glibc jest prlimit(); nazwą wywołania systemowego jest
prlimit64().
USTERKI
W starszych jądrach Linux, sygnały SIGXCPU i SIGKILL dostarczane, gdy proces napotkał
miękkie i sztywne limity RLIMIT_CPU, dostarczano jedną sekundę (procesorową) później, niż
powinno to nastąpić. Poprawiono to w Linuksie 2.6.8.
W jądrach Linux 2.6.x wcześniejszych niż Linux 2.6.17, limit RLIMIT_CPU wynoszący 0 był
nieprawidłowo traktowany jako „brak limitu” (jak RLIM_INFINITY). Od Linuksa 2.6.17,
ustawienie limitu 0 jest stosowane, ale faktycznie skutkuje limitem 1 sekundy.
Błąd jądra powodował, że RLIMIT_RTPRIO nie działał w Linuksie 2.6.12; problem poprawiono w
Linuksie 2.6.13.
W Linuksie 2.6.12, istniała niezgodność o jeden pomiędzy zakresami priorytetów zwracanymi
przez getpriority(2) i RLIMIT_NICE. Dawało te efekt, że faktyczna górna granica wartości
nice była obliczana jako 19 - rlim_cur. Poprawiono to w Linuksie 2.6.13.
Od Linuksa 2.6.12, jeśli proces osiąga swój miękki limit RLIMIT_CPU i posiada procedurę
obsługi SIGXCPU, 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 RLIMIT_CPU 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 RLIMIT_RTTIME działa
w ten sam sposób, gdy osiągnie się miękki limit.
Jądra przed Linuksem 2.4.22 nie diagnozują błędu EINVAL w przypadku setrlimit(), gdy
rlim->rlim_cur było większe niż rlim->rlim_max.
Ze względu na kompatybilność, Linux nie zwraca błędu, gdy próba ustawienia RLIMIT_CPU
zawodzi.
Reprezentacja „dużych” wartości limitu zasobu na platformach 32-bitowych
Funkcje opakowujące getrlimit() i setrlimit() z glibc używają 64-bitowego typu danych
rlim_t, nawet na platformach 32-bitowych. Jednakże typ danych rlim_t używany w wywołaniach
systemowych getrlimit() i setrlimit() jest (32-bitowym) unsigned long. Co więcej, w
Linuksie jądro reprezentuje limit zasobów na platformach 32-bitowych jako unsigned long.
Jednak 32-bitowy typ danych nie jest wystarczająco szeroki. Najtrudniejsza sytuacja
występuje odnośnie limitu RLIMIT_FSIZE 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 off_t (zakładając, że program skompilowano z _FILE_OFFSET_BITS=64).
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 unsigned long, funkcja
opakowująca setrlimit() z glibc po cichu konwertowała wartość limitu na RLIM_INFINITY.
Innymi słowy, żądany limit zasobów był po cichu ignorowany.
OD glibc 2.13, glibc obchodzi to ograniczenie wywołań systemowych getrlimit() i
setrlimit() implementując setrlimit() i getrlimit() jako funkcje opakowujące wywołujące
prlimit().
PRZYKŁADY
Poniższy program demonstruje użycie 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, "Użycie: %s <pid> [<nowy-limit-miękki> "
"<nowy-limit-sztywny>]\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\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\n",
(intmax_t) old.rlim_cur, (intmax_t) old.rlim_max);
exit(EXIT_SUCCESS);
}
ZOBACZ TAKŻE
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)
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>
Niniejsze tłumaczenie jest wolną dokumentacją. Bliższe informacje o warunkach licencji
można uzyskać zapoznając się z GNU General Public License w wersji 3
⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ lub nowszej. Nie przyjmuje się ŻADNEJ
ODPOWIEDZIALNOŚCI.
Błędy w tłumaczeniu strony podręcznika prosimy zgłaszać na adres listy dyskusyjnej
⟨manpages-pl-list@lists.sourceforge.net⟩.