Erro muito longo na lista de argumentos para comandos rm, cp, mv

Eu tenho várias centenas de PDFs em um diretório no UNIX. Os nomes dos PDFs são realmente longos (aprox. 60 caracteres).

Quando tento excluir todos os PDFs juntos, usando o seguinte comando:

rm -f *.pdf

Estou tendo o erro a seguir:

/bin/rm: cannot execute [Argument list too long]

Qual é a solução para esse erro? Este erro ocorre para mve cpcomandos também? Se sim, como resolver esses comandos?

Isso ocorre porque o bash realmente expande o asterisco para todos os arquivos correspondentes, produzindo uma linha de comando muito longa.

Tente o seguinte:

find . -name "*.pdf" -print0 | xargs -0 rm

Aviso: esta é uma pesquisa recursiva e também encontrará (e excluir) arquivos em subdiretórios. Prenda -fo comando rm apenas se tiver certeza de que não deseja confirmação.

Você pode fazer o seguinte para tornar o comando não recursivo:

find . -maxdepth 1 -name "*.pdf" -print0 | xargs -0 rm

Outra opção é usar o -deletesinalizador de localização:

find . -name "*.pdf" -delete

tl; dr

É uma limitação do kernel no tamanho do argumento da linha de comando. Use um forloop em seu lugar.

Origem do problema

Este é um problema do sistema, relacionado execvee ARG_MAXconstante. Há muita documentação sobre isso (veja man execve , wiki do debian ).

Basicamente, a expansão produz um comando (com seus parâmetros) que excede o ARG_MAXlimite. No kernel 2.6.23, o limite foi definido em 128 kB. Essa constante foi aumentada e você pode obter seu valor executando:

getconf ARG_MAX
# 2097152 # on 3.5.0-40-generic

Solução: Usando forLoop

Use um forloop conforme recomendado no BashFAQ / 095 e não há limite, exceto para RAM / espaço de memória:

Execução a seco para verificar se ele excluirá o que você espera:

for f in *.pdf; do echo rm "$f"; done

E execute:

for f in *.pdf; do rm "$f"; done

Além disso, esta é uma abordagem portátil, pois a glob possui um comportamento forte e consistente entre os shells ( parte das especificações do POSIX ).

Nota: Como observado por vários comentários, isso é realmente mais lento, mas mais sustentável, pois pode adaptar cenários mais complexos, por exemplo , onde se deseja fazer mais do que apenas uma ação.

Solução: Usando find

Se você insiste, pode usar, findmas realmente não usa xargs , pois "é perigoso (quebrado, explorável etc.) ao ler entradas não delimitadas por NUL" :

find . -maxdepth 1 -name '*.pdf' -delete 

Usar em -maxdepth 1 ... -deletevez de -exec rm {} +permite findsimplesmente executar as chamadas necessárias do sistema sem usar um processo externo, portanto, mais rápido (graças ao comentário do @chepner ).

Referências

• Estou recebendo "Lista de argumentos muito longa". Como posso processar uma lista grande em pedaços? @ wooledge
• execve (2) - página de manual do Linux (procure por ARG_MAX);
• Erro: Lista de argumentos muito longa no wiki do Debian;
• Por que obtenho “/ bin / sh: lista de argumentos muito longa” ao passar argumentos citados? @ Superusuário

findtem uma -deleteação:

find . -maxdepth 1 -name '*.pdf' -delete

Outra resposta é forçar o xargsprocessamento dos comandos em lotes. Por exemplo, para deleteos arquivos de 100cada vez, cdno diretório e execute:

echo *.pdf | xargs -n 100 rm

Ou você pode tentar:

find . -name '*.pdf' -exec rm -f {} \;

Se você estiver tentando excluir um número muito grande de arquivos ao mesmo tempo (eu excluí um diretório com mais de 485.000 hoje), provavelmente você encontrará esse erro:

/bin/rm: Argument list too long.

O problema é que, quando você digita algo como rm -rf *, o *é substituído por uma lista de todos os arquivos correspondentes, como “rm -rf arquivo1 arquivo2 arquivo3 arquivo4” e assim por diante. Há um buffer de memória relativamente pequeno alocado para armazenar esta lista de argumentos e, se estiver cheia, o shell não executará o programa.

Para contornar esse problema, muitas pessoas usarão o comando find para encontrar todos os arquivos e passá-los um a um para o comando “rm” como este:

find . -type f -exec rm -v {} \;

Meu problema é que eu precisava excluir 500.000 arquivos e estava demorando muito.

Eu me deparei com uma maneira muito mais rápida de excluir arquivos - o comando “find” tem uma bandeira “-delete” embutida! Aqui está o que eu acabei usando:

find . -type f -delete

Usando esse método, eu estava excluindo arquivos a uma taxa de cerca de 2000 arquivos / segundo - muito mais rápido!

Você também pode mostrar os nomes dos arquivos ao excluí-los:

find . -type f -print -delete

… Ou até mostrar quantos arquivos serão excluídos e tempo quanto tempo leva para excluí-los:

root@devel# ls -1 | wc -l && time find . -type f -delete
100000
real    0m3.660s
user    0m0.036s
sys     0m0.552s

você pode tentar isso:

for f in *.pdf
do
  rm $f
done

EDIT: O comentário do ThiefMaster sugere que eu não divulgue essa prática perigosa aos jedis do jovem shell, então adicionarei uma versão mais "segura" (para preservar as coisas quando alguém tem um arquivo "-rf. ..Pdf")

echo "# Whooooo" > /tmp/dummy.sh
for f in '*.pdf'
do
   echo "rm -i $f" >> /tmp/dummy.sh
done

Após executar o procedimento acima, basta abrir o arquivo /tmp/dummy.sh no seu favorito. editor e verifique se há nomes de arquivos perigosos em todas as linhas, comentando-os, se encontrados.

Em seguida, copie o script dummy.sh no seu diretório de trabalho e execute-o.

Tudo isso por razões de segurança.

Você pode usar uma matriz bash:

files=(*.pdf)
for((I=0;I<${#files[@]};I+=1000)); do
    rm -f "${files[@]:I:1000}"
done

Dessa forma, ele será apagado em lotes de 1000 arquivos por etapa.

você pode usar esse elogio

find -name "*.pdf"  -delete

O comando rm possui uma limitação de arquivos que você pode remover simultaneamente.

Uma possibilidade é removê-los usando várias vezes o comando rm com base em seus padrões de arquivo, como:

rm -f A*.pdf
rm -f B*.pdf
rm -f C*.pdf
...
rm -f *.pdf

Você também pode removê-los através do comando find :

find . -name "*.pdf" -exec rm {} \;

Se forem nomes de arquivos com espaços ou caracteres especiais, use:

find -maxdepth 1 -name '*.pdf' -exec rm "{}" \;

Essa frase pesquisa todos os arquivos no diretório atual (-maxdepth 1) com a extensão pdf (-name '* .pdf') e, em seguida, exclua cada um (-exec rm "{}").

A expressão {} substitui o nome do arquivo e "{}" define o nome do arquivo como string, incluindo espaços ou caracteres especiais.

eu estava enfrentando o mesmo problema ao copiar o diretório de origem do formulário para o destino

diretório de origem tinha arquivos ~ 3 lakcs

usei cp com a opção -r e funcionou para mim

cp -r abc / def /

ele copiará todos os arquivos do abc para o def sem avisar por muito tempo a lista de argumentos

Tente isso também Se você quiser excluir arquivos / pastas acima de 30/90 dias (+) ou abaixo de 30/90 (-) dias, use os comandos ex abaixo

Ex: para 90 dias exclui acima após 90 dias, arquivos / pastas são excluídos, significa 91,92 .... 100 dias

find <path> -type f -mtime +90 -exec rm -rf {} \;

Ex: Apenas para os arquivos mais recentes de 30 dias que você deseja excluir, use o comando abaixo (-)

find <path> -type f -mtime -30 -exec rm -rf {} \;

Se você deseja alterar os arquivos por mais de 2 dias

find <path> -type f -mtime +2 -exec gzip {} \;

Se você quiser ver os arquivos / pastas apenas no último mês. Ex:

find <path> -type f -mtime -30 -exec ls -lrt {} \;

Acima de mais de 30 dias, apenas liste os arquivos / pastas Ex:

find <path> -type f -mtime +30 -exec ls -lrt {} \;

find /opt/app/logs -type f -mtime +30 -exec ls -lrt {} \;

Estou surpreso que não haja ulimitrespostas aqui. Toda vez que tenho esse problema, acabo aqui ou aqui . Entendo que esta solução tem limitações, mas ulimit -s 65536parece que costuma fazer o truque para mim.

Eu tive o mesmo problema com uma pasta cheia de imagens temporárias que crescia dia a dia e esse comando me ajudou a limpar a pasta

find . -name "*.png" -mtime +50 -exec rm {} \;

A diferença com os outros comandos é o parâmetro mtime que levará apenas os arquivos com mais de X dias (no exemplo 50 dias)

Usando isso várias vezes, diminuindo a cada execução do período, pude remover todos os arquivos desnecessários

Eu só sei uma maneira de contornar isso. A idéia é exportar a lista de arquivos pdf que você possui para um arquivo. Em seguida, divida esse arquivo em várias partes. Em seguida, remova os arquivos pdf listados em cada parte.

ls | grep .pdf > list.txt
wc -l list.txt

wc -l é para contar quantas linhas o list.txt contém. Quando você tem a idéia de quanto tempo leva, pode decidir dividi-lo ao meio, para a frente ou algo assim. Usando o comando split -l Por exemplo, divida-o em 600 linhas cada.

split -l 600 list.txt

isso criará alguns arquivos chamados xaa, xab, xac e assim por diante, dependendo de como você o divide. Agora, para "importar" cada lista desses arquivos no comando rm, use este:

rm $(<xaa)
rm $(<xab)
rm $(<xac)

Desculpe pelo meu inglês ruim.

Eu me deparei com esse problema algumas vezes. Muitas das soluções executam o rmcomando para cada arquivo individual que precisa ser excluído. Isso é muito ineficiente:

find . -name "*.pdf" -print0 | xargs -0 rm -rf

Acabei escrevendo um script python para excluir os arquivos com base nos 4 primeiros caracteres no nome do arquivo:

import os
filedir = '/tmp/' #The directory you wish to run rm on 
filelist = (os.listdir(filedir)) #gets listing of all files in the specified dir
newlist = [] #Makes a blank list named newlist
for i in filelist: 
    if str((i)[:4]) not in newlist: #This makes sure that the elements are unique for newlist
        newlist.append((i)[:4]) #This takes only the first 4 charcters of the folder/filename and appends it to newlist
for i in newlist:
    if 'tmp' in i:  #If statment to look for tmp in the filename/dirname
        print ('Running command rm -rf '+str(filedir)+str(i)+'* : File Count: '+str(len(os.listdir(filedir)))) #Prints the command to be run and a total file count
        os.system('rm -rf '+str(filedir)+str(i)+'*') #Actual shell command
print ('DONE')

Isso funcionou muito bem para mim. Consegui limpar mais de 2 milhões de arquivos temporários em uma pasta em cerca de 15 minutos. Eu comentei o tar do pouco código, para que qualquer pessoa com um conhecimento mínimo ou nenhum de python possa manipular esse código.

E um outro:

cd  /path/to/pdf
printf "%s\0" *.[Pp][Dd][Ff] | xargs -0 rm

printfé um shell embutido e, tanto quanto eu sei, sempre foi assim. Agora, como esse printfnão é um comando do shell (mas um interno), ele não está sujeito a "argument list too long ... " erro fatal.

Assim, podemos usá-lo com segurança com padrões de globbing do shell, como *.[Pp][Dd][Ff], em seguida, canalizamos sua saída para remover ( rm) o comando xargs, o que garante que ele se ajuste a nomes de arquivos suficientes na linha de comando para não falhar norm comando, que é um shell comando.

O \0in printfserve como um separador nulo para os nomes de arquivo que são processados ​​por xargscomando, usando-o ( -0) como separador, para rmque não falhe quando houver espaços em branco ou outros caracteres especiais nos nomes de arquivo.

Você pode criar uma pasta temporária, mover todos os arquivos e subpastas que deseja manter para a pasta temporária, excluir a pasta antiga e renomear a pasta temporária para a pasta antiga. Tente este exemplo até ter certeza de fazê-lo ao vivo:

mkdir testit
cd testit
mkdir big_folder tmp_folder
touch big_folder/file1.pdf
touch big_folder/file2.pdf
mv big_folder/file1,pdf tmp_folder/
rm -r big_folder
mv tmp_folder big_folder

o rm -r big_folderremoverá todos os arquivos, big_foldernão importa quantos. Você só precisa ter muito cuidado, primeiro tem todos os arquivos / pastas que deseja manter, neste caso, foifile1.pdf

Para excluir tudo *.pdfem um diretório/path/to/dir_with_pdf_files/

mkdir empty_dir        # Create temp empty dir

rsync -avh --delete --include '*.pdf' empty_dir/ /path/to/dir_with_pdf_files/

Excluir arquivos específicos rsyncusando o curinga é provavelmente a solução mais rápida, caso você tenha milhões de arquivos. E isso resolverá o erro que você está recebendo.

(Etapa opcional): EXECUÇÃO SECA. Para verificar o que será excluído sem excluir. `

rsync -avhn --delete --include '*.pdf' empty_dir/ /path/to/dir_with_pdf_files/

. . .

Clique em dicas e truques do rsync para obter mais hacks do rsync

Eu descobri que, para listas extremamente grandes de arquivos (> 1e6), essas respostas eram muito lentas. Aqui está uma solução usando processamento paralelo em python. Eu sei, eu sei, isso não é linux ... mas nada aqui funcionou.

(Isso me salvou horas)

# delete files
import os as os
import glob
import multiprocessing as mp

directory = r'your/directory'
os.chdir(directory)


files_names = [i for i in glob.glob('*.{}'.format('pdf'))]

# report errors from pool

def callback_error(result):
    print('error', result)

# delete file using system command
def delete_files(file_name):
     os.system('rm -rf ' + file_name)

pool = mp.Pool(12)  
# or use pool = mp.Pool(mp.cpu_count())


if __name__ == '__main__':
    for file_name in files_names:
        print(file_name)
        pool.apply_async(delete_files,[file_name], error_callback=callback_error)

Eu enfrentei um problema semelhante quando havia milhões de arquivos de log inúteis criados por um aplicativo que preenchia todos os inodes. Eu recorri ao "localizar", coloquei todos os arquivos "localizados" d em um arquivo de texto e os removi um a um. Demorou um pouco, mas fez o trabalho!

Uma versão um pouco mais segura do que usar xargs, também não recursiva: ls -p | grep -v '/$' | grep '\.pdf$' | while read file; do rm "$file"; done

Filtrar nossos diretórios aqui é um pouco desnecessário, pois 'rm' não o exclui de qualquer maneira, e pode ser removido por simplicidade, mas por que executar algo que definitivamente retornará erro?

Usar o GNU paralelo ( sudo apt install parallel) é super fácil

Ele executa os comandos multithread onde '{}' é o argumento passado

Por exemplo

ls /tmp/myfiles* | parallel 'rm {}'

Para remover os 100 primeiros arquivos:

rm -rf 'ls | cabeça -100 '

A opção abaixo parece simples para esse problema. Eu recebi essas informações de algum outro tópico, mas isso me ajudou.

for file in /usr/op/data/Software/temp/application/openpages-storage/*; do
    cp "$file" /opt/sw/op-storage/
done

Basta executar o comando acima e ele fará a tarefa.