Início / unix / Perguntas / 451486
Accepted
Sergiy Kolodyazhnyy
Asked: 2018-06-24 09:43:23 +0800 CST

Como causar o erro "Lista de argumentos muito longa"? [duplicado]

  • 772

Contexto para a pergunta: De acordo com as especificações do POSIX , ARG_MAX é o comprimento máximo dos argumentos de linha de comando para a exec()família de funções. O que me leva a acreditar que esse é o número real de argumentos, no entanto, isso claramente não funcionou:

$ ulimit -s
8192
$ touch {1..18000}.jpg
$ rm *.jpg
$

Claramente, isso funciona bem, apesar de ter mais de 8192 itens. De acordo com a resposta do DW , o 8192tamanho é supostamente em kB. Então, claramente, a suposição anterior estava errada.

É aqui que entra a questão real: Como descubro a quantidade de itens que realmente ficarão acima do limite de 8192 kB? Em outras palavras, que tipo de computação devo realizar para garantir que esse *.jpgtipo de glob resultará em Argument list too longerro?

Observe que isso não é uma duplicata de O que define o tamanho máximo do argumento de comando único . Conheço getconf ARG_MAXe ulimit -svalores, essa não é a minha pergunta. Eu preciso saber como gerar argumentos suficientes em tamanho que estarão acima do limite . Em outras palavras, preciso encontrar uma maneira de obter o erro, não evitá-lo.

shell command-line

4 respostas

  1. Best Answer

    Usar getconf ARG_MAXpara gerar uma longa lista xe chamar um utilitário externo com isso como seu argumento geraria um erro "Lista de argumentos muito longa":

    $ /bin/echo $( perl -e 'print "x" x $ARGV[0]' "$(getconf ARG_MAX)" )
/bin/sh: /bin/echo: Argument list too long

    O ambiente e o comprimento da string /bin/echoserão incluídos no que faz o erro ocorrer, então podemos tentar encontrar o maior número possível subtraindo estes:

    $ env
PATH=/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin:/usr/local/bin

    (Comecei este shell com env -i sh, então há apenas a PATHvariável no ambiente)

    $ /bin/echo $( perl -e 'print "x" x ($ARGV[0] - length($ENV{"PATH"}) - length("/bin/echo"))' "$(getconf ARG_MAX)" )
sh: /bin/echo: Argument list too long

    Ainda muito tempo. Por quanto?

    i=0
while ! /bin/echo $( perl -e 'print "x" x ($ARGV[0] - length($ENV{"PATH"}) - length("/bin/echo") - $ARGV[1])' "$(getconf ARG_MAX)" "$i" )
do
    i=$(( i + 1 ))
done

    Este loop sai para i=8.

    Portanto, há quatro bytes que não posso explicar imediatamente (quatro dos oito devem ser para o nome da PATHvariável de ambiente). Esses são os terminadores nulos para as quatro strings PATH, o valor de PATHe /bin/echoa longa string de xcaracteres.

    Observe que cada argumento é terminado em nulo, portanto, quanto mais argumentos você tiver para o comando, menor será o comprimento combinado deles.

    Além disso, apenas para mostrar o efeito de um ambiente grande:

    $ export BIG=$( perl -e 'print "x" x $ARGV[0]' "$( getconf ARG_MAX )" )

$ /bin/echo hello
sh: /bin/echo: Argument list too long

$ /bin/echo
sh: /bin/echo: Argument list too long
    • 10

  2. Em muitas distribuições Linux, você pode descobrir qual é o valor atual de ARG_MAX executando

    getconf ARG_MAX

    Uma maneira simples de gerar a mensagem "Lista de argumentos muito longa" é fornecer uma lista de argumentos longa; por exemplo, no meu sistema

    /bin/echo "$(find / -xdev 2> /dev/null)"

    funciona, mas

    /bin/echo "$(find / -xdev 2> /dev/null)" "$(find / -xdev 2> /dev/null)"

    produz

    bash: /bin/echo: Argument list too long

    Para uma discussão aprofundada, consulte " Erro na lista de argumentos muito longa para comandos rm, cp, mv " no Stack Overflow.

    PS O comprimento em questão é a quantidade real de memória necessária para armazenar os argumentos e o ambiente. Não está relacionado com o número de argumentos.

    • 8

  3. Em vez de listar todos os arquivos do sistema, o que demora uma eternidade e não funciona em sistemas esparsos, o comando

    /bin/echo {1..200000}

    é uma maneira muito mais rápida (163ms) de gerar o erro. Para mim ARG_MAXé 2097152(2.097.152 na ordem de 2 milhões), mas o comando ainda apresenta erros.

    Se o seu shell não tiver {start..end}, você pode usar o um pouco mais lento (mas ainda mais rápido do que listar arquivos)

    /bin/echo $(seq 1 200000)

    Se qualquer um dos comandos não funcionar, apenas aumente o valor final até que funcione, até bashficar sem memória ou até seqnão poder contar mais.

    • 6

  4. Para facilitar, inicie um novo shell ( exitquando concluído) e defina o limite para um valor menor (100kbytes):

    $ bash
$ ulimit -s 100

    Com o exemplo que você usou, o erro pode ser acionado:

    $ touch {1..100000}.jpg
bash: /usr/bin/touch: Argument list too long

    Mas é melhor usar algo como echo. Entenda que um builtin pode não acionar um erro, este comando deve funcionar corretamente:

    $ echo {000001..100000}6789

    Observe também que a quantidade de bytes está bem acima do limite definido acima (1,1 Mbyte):

    $ echo {000001..100000}6789 | wc -c
1100000

    Mas este comando não funcionará:

    $ /bin/echo {000001..100000}6789
bash: /bin/echo: Argument list too long

    O limite é definido pelo tamanho da lista de argumentos em bytes adicionados ao tamanho do ambiente do shell.

    • 6

relate perguntas