Elenco degli argomenti errore troppo lungo per i comandi rm, cp, mv

Ho diverse centinaia di PDF in una directory in UNIX. I nomi dei PDF sono molto lunghi (circa 60 caratteri).

Quando provo a eliminare tutti i PDF insieme usando il seguente comando:

rm -f *.pdf

Ottengo il seguente errore:

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

Qual è la soluzione a questo errore? Questo errore si verifica per mve cpcomandi come bene? Se sì, come risolvere questi comandi?

Il motivo si verifica perché bash in realtà espande l'asterisco a ogni file corrispondente, producendo una riga di comando molto lunga.

Prova questo:

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

Attenzione: questa è una ricerca ricorsiva e troverà (ed eliminerà) i file anche nelle sottodirectory. Attenersi -fal comando rm solo se si è sicuri di non voler confermare.

È possibile effettuare le seguenti operazioni per rendere il comando non ricorsivo:

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

Un'altra opzione è usare la -deletebandiera di find :

find . -name "*.pdf" -delete

tl; dr

È una limitazione del kernel sulla dimensione dell'argomento della riga di comando. Utilizzare forinvece un ciclo.

Origine del problema

Questo è un problema di sistema, correlato execvee ARG_MAXcostante. C'è molta documentazione al riguardo (vedi man execve , debian's wiki ).

Fondamentalmente, l'espansione produce un comando (con i suoi parametri) che supera il ARG_MAXlimite. Sul kernel 2.6.23, il limite è stato fissato a 128 kB. Questa costante è stata aumentata e puoi ottenerne il valore eseguendo:

getconf ARG_MAX
# 2097152 # on 3.5.0-40-generic

Soluzione: utilizzo di forLoop

Utilizzare un forloop come consigliato su BashFAQ / 095 e non vi sono limiti ad eccezione dello spazio RAM / memoria:

La corsa a secco per accertarsi che cancellerà ciò che ti aspetti:

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

Ed eseguilo:

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

Anche questo è un approccio portatile poiché glob hanno un comportamento forte e coerente tra le shell ( parte delle specifiche POSIX ).

Nota: come notato da diversi commenti, questo è effettivamente più lento ma più mantenibile in quanto può adattare scenari più complessi, ad esempio dove si vuole fare più di una sola azione.

Soluzione: utilizzo find

Se insisti, puoi usare findma in realtà non usare xargs in quanto "è pericoloso (rotto, sfruttabile, ecc.) Quando leggi input non delimitati da NUL" :

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

L'utilizzo -maxdepth 1 ... -deleteinvece di -exec rm {} +consente findsemplicemente di eseguire da solo le chiamate di sistema richieste senza utilizzare un processo esterno, quindi più veloce (grazie al commento di @chepner ).

Riferimenti

• Ricevo "Elenco argomenti troppo lungo". Come posso elaborare un ampio elenco in blocchi? @ Wooledge
• execve (2) - Man page di Linux (cerca ARG_MAX);
• Errore: elenco degli argomenti troppo lungo @ wiki di Debian;
• Perché ottengo "/ bin / sh: Elenco argomenti troppo lungo" quando si passano gli argomenti tra virgolette? @ SuperUser

findha -deleteun'azione:

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

Un'altra risposta è forzare xargsl'elaborazione dei comandi in batch. Ad esempio ai deletefile 100alla volta, cdnella directory ed esegui questo:

echo *.pdf | xargs -n 100 rm

Oppure puoi provare:

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

Se stai cercando di eliminare un numero molto elevato di file contemporaneamente (ho eliminato una directory con 485.000+ oggi), probabilmente ti imbatterai in questo errore:

/bin/rm: Argument list too long.

Il problema è che quando si digita qualcosa di simile rm -rf *, *viene sostituito con un elenco di tutti i file corrispondenti, come "rm -rf file1 file2 file3 file4" e così via. Esiste un buffer di memoria relativamente piccolo allocato per la memorizzazione di questo elenco di argomenti e se viene riempito, la shell non eseguirà il programma.

Per ovviare a questo problema, molte persone useranno il comando find per trovare ogni file e passarli uno alla volta al comando "rm" in questo modo:

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

Il mio problema è che dovevo eliminare 500.000 file e impiegava troppo tempo.

Mi sono imbattuto in un modo molto più veloce di eliminare i file: il comando "trova" ha un flag "-elimina" integrato! Ecco cosa ho finito per usare:

find . -type f -delete

Usando questo metodo, stavo cancellando i file a una velocità di circa 2000 file / secondo - molto più velocemente!

Puoi anche mostrare i nomi dei file mentre li elimini:

find . -type f -print -delete

... o mostra anche quanti file verranno eliminati, quindi il tempo necessario per eliminarli:

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

puoi provare questo:

for f in *.pdf
do
  rm $f
done

EDIT: il commento di ThiefMaster mi suggerisce di non rivelare una pratica così pericolosa ai jedis della giovane shell, quindi aggiungerò una versione più "più sicura" (per salvaguardare le cose quando qualcuno ha un file "-rf. ..Pdf")

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

Dopo aver eseguito quanto sopra, basta aprire il file /tmp/dummy.sh nel tuo preferito. editare e controllare ogni singola riga per nomi di file pericolosi, commentandoli se trovati.

Quindi copia lo script dummy.sh nella directory di lavoro ed eseguilo.

Tutto questo per motivi di sicurezza.

È possibile utilizzare un array bash:

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

In questo modo verrà cancellato in batch di 1000 file per passaggio.

puoi usare questo encomio

find -name "*.pdf"  -delete

Il comando rm ha una limitazione di file che è possibile rimuovere contemporaneamente.

Una possibilità è possibile rimuoverli utilizzando più volte le basi di comando rm sui modelli di file, come:

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

Puoi anche rimuoverli tramite il comando find :

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

Se sono nomi di file con spazi o caratteri speciali, utilizzare:

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

Questa frase cerca tutti i file nella directory corrente (-maxdepth 1) con estensione pdf (-name '* .pdf'), quindi elimina ognuno (-exec rm "{}").

L'espressione {} sostituisce il nome del file e, "{}" imposta il nome file come stringa, inclusi spazi o caratteri speciali.

stavo affrontando lo stesso problema durante la copia della directory sorgente del modulo a destinazione

la directory di origine aveva file ~ 3 lakcs

ho usato cp con l'opzione -r ed ha funzionato per me

cp -r abc / def /

copierà tutti i file da abc a def senza avvertire troppo a lungo l'elenco degli argomenti

Prova anche questo Se vuoi cancellare file / cartelle superiori a 30/90 giorni (+) o meno di 30/90 (-) giorni, puoi usare i seguenti comandi ex

Esempio: per 90 giorni escluso sopra dopo l'eliminazione di file / cartelle di 90 giorni, significa 91,92 .... 100 giorni

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

Esempio: per gli ultimi file di 30 giorni che desideri eliminare, utilizza il comando seguente (-)

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

Se vuoi giz i file per più di 2 giorni

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

Se vuoi vedere i file / le cartelle solo da un mese. Ex:

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

Oltre i 30 giorni in più solo allora elenca i file / cartelle Es:

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

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

Sono sorpreso che non ci siano ulimitrisposte qui. Ogni volta che ho questo problema, finisco qui o qui . Capisco che questa soluzione ha dei limiti ma ulimit -s 65536sembra spesso fare il trucco per me.

Ho avuto lo stesso problema con una cartella piena di immagini temporanee che cresceva giorno dopo giorno e questo comando mi ha aiutato a cancellare la cartella

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

La differenza con gli altri comandi è il parametro mtime che prenderà solo i file più vecchi di X giorni (nell'esempio 50 giorni)

Usandolo più volte, diminuendo ad ogni esecuzione nell'intervallo di giorno, sono stato in grado di rimuovere tutti i file non necessari

Conosco solo un modo per aggirare questo. L'idea è di esportare quell'elenco di file pdf che hai in un file. Quindi suddividere il file in più parti. Quindi rimuovere i file pdf elencati in ogni parte.

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

wc -l è contare quante righe contiene list.txt. Quando hai l'idea di quanto tempo, puoi decidere di dividerlo a metà, avanti o qualcosa del genere. Uso del comando split -l Ad esempio, dividerlo in 600 righe ciascuno.

split -l 600 list.txt

questo creerà alcuni file chiamati xaa, xab, xac e così via dipende da come lo dividi. Ora per "importare" ogni elenco in quei file nel comando rm, usa questo:

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

Scusa per il mio cattivo inglese.

Ho riscontrato questo problema alcune volte. Molte delle soluzioni eseguiranno il rmcomando per ogni singolo file che deve essere eliminato. Questo è molto inefficiente:

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

Ho finito per scrivere uno script Python per eliminare i file in base ai primi 4 caratteri nel nome file:

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')

Questo ha funzionato molto bene per me. Sono stato in grado di cancellare oltre 2 milioni di file temporanei in una cartella in circa 15 minuti. Ho commentato il tar del bit di codice in modo che chiunque abbia una conoscenza minima o nulla del pitone possa manipolare questo codice.

E un altro:

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

printfè una shell incorporata e, per quanto ne so, è sempre stata tale. Ora dato che printfnon è un comando shell (ma un builtin), non è soggetto a " argument list too long ..." errore fatale.

Quindi possiamo tranquillamente usarlo con modelli di globbing della shell come *.[Pp][Dd][Ff], quindi convogliamo il suo output per rimuovere ( rm) il comando, attraverso xargs, che si assicura che si adatti a abbastanza nomi di file nella riga di comando in modo da non fallire il rmcomando, che è una shell comando.

La \0in printffunga da separatore nullo per i nomi di file goduto vengono poi elaborati dal xargscomando, usando ( -0) come separatore, quindi rmnon fallisce quando ci sono spazi bianchi o altri caratteri speciali nei nomi di file.

Puoi creare una cartella temporanea, spostare tutti i file e le sottocartelle che desideri conservare nella cartella temporanea, quindi eliminare la vecchia cartella e rinominare la cartella temporanea nella vecchia cartella, prova questo esempio fino a quando non sei sicuro di farlo dal 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

la rm -r big_folderrimuoverà tutti i file nella big_foldernon importa quante. Devi solo fare molta attenzione prima di avere tutti i file / cartelle che vuoi conservare, in questo caso lo erafile1.pdf

Per eliminare tutto *.pdfin una directory/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/

Eliminare file specifici tramite l' rsyncuso di caratteri jolly è probabilmente la soluzione più veloce nel caso abbiate milioni di file. E si prenderà cura dell'errore che stai ricevendo.

(Passaggio opzionale): DRY RUN. Per controllare cosa verrà eliminato senza eliminare. `

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

. . .

Fai clic su suggerimenti e trucchi per rsync per ulteriori hack di rsync

Ho scoperto che per elenchi di file estremamente grandi (> 1e6), queste risposte erano troppo lente. Ecco una soluzione che utilizza l'elaborazione parallela in Python. Lo so, lo so, questo non è Linux ... ma nient'altro qui ha funzionato.

(Questo mi ha risparmiato ore)

# 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)

Ho riscontrato un problema simile quando c'erano milioni di file di registro inutili creati da un'applicazione che riempiva tutti gli inode. Ho fatto ricorso a "individuare", ho ottenuto tutti i file "trova" d in un file di testo e poi li ho rimossi uno per uno. Ci è voluto un po 'ma ha fatto il lavoro!

Una versione un po 'più sicura rispetto all'utilizzo di xargs, anche non ricorsiva: ls -p | grep -v '/$' | grep '\.pdf$' | while read file; do rm "$file"; done

Filtrare le nostre directory qui è un po 'inutile in quanto' rm 'non lo eliminerà comunque, e può essere rimosso per semplicità, ma perché eseguire qualcosa che sicuramente restituirà errore?

Usando GNU parallel (sudo apt install parallel ) è semplicissimo

Esegue i comandi multithread dove "{}" è l'argomento passato

Per esempio

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

Per rimuovere i primi 100 file:

rm -rf 'ls | testa -100 '

L'opzione di seguito sembra semplice a questo problema. Ho ricevuto queste informazioni da qualche altra discussione ma mi ha aiutato.

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

Basta eseguire il comando precedente e farà il compito.