Egy új rendszer telepítése, alapértelmezett paraméterekkel, a következő rendszerszintű fájlkorlátokkal van konfigurálva:
- Kernel Max fájlok: 12288
- Fájlok száma folyamatonként: 10240
Az aktuális kernel sysctl paraméterei az sysctl paranccsal tekinthetők meg:
$ sysctl -a | grep kern.maxf
kern.maxfiles: 12288
kern.maxfilesperproc: 10240
Most ellenőrizzük a határértékeket az ulimit paranccsal:
FOFT korlátok esetén: [láthatjuk, hogy: open files = 256]
$ ulimit -aS
törzsfájl mérete (blokkok, -c) 0
adatszegmens mérete (kbyte, -d) korlátlan
fájlméret (blokkok, -f) korlátlan
max. lezárt memória (kbyte, -l) korlátlan
maximális memória méret (kbyte, -m) korlátlan
fájlok megnyitása (-n) 256
csőméret (512 bájt, -p) 1
veremméret (kbyte, -s) 8192
cpu idő (másodperc, -t) korlátlan
max. felhasználói folyamatok (-u) 266
virtuális memória (kbyte, -v) korlátlan
HARD korlátozásokhoz: [láthatjuk, hogy: open files = Korlátlan]
$ ulimit -aH
magfájl mérete (blokkok, -c) korlátlan
adatszegmens mérete (kbyte, -d) korlátlan
fájlméret (blokkok, -f) korlátlan
max. lezárt memória (kbyte, -l) korlátlan
maximális memória méret (kbyte, -m) korlátlan
fájlok megnyitása (-n) korlátlan
csőméret (512 bájt, -p) 1
veremméret (kbyte, -s) 65532
cpu idő (másodperc, -t) korlátlan
max. felhasználói folyamatok (-u) 532
virtuális memória (kbyte, -v) korlátlan
A launchctl használata
A launchctl képes határértékek konfigurálására vagy az aktuális értékek megjelenítésére.
A launchctl limit használatával megjeleníti az összes jelenlegi Soft és Hard korlátozást, és láthatjuk, hogy a soft limit 256, a hard limit pedig „korlátlan” az maxfiles elemnél. (ugyanazt az információt kaptuk a fenti ulimit paranccsal)
$ uname -a
18.6.0 Darwin Kernel 18.6.0 verzió: Csütörtök 25, 23:16:27 PDT, 2019; gyökér: xnu-4903.261.4 ~ 2 / RELEASE_X86_64 x86_64
$ launchctl korlát
cpu korlátlan korlátlan
fájlméretezés korlátlan korlátlan
adatok korlátlan korlátlan
verem 8388608 67104768
mag 0 korlátlan
rss korlátlan korlátlan
memlock korlátlan korlátlan
maxproc 266 532
maxfiles 256 korlátlan
A szűréshez egyszerűen használhatjuk a launchctl limit maxfiles
fájlt
$ launchctl limit maxfiles
maxfiles 256 korlátlan
Most próbáljuk meg megváltoztatni ezeket az értékeket #
Például a parancssort használja:
sudo launchctl limit maxfiles 10000 unlimited
De utána, amikor újra végrehajtom a korlátok megjelenítésére vonatkozó parancsot, láthatjuk, hogy:
- A soft határt 256-ról 10000-ra állítottuk be,
- de a Hard határértéket csökkentették -tól 'korlátlan' -tól '10240'-ig
sudo launchctl limit
maxfiles 10000 10240
Mostantól pedig lehetetlen visszaszállítani korlátlanul!
Láthatjuk, hogy végrehajtása után megváltoztatta a kernel sysctl paramétereit is.
$ sysctl -A | grep max
kern.maxfiles: 10240
kern.maxfilesperproc: 10000
Ennek oka
Az 'unlimited' szó, amikor paraméterként használják a maxfájlok beállításához,
megegyezik az '10240' értékkel.
Mivel a launchctl nem fogadja el az 'unlimited' karakterláncot, és átalakítja azt
a 10240 értékre!
[Az alábbiakban bebizonyítom, a launchclt és a MacOS Mojave kernel forráskódjával]
De először nézzük meg, használhatunk-e nagyobb értéket, például 2 milliót:
sudo launchctl limit maxfiles 10000 2000000
$ launchctl limit maxfiles
maxfiles 10000 2000000
Igen, tudjuk, elfogadta a nagyobb értéket.
Miért történik ez
A forráskódban nehezen kódolt, hogy nem fogadja el az 'unlimited' értéket, ezért ha egyszer megváltoztattuk, soha nem tehetjük vissza.
B De mi az az érték, amely megfelel a 'korlátlan' értéknek?
- R: Az 'unlimited' értéke INT_MAX, ami '2147483647' (az Egész szám típusának maximális értéke)
Menjünk bele a forráskódba #
A MacOS launchclt.c és Kernel rutinjainak forráskód-elemzése
10.14 Mojave arról, hogy miért nem lehet a maxfájlokat korlátlanra állítani a launchctl parancssoron keresztül.
Az alábbi összes információ elemzésem, a (z) forráskód felhasználásával
Apple, amely a következő címen szerezhető be: https://opensource.apple.com
Rafael Prado - 2019/08/09
/ * A KÓDELEMZÉS ELKEZDÉSE * /
// --------------- Analisys Comment ------------------------------- ---
// A MacOS rendszer magfejlécfájlját nézve a syslimits.h van
// az OPEN_MAX meghatározása 10240 értékkel.
//
// Ez az alapérték, amelyet alapértelmezés szerint használunk
// maxfiles érték a rendszer indításakor.
//
// Ez a megjegyzés, amelyet itt olvas, az enyém.
//
/ * FÁJL: sys / syslimits.h * /
// ************************************************** *****************
#define OPEN_MAX 10240 / * max. megnyitott fájlok folyamatonként - igaz, konfigurációs opciót készít? * /
// ************************************************** *****************
//
// --------------- Analisys Comment ------------------------------- -
// Most láthatjuk a kernel config belsejében azt a maxfiles paramétert
// az OPEN_MAX egyik alterméke, 2048 hozzáadásával az értékéhez,
// amelyek megadják az 12288 számot.
//
// Ez lesz a sysctl kern.maxfiles: 12288 alapértelmezett értéke
//
/ * FÁJL: conf / param.c * /
// ************************************************** *****************
#define MAXFILES (OPEN_MAX + 2048)
int maxfiles = MAXFILES;
// ************************************************** *****************
//
// --------------- Analisys Comment ------------------------------- -
// Itt van, ezért lehetetlen beállítani a „korlátlan” értéket a használatával
// a launchctl parancssora:
//
/ * FÁJL: launchd / support / launchctl.c * /
// ************************************************** *****************
//
// (: ..) A lim2str () függvény a 2810-es vonalon
const char *
lim2str (rlim_t val, char * buf)
{
if (val == RLIM_INFINITY)
strcpy (buf, "korlátlan");
más
sprintf (buf, "% lld", val);
visszatérő buf;
}
// (: ..) srt2lim () függvény a 2821. soron
bool
str2lim (const char * buf, rlim_t * res)
{
char * endptr;
* res = strtoll (buf, &endptr, 10);
if (! strcmp (buf, "korlátlan")) {
* res = RLIM_INFINITY;
return false;
} else if (* endptr == '\ 0') {
return false;
}
return true;
}
// (: ..) Funkció limit_cmd () található a 2835-ös vonalon
int
limit_cmd (int argc, char * const argv [])
{
// ------------------------------------------------ ------------
// Ez a megjegyzés nem része a forrásfájlnak, az
// elemzéseim megjegyzik, hogy ez a funkció mit csinál.
//
// Itt olvassa el a 'launchctl limit argv2 argv3' paramétereit
// és meghívja az srt2lim () függvényt, hogy az argokat határértékekké konvertálja
//
// Az srt2lim () függvény fent van kinyomtatva.
// ------------------------------------------------ ------------
//
// (: ....) ugrás a 2850-es sorra ezen a funkción belül
ha (argc > = 3 && str2lim (argv [2], &slim))
badargs = igaz;
más
hlim = karcsú;
if (argc == 4 && str2lim (argv [3], &hlim))
badargs = igaz;
// ------------------------------------------------ ------------
// De az értékek meghatározása előtt ellenőrizni kell, hogy
// tiltja az 'unlimited' szó paraméterként való használatát (csak
// ha a 'maxfiles' esetén használjuk), és ez az ellenőrzés hibát ad, kilépve
// a limit_cmd () függvény [az a funkció, amin belül vagyunk] és
// a rendszermag-paramétert soha nem állítjuk be, ha használjuk
// a 'korlátlan' szó értékként.
//
// Ezt a megjegyzést én írtam
// és nem része a forrásfájlnak.
// ------------------------------------------------ ------------
//
// (: ....) a funkción belül a 2906-os sorra ugrik
bool maxfiles_exceeded = hamis;
if (strncmp (argv [1], "maxfiles", sizeof ("maxfiles")) == 0) {
if (argc > 2) {
maxfiles_exceeded = (strncmp (argv [2], "korlátlan", sizeof ("korlátlan")) == 0);
}
if (argc > 3) {
maxfiles_exceeded = (maxfiles_exseded || strncmp (argv [3], "korlátlan", sizeof ("korlátlan")) == 0);
}
if (maxfájlok_túllépve) {
launchctl_log (LOG_ERR, "A" maxfiles \ "sem kemény, sem soft korlátja nem lehet korlátlan. Mindkét esetben használjon numerikus paramétert.");
visszatér 1;
}
}
// ------------------------------------------------ -------------
// Fentebb láthatjuk, hogy tilos használni a „korlátlan” értéket
// És amikor használjuk, a rendszer felveszi a
// az OPEN_MAX alapértelmezett értéke, amely 10240!
//
// Ez megmagyarázza és bebizonyítja, hogy a 'korlátlan' beállítása miért ad nekünk 10240-et
// ------------------------------------------------ --------------
// ************************************************** *****************
//
// --------------- Analisys Comment ------------------------------- -
// Megtekintve egy másik fájlt a Kernel forrásból, találhatunk egy másikat
// hely, ahol ellenőrzi a „korlátlan” értéket, és ott is van
// az Apple magyarázata róla.
//
// Az ALÁBBI megjegyzés Az Apple Developers és
// a kern_resource.c fájlban található a MacOS Kernel Source fájlból.
//
/ * FÁJL: kern / kern_resource.c * /
// ************************************************** *****************
RLIMIT_NOFILE eset:
/ *
* Csak a root állíthatja be a maxfile korlátokat, ahogy van
* rendszerszintű erőforrás. Ha POSIX viselkedésre számítunk,
* az érték befogása helyett adja vissza az EINVAL értéket. Ezt csináljuk
* mert történelmileg az emberek megpróbálhatták
* állítsa be a RLIM_INFINITY értéket úgy, hogy "bármi legyen a maximum".
* /
if (kauth_cred_issuser (kauth_cred_get ())) {
if (limp->rlim_cur! = alimp->rlim_cur &&
limp->rlim_cur > (rlim_t) maxfiles) {
if (posix) {
hiba = EINVAL;
kimenni;
}
limp->rlim_cur = maxfájlok;
}
if (limp->rlim_max! = alimp->rlim_max &&
limp->rlim_max > (rlim_t) maxfiles)
limp->rlim_max = maxfájlok;
}
más {
ha (limp->rlim_cur! = alimp->rlim_cur &&
limp->rlim_cur > (rlim_t) maxfilesperproc) {
if (posix) {
hiba = EINVAL;
kimenni;
}
limp->rlim_cur = maxfilesperproc;
}
if (limp->rlim_max! = alimp->rlim_max &&
limp->rlim_max > (rlim_t) maxfilesperproc)
limp->rlim_max = maxfilesperproc;
}
szünet;
// ************************************************** *****************
/ * KÓDELEMZÉS VÉGE * /
T Ez megmagyarázza, miért lehetetlen újra beállítani az „unlimited” beállítást, miután valamilyen más értékre módosította.
Hogyan kell csinálni? #
Az RLIM_INFINITY a <sys/resources.h>
416. sorában van megadva
/ *
* Az erőforrás-korlátok szimbolikus állandói; mivel minden határ reprezentálható
* mint rlim_t típus, megengedett, hogy meghatározzuk az RLIM_SAVED_ * kifejezést
* RIML_INFINITY.
* /
#define RLIM_INFINITY ((((__uint64_t) 1 << 63) - 1) / * nincs korlátozás * /
#define RLIM_SAVED_MAX RLIM_INFINITY / * Nem képviselhető kemény határ * /
#define RLIM_SAVED_CUR RLIM_INFINITY / * Nem képviselhető soft limit * /
A gyakorlatban a jelenlegi platform esetében a korlátlan INFINITY maximális érték az INT_MAX értékre van korlátozva (amely az Integer Type maximális értéke)
Ezt figyelembe véve azt jelenti, hogy az „unlimited” jelentése INT_MAX, amely az 2147483647 értéke.
Egy lehetséges workaround beállíthatja a 2147483647 határértéket:
sudo launchctl limit maxfiles 2147483647 2147483647
Mivel ez a lehető legnagyobb érték.
Mivel ez lehetséges megoldás. Mennem kellene mélyebben a forrásba, hogy ellenőrizhessem, ez valóban „ugyanazt jelenti-e”, mint a „korlátlan”.
W figyelmeztetés:
PS: Kérjük, ne állítsa nagyobbra, mint 2147483647, mert SIGNED INT, és ha a 2147483648-t (figyeld meg a nyolcast, csak a +1-et adom hozzá a maximális értékhez), akkor a SIGNED INT negative-ként fogják értelmezni, és azonnal összeomlik a macOS, mert nem fog tudni megnyitni más fájlleírót, kba foglalva azt sem, amelyre az -nek szüksége lesz, hogy visszaállítsa ezt az értéket, ha a launchctl különböző paraméterekkel.
Az egyetlen megoldás a rendszer kemény visszaállítása lesz, ha ezt megpróbálja. És elveszítheti az összes mentetlen dolgát. Próbálkozzon valamilyen MacOS virtuális gépen tesztelés céljából
S forráskód hivatkozások:
<sys / resource.h> https://opensource.apple.com/source/xnu/xnu-4903.221.2/bsd/sys/resource.h.auto.html
<dev / unix_startup.c> https://opensource.apple.com/source/xnu/xnu-4903.221.2/bsd/dev/unix_startup.c.auto.html
<kern / kern_resource.c> https://opensource.apple.com/source/xnu/xnu-4903.221.2/bsd/kern/kern_resource.c.auto.html
<conf / param.c> https://opensource.apple.com/source/xnu/xnu-4903.221.2/bsd/conf/param.c.auto.html
<sys / syslimits.h> https://opensource.apple.com/source/xnu/xnu-4903.221.2/bsd/sys/syslimits.h.auto.html
launchctl.c https://opensource.apple.com/source/launchd/launchd-442.21/support/launchctl.c.auto.html