Qual comando controla os limites de arquivo aberto?

Qual arquivo de comando / configuração controla os limites de arquivo aberto no OS X? Existe um comando diferente para o OS X 10.5 / 10.6 / 10.7? As opções I explorar abaixo são ulimit, sysctlelaunchctl

"Muitos arquivos abertos" é aparentemente um erro comum no Leopard, talvez outras versões do OS X:

• 420 Muitos Arquivos Abertos

• Como aumentar corretamente ulimit -n no Lion?

• Onde estão os ulimits padrão especificados no OS X (10.5)?

Existem muitas maneiras (relacionadas?) De exibir os limites de arquivos abertos:

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


$ launchctl limit
cpu         unlimited      unlimited      
filesize    unlimited      unlimited      
data        unlimited      unlimited      
stack       8388608        67104768       
core        0              unlimited      
rss         unlimited      unlimited      
memlock     unlimited      unlimited      
maxproc     1024           2048           
maxfiles    2048           4096       

$ sysctl -a | grep files
kern.maxfiles = 32768
kern.maxfilesperproc = 16384
kern.maxfiles: 32768
kern.maxfilesperproc: 16384
kern.num_files: 2049

Foi reivindicado em algumas das postagens acima que elas podem ser modificadas com os seguintes comandos:

sudo launchctl limit maxfiles 16384 32768
sudo ulimit -n 32768
sudo sysctl -w kern.maxfilesperproc=16384
sudo sysctl -w kern.maxfiles=32768

No entanto, fora dos comandos acima, apenas os sysctlcomandos têm algum efeito aparentemente (por exemplo, ulimit -ne launchctl limitnão mostram alterações após a inserção dos comandos acima, enquanto sysctl -amostram as alterações solicitadas).

Os locais correspondentes para alterar esses parâmetros para o sistema operacional são:

/etc/sysctl.conf
/etc/launchd.conf

Eu também descobri uma resposta que diz que ulimitapenas controla o shell atual.

Como posso ajustar para cima os limites máximos de arquivos / máximos arquivos abertos no macOS?

A resposta simples costumava ser que havia vários limites e o limite mais baixo que você alcança em uma instância específica gera seu erro. Agora em 10.12 launchctl limit maxfilestambém está na mistura. Para obter detalhes sobre a implementação, essa ótima resposta está recebendo recompensas e merece mais votos do que o que eu posso dar.

outros tópicos relevantes são:

• `ulimit -n` para não raiz
• Por que a configuração do kern.maxfiles no /etc/sysctl.conf permanece?

O ulimitnível é definido baixo para impedir que um script de shell ruim inunde o kernel com arquivos abertos.

O kern.maxfilesperprocque há para deixar um pouco de espaço nos arquivos max contar para que um processo pode usar a maioria, mas não todo o espaço manipulador de arquivo aberto a partir do kernel.

Para situações normais, esse kern.maxfilesé o fator limitante final.

No Sierra - os limites são 256 arquivos abertos e um número ilimitado máximo, então estou descobrindo que ter de 3 a 4 mil arquivos definidos para o limite flexível funciona para quase todo o nosso hardware e ainda mantém o sistema responsivo quando um processo descontrolado abre muitos arquivos. Gostamos de manter nossos servidores de desenvolvimento no limite de 256, para capturar software problemático e com vazamentos no desenvolvimento / teste e teste, em vez de descobrir sobre isso na produção.

• http://krypted.com/mac-os-x/maximum-files-in-mac-os-x/

Eu não sou fã de arquivos de 10k - talvez com o armazenamento APFS e NVMe veremos o dia em que isso não é impensável, mas tente manter centenas ou milhares baixos para os limites de arquivos. Especialmente se o seu mac tiver um limite baixo de processos , ter tantos arquivos abertos por tão poucos processos pode ser problemático.

Parece que existe um método totalmente diferente para alterar o limite de arquivos abertos para cada versão do OS X.

Para o OS X Sierra (10.12.X), você precisa:

1. Em Library/LaunchDaemonscriar um arquivo chamado limit.maxfiles.pliste cole o seguinte em (sinta-se livre para alterar os dois números (que são os limites moles e duros, respectivamente):

<?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>Label</key>
    <string>limit.maxfiles</string>
    <key>ProgramArguments</key>
    <array>
      <string>launchctl</string>
      <string>limit</string>
      <string>maxfiles</string>
      <string>64000</string>
      <string>524288</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>ServiceIPC</key>
    <false/>
  </dict>
</plist> 

2. Altere o proprietário do seu novo arquivo:

sudo chown root:wheel /Library/LaunchDaemons/limit.maxfiles.plist

3. Carregue estas novas configurações:

sudo launchctl load -w /Library/LaunchDaemons/limit.maxfiles.plist

4. Por fim, verifique se os limites estão corretos:

launchctl limit maxfiles

O seguinte deve resolver os problemas mais comuns (e listados na ordem de sua hierarquia):

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

Notas:

1. Você precisará reiniciar para que essas alterações entrem em vigor.
2. AFAIK, você não pode mais definir limites para 'ilimitado' no OS X
3. launchctl maxfiles são limitados por sysctl maxfiles e, portanto, não podem excedê-los
4. O sysctl parece herdar o kern.maxfilesperproc do launchctl maxfiles
5. ulimit parece herdar o valor de 'arquivos abertos' do launchctl por padrão
6. você pode definir um ulimit personalizado dentro de / etc / profile ou ~ / .profile; Embora isso não seja necessário, forneci um exemplo
7. Seja cauteloso ao definir um desses valores para um número muito alto quando comparado ao padrão - os recursos existem estabilidade / segurança. Peguei esses números de exemplo que considero razoáveis, escritos em outros sites.

Em palavras simples:

• O ulimitcomando fornece "controle sobre os recursos disponíveis para o shell e os processos que ele cria" (consulte: help ulimite man bash). Os recursos fornecidos ao shell são limitados pelos limites de recursos do sistema.

• O launchctlconsumo máximo de recursos do sistema controlos pelo processo corrente (ver: man setrlimite man launchctl). Os valores máximos são limitados pelos limites do kernel.

• Os sysctllimites do kernel dos controles (consulte: man sysctle os limites do kernel do BSD ).

Para aumentar os limites, você pode usar cada um dos comandos, dependendo do problema.

Veja também: Qual é a relação entre `launchctl limit` e` ulimit`?

Para o problema com muitos arquivos abertos, isso depende de qual limite exato ou flexível foi atingido (seja um script de shell local, o script global executado root, um aplicativo ou todos os processos ao mesmo tempo). Vale a pena aumentar todos os limites (limites de shell, launchd e kernel).

Para aumentar os limites persistentemente, consulte: Como controlar persistentemente o consumo máximo de recursos do sistema no Mac?