Où sont les ulimits par défaut spécifiés sur OS X (10.5)?

La nofilelimite par défaut pour les comptes d'utilisateurs OS X semble être d'environ 256 descripteurs de fichiers ces jours-ci. J'essaie de tester des logiciels qui nécessitent beaucoup plus de connexions que ceux ouverts en même temps.

Sur une boîte Debian typique exécutant le module pam limits, je modifierais /etc/security/limits.confpour définir des limites plus élevées pour l'utilisateur qui exécutera le logiciel, mais je ne sais pas où définir ces limites dans OS X.

Y a-t-il une interface graphique quelque part pour cela? Existe-t-il un fichier de configuration quelque part? Quelle est la façon la plus simple de modifier les ulimits par défaut sous OS X?

Sous Leopard, le processus initial est launchd. Les ulimits par défaut de chaque processus sont hérités de launchd. Pour référence, les limites par défaut (compilées en) sont

$ sudo launchctl limit
    cpu         unlimited      unlimited      
    filesize    unlimited      unlimited      
    data        6291456        unlimited      
    stack       8388608        67104768       
    core        0              unlimited      
    rss         unlimited      unlimited      
    memlock     unlimited      unlimited      
    maxproc     266            532            
    maxfiles    256            unlimited

Pour modifier l'une de ces limites, ajoutez une ligne (vous devrez peut-être d'abord créer le fichier) à /etc/launchd.conf, les arguments sont les mêmes que ceux transmis à la launchctlcommande. Par exemple

echo "limit maxfiles 1024 unlimited" | sudo tee -a /etc/launchd.conf

Cependant, launchdvotre shell de connexion a déjà démarré, donc le moyen le plus simple pour que ces modifications prennent effet est de redémarrer notre machine. (Utilisez >> pour ajouter à /etc/launchd.conf.)

sudo echo "limit maxfiles 1024 unlimited" >> /etc/launchd.conf

ne fonctionne pas car sudo est au mauvais endroit, essayez ceci:

echo 'limit maxfiles 10000 unlimited' | sudo tee -a /etc/launchd.conf

Limites du shell

Les ressources disponibles pour le shell et les processus peuvent être modifiées par une ulimitcommande qui peut être ajoutée aux scripts de démarrage tels que ~/.bashrcou ~/.bash_profilepour des utilisateurs individuels ou /etc/bashrcpour tous les utilisateurs . Exemple de ligne à ajouter:

ulimit -Sn 4096 && ulimit -Sl unlimited

^{Voir: help ulimitet man bashpour plus d'informations.}

Limites du système

En général, les limites du système sont contrôlées par le framework Launchd et peuvent être modifiées par launchctlcommande, par exemple

launchctl limit maxfiles 10240 unlimited

Pour rendre les modifications persistantes, vous devez créer un fichier de liste de propriétés dans des dossiers conformes au lancement spécifiques qui agit comme un agent de démarrage.

Voici l'exemple de commande créant un tel fichier de démarrage:

sudo /usr/libexec/PlistBuddy /Library/LaunchAgents/com.launchd.maxfiles.plist -c "add Label string com.launchd.maxfiles" -c "add ProgramArguments array" -c "add ProgramArguments: string launchctl" -c "add ProgramArguments: string limit" -c "add ProgramArguments: string maxfiles" -c "add ProgramArguments: string 10240" -c "add ProgramArguments: string unlimited" -c "add RunAtLoad bool true"

Le fichier serait chargé au lancement du système, cependant, à charger pour exécuter manuellement:

sudo launchctl load /Library/LaunchAgents/com.launchd.maxfiles.plist

Pour vérifier les limites actuelles, exécutez: launchctl limit.

^{Voir: Créer des démons et des agents de lancement .}

Limites du noyau

• Les limites du noyau sont contrôlées par la sysctlcommande.
• Pour voir les limites du noyau en cours, exécutez: sysctl -a | grep ^kern.max.
• Pour modifier le maximum de fichiers autorisés à ouvrir, exécutez: sudo sysctl -w kern.maxfiles=20480.
• Pour rendre les modifications persistantes, utilisez la méthode ci-dessus similaire pour créer le fichier de liste de propriétés dans le dossier de démarrage du système.

En relation:

• Comment contrôler de manière persistante la consommation maximale de ressources système sur Mac?
• Quelle commande contrôle les limites des fichiers ouverts?

Méthodes obsolètes

Dans la version antérieure de macOS, vous pouviez définir ces limites à l' /etc/sysctl.conféchelle du système comme vous le faites normalement sur Unix, mais il semble que ce ne soit pas pris en charge.

L'utilisation de ~/.launchd.confou /etc/launchd.confsemble ne pas non plus être prise en charge dans aucune version existante de macOS. ^wiki

Idem avec /etc/rc.localle fichier de démarrage, il n'est pas pris en charge sur macOS.

% ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) 6144
file size               (blocks, -f) unlimited
max locked memory       (kbytes, -l) unlimited
max memory size         (kbytes, -m) unlimited
open files                      (-n) 2560
pipe size            (512 bytes, -p) 1
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 266
virtual memory          (kbytes, -v) unlimited
%

Maintenant, je dois trouver pourquoi il existe 2 moyens de vérifier / fixer des limites ....

D'accord - semble ulimitet sysctldonne un sentiment faussement positif qu'ils font réellement quelque chose - mais à la place, ils semblent inutiles . Quelqu'un pourrait-il vérifier cela?

D'accord, je commence à comprendre. Depuis la version 10.4, il n'y inita plus de processus, il a été remplacé par launchd, qui fonctionne également avec un PID de 1.

% ps -fu root
  UID   PID  PPID   C     STIME TTY           TIME CMD
    0     1     0   0   0:30.72 ??         0:46.72 /sbin/launchd

Et bien sûr, il convient de mentionner que ulimitc'est un shell intégré, launchctlun programme indépendant du shell.

Sous OS X, si vous essayez de modifier les limites logicielles pour un démon ou un processus ou une tâche, la bonne façon de modifier ces limites logicielles n'est pas de modifier la configuration de launchd par défaut pour tous les processus, mais en la définissant pour le processus que vous êtes essayant de courir.

Ceci est accompli dans votre fichier launchd .plist pour votre processus.

Si vous avez un démon ou un processus en cours d'exécution pour lequel vous avez besoin d'avoir plus de fichiers ouverts, créez un fichier plist pour lui et ajoutez-lui ces paramètres:

    <key>SoftResourceLimits</key>
    <dict>
        <key>NumberOfFiles</key>
        <integer>1024</integer>
    </dict>

Un exemple, en utilisant mongodb. Je crée un fichier .plist appelé org.mongo.mongodb.plist et l'enregistre dans /Library/LaunchDaemons/org.mongo.mongodb.plist. Le fichier ressemble à ceci:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Disabled</key>
  <false/>
  <key>Label</key>
  <string>org.mongo.mongod</string>
  <key>ProgramArguments</key>
  <array>
    <string>/usr/local/lib/mongodb/bin/mongod</string>
    <string>--dbpath</string>
    <string>/Users/Shared/mongodata/</string>
    <string>--logpath</string>
    <string>/var/log/mongodb.log</string>
  </array>
  <key>QueueDirectories</key>
  <array/>
  <key>RunAtLoad</key>
  <true/>
  <key>UserName</key>
  <string>daemon</string>
  <key>SoftResourceLimits</key>
  <dict>
    <key>NumberOfFiles</key>
    <integer>1024</integer>
    <key>NumberOfProcesses</key>
    <integer>512</integer>
  </dict>
</dict>
</plist>

Désormais, votre processus dispose des ressources dont il a besoin, sans contourner la configuration globale du système. Ce sera automatiquement configuré au redémarrage. Ou, si vous ne voulez pas redémarrer, vous pouvez exécuter

sudo launchctl load /Library/LaunchDaemons/org.mongod.plist

Si votre processus ou tâche est plus un agent qu'un démon, vous pouvez mettre le .plist dans / Library / LaunchAgents à la place. Différentes règles s'appliquent à la façon dont launchd contrôlera votre processus dans les deux cas. LaunchDaemons semble réservé aux processus que launchd tentera de suivre à tout moment.

Les éléments suivants devraient résoudre la plupart des solutions (et sont répertoriés dans l'ordre de leur hiérarchie):

echo 'kern.maxfiles=20480' | sudo tee -a /etc/sysctl.conf
echo -e 'limit maxfiles 8192 20480\nlimit maxproc 1000 2000' | sudo tee -a /etc/launchd.conf
echo 'ulimit -n 4096' | sudo tee -a /etc/profile

Remarques:

1. Vous devrez redémarrer pour que ces modifications prennent effet.
2. AFAIK, vous ne pouvez plus définir de limites à «illimité» sous OS X
3. launchctl maxfiles sont limités par sysctl maxfiles, et ne peuvent donc pas les dépasser
4. sysctl semble hériter de kern.maxfilesperproc de launchctl maxfiles
5. ulimit semble hériter par défaut de sa valeur de «fichiers ouverts» de launchctl
6. vous pouvez définir un ulimit personnalisé dans / etc / profile ou ~ / .profile; bien que cela ne soit pas nécessaire, j'ai fourni un exemple
7. Soyez prudent lorsque vous définissez l'une de ces valeurs à un nombre très élevé par rapport à leur valeur par défaut - les fonctionnalités existent stabilité / sécurité. J'ai pris ces exemples de chiffres que je pense être raisonnables, écrits sur d'autres sites Web.
8. Lorsque les limites de launchctl sont inférieures à celles de sysctl, il a été signalé que les limites de sysctl pertinentes seraient augmentées automatiquement pour répondre aux exigences.

D'après mon expérience, ma tâche à nombre de processus élevé n'a réussi qu'avec:

kern.maxproc=2500  # This is as big as I could set it.

kern.maxprocperuid=2048

ulimit -u 2048

Les deux premiers peuvent aller dans /etc/sysctl.confet la valeur ulimit dans launchd.conf, pour un réglage fiable.

Puisque tcp / ip faisait partie de ce que je faisais, je devais aussi augmenter

kern.ipc.somaxconn=8192

de son 128 par défaut.

Avant d'augmenter les limites du processus, j'obtenais des échecs «fork», pas assez de ressources. Avant d'augmenter kern.ipc.somaxconn, je recevais des erreurs de "tuyau cassé".

C'était en exécutant un bon nombre (500-4000) de processus détachés sur mon monstre Mac, OS 10.5.7, puis 10.5.8, maintenant 10.6.1. Sous Linux sur l'ordinateur de mes patrons, cela a juste fonctionné.

Je pensais que le nombre de processus serait plus proche de 1000, mais il semble que chaque processus que j'ai commencé comprenait sa propre copie du shell en plus de l'élément réel faisant le travail réel. Très festif.

J'ai écrit un jouet d'affichage qui ressemblait à quelque chose comme:

#!/bin/sh

while[ 1 ]

do

    n=netstat -an | wc -l

    nw=netstat -an | grep WAIT | wc -l

    p=ps -ef | wc -l

    psh=ps -ef | fgrep sh | wc -l

    echo "netstat: $n   wait: $nw      ps: $p   sh: $psh"

    sleep 0.5

done

et regardé le nombre maximum de processus dans ps -ef et traîner dans netstat en attente TIME_WAITd'expiration ... Avec les limites augmentées, j'ai vu plus de 3500 TIME_WAITarticles au maximum.

Avant de relever les limites, je pouvais `` me faufiler '' sur le seuil de défaillance, qui a commencé au-dessous de 1K mais a atteint une valeur élevée de 1190. mis en cache qui s'est étendu à sa limite chaque fois qu'il a échoué.

Bien que mon cas de test ait eu une «attente» comme déclaration finale, il y avait encore BEAUCOUP de processus détachés qui traînaient après sa sortie.

J'ai obtenu la plupart des informations que j'ai utilisées à partir de publications sur Internet, mais elles n'étaient pas toutes exactes. Votre kilométrage peut varier.