Liste d'arguments erreur trop longue pour les commandes rm, cp, mv

J'ai plusieurs centaines de PDF sous un répertoire sous UNIX. Les noms des PDF sont vraiment longs (environ 60 caractères).

Lorsque j'essaie de supprimer tous les PDF ensemble à l'aide de la commande suivante:

rm -f *.pdf

J'obtiens l'erreur suivante:

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

Quelle est la solution à cette erreur? Est -ce que cette erreur se produit pour mvet des cpcommandes ainsi? Si oui, comment résoudre ces commandes?

La raison en est que bash étend réellement l'astérisque à chaque fichier correspondant, produisant une très longue ligne de commande.

Essaye ça:

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

Avertissement: il s'agit d'une recherche récursive qui trouvera (et supprimera) les fichiers dans les sous-répertoires également. N'utilisez -fla commande rm que si vous êtes sûr de ne pas vouloir de confirmation.

Vous pouvez effectuer les opérations suivantes pour rendre la commande non récursive:

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

Une autre option consiste à utiliser l' -deleteindicateur find :

find . -name "*.pdf" -delete

tl; dr

C'est une limitation du noyau sur la taille de l'argument de ligne de commande. Utilisez forplutôt une boucle.

Origine du problème

Il s'agit d'un problème système, lié execveet ARG_MAXconstant. Il y a beaucoup de documentation à ce sujet (voir man execve , wiki de debian ).

Fondamentalement, l'expansion produit une commande (avec ses paramètres) qui dépasse la ARG_MAXlimite. Sur le noyau 2.6.23, la limite a été fixée à 128 kB. Cette constante a été augmentée et vous pouvez obtenir sa valeur en exécutant:

getconf ARG_MAX
# 2097152 # on 3.5.0-40-generic

Solution: utiliser la forboucle

Utilisez une forboucle comme il est recommandé sur BashFAQ / 095 et il n'y a pas de limite sauf pour la RAM / espace mémoire:

Un essai à sec pour vérifier qu'il supprimera ce que vous attendez:

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

Et exécutez-le:

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

C'est également une approche portable car les glob ont un comportement fort et cohérent entre les shells ( partie de la spécification POSIX ).

Remarque: Comme indiqué par plusieurs commentaires, cela est en effet plus lent mais plus facile à gérer car il peut adapter des scénarios plus complexes, par exemple lorsque l'on veut faire plus d'une seule action.

Solution: utilisation find

Si vous insistez, vous pouvez utiliser findmais n'utilisez vraiment pas xargs car il "est dangereux (cassé, exploitable, etc.) lors de la lecture d'une entrée non délimitée par NUL" :

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

Utiliser -maxdepth 1 ... -deleteau lieu de -exec rm {} +permet findd'exécuter simplement les appels système requis sans utiliser de processus externe, donc plus rapide (grâce au commentaire @chepner ).

Références

• Je reçois une "Liste d'arguments trop longue". Comment puis-je traiter une grande liste en morceaux? @ wooledge
• execve (2) - Page de manuel Linux (recherchez ARG_MAX);
• Erreur: Liste d'arguments trop longue @ wiki Debian;
• Pourquoi est-ce que j'obtiens «/ bin / sh: Liste d'arguments trop longue» lorsque je passe des arguments entre guillemets? @ SuperUser

finda une -deleteaction:

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

Une autre réponse consiste à forcer xargsle traitement des commandes par lots. Par exemple pour deleteles fichiers 100à la fois, cddans le répertoire et exécutez ceci:

echo *.pdf | xargs -n 100 rm

Ou vous pouvez essayer:

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

Si vous essayez de supprimer un très grand nombre de fichiers à la fois (j'ai supprimé un répertoire avec 485 000+ aujourd'hui), vous rencontrerez probablement cette erreur:

/bin/rm: Argument list too long.

Le problème est que lorsque vous tapez quelque chose comme rm -rf *, le *est remplacé par une liste de tous les fichiers correspondants, comme «rm -rf fichier1 fichier2 fichier3 fichier4» et ainsi de suite. Il y a un tampon de mémoire relativement petit alloué au stockage de cette liste d'arguments et s'il est rempli, le shell n'exécutera pas le programme.

Pour contourner ce problème, beaucoup de gens utiliseront la commande find pour trouver chaque fichier et les passeront un par un à la commande "rm" comme ceci:

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

Mon problème est que j'avais besoin de supprimer 500 000 fichiers et cela prenait beaucoup trop de temps.

Je suis tombé sur un moyen beaucoup plus rapide de supprimer des fichiers - la commande "find" a un indicateur "-delete" intégré! Voici ce que j'ai fini par utiliser:

find . -type f -delete

En utilisant cette méthode, je supprimais des fichiers à une vitesse d'environ 2000 fichiers / seconde - beaucoup plus rapidement!

Vous pouvez également afficher les noms de fichiers lorsque vous les supprimez:

find . -type f -print -delete

… Ou même montrer combien de fichiers seront supprimés, puis le temps nécessaire pour les supprimer:

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

vous pouvez essayer ceci:

for f in *.pdf
do
  rm $f
done

EDIT: Le commentaire de ThiefMaster me suggère de ne pas divulguer une telle pratique dangereuse aux jedis du jeune shell, donc j'ajouterai une version plus "plus sûre" (pour préserver les choses quand quelqu'un a un fichier "-rf. ..Pdf")

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

Après avoir exécuté ce qui précède, ouvrez simplement le fichier /tmp/dummy.sh dans votre fav. éditeur et vérifiez chaque ligne pour les noms de fichiers dangereux, en les commentant s'ils sont trouvés.

Copiez ensuite le script dummy.sh dans votre répertoire de travail et exécutez-le.

Tout cela pour des raisons de sécurité.

Vous pouvez utiliser un tableau bash:

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

De cette façon, il sera effacé par lots de 1000 fichiers par étape.

vous pouvez utiliser cette recommandation

find -name "*.pdf"  -delete

La commande rm a une limitation de fichiers que vous pouvez supprimer simultanément.

Vous pouvez les supprimer en utilisant plusieurs fois la commande rm en fonction de vos modèles de fichiers, comme:

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

Vous pouvez également les supprimer via la commande find :

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

S'il s'agit de noms de fichiers avec des espaces ou des caractères spéciaux, utilisez:

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

Cette phrase recherche tous les fichiers du répertoire courant (-maxdepth 1) avec l'extension pdf (-name '* .pdf'), puis supprime chacun (-exec rm "{}").

L'expression {} remplace le nom du fichier et "{}" définit le nom de fichier sous forme de chaîne, y compris les espaces ou les caractères spéciaux.

j'étais confronté au même problème lors de la copie du répertoire source du formulaire vers la destination

le répertoire source avait des fichiers ~ 3 lakcs

j'ai utilisé cp avec l'option -r et cela a fonctionné pour moi

cp -r abc / def /

il copiera tous les fichiers de abc vers def sans avertir de la liste d'arguments trop longtemps

Essayez aussi ceci Si vous voulez supprimer des fichiers / dossiers au-dessus de 30/90 jours (+) ou au-dessous de 30/90 jours (-), vous pouvez utiliser les commandes ex ci-dessous

Ex: pour 90 jours exclut ci-dessus après 90 jours de suppression de fichiers / dossiers, cela signifie 91,92 .... 100 jours

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

Ex: pour les derniers fichiers 30 jours que vous souhaitez supprimer, utilisez la commande ci-dessous (-)

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

Si vous voulez giz les fichiers depuis plus de 2 jours

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

Si vous ne souhaitez voir les fichiers / dossiers que depuis un mois. Ex:

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

Au-dessus de 30 jours de plus seulement, répertoriez les fichiers / dossiers Ex:

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

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

Je suis surpris qu'il n'y ait pas de ulimitréponses ici. Chaque fois que j'ai ce problème, je me retrouve ici ou ici . Je comprends que cette solution a ses limites mais ulimit -s 65536semble souvent faire l'affaire pour moi.

J'ai eu le même problème avec un dossier plein d'images temporaires qui grandissait de jour en jour et cette commande m'a aidé à effacer le dossier

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

La différence avec les autres commandes est le paramètre mtime qui ne prendra que les fichiers antérieurs à X jours (dans l'exemple 50 jours)

En utilisant cela plusieurs fois, diminuant à chaque exécution de la plage de jours, j'ai pu supprimer tous les fichiers inutiles

Je ne connais qu'un moyen de contourner cela. L'idée est d'exporter cette liste de fichiers pdf que vous avez dans un fichier. Ensuite, divisez ce fichier en plusieurs parties. Supprimez ensuite les fichiers pdf répertoriés dans chaque partie.

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

wc -l consiste à compter le nombre de lignes que contient list.txt. Lorsque vous avez une idée de sa durée, vous pouvez décider de la diviser en deux, en avant ou quelque chose comme ça. Utilisation de la commande split -l Par exemple, divisez-la en 600 lignes chacune.

split -l 600 list.txt

cela créera quelques fichiers nommés xaa, xab, xac et ainsi de suite dépend de la façon dont vous le divisez. Maintenant, pour "importer" chaque liste de ces fichiers dans la commande rm, utilisez ceci:

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

Désolé pour mon mauvais anglais.

J'ai rencontré ce problème plusieurs fois. De nombreuses solutions exécuteront la rmcommande pour chaque fichier individuel qui doit être supprimé. C'est très inefficace:

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

J'ai fini par écrire un script python pour supprimer les fichiers en fonction des 4 premiers caractères du nom de fichier:

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

Cela a très bien fonctionné pour moi. J'ai pu effacer plus de 2 millions de fichiers temporaires dans un dossier en environ 15 minutes. J'ai commenté le goudron du petit bout de code pour que toute personne ayant peu ou pas de connaissances en python puisse manipuler ce code.

Et un autre:

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

printfest un shell intégré, et pour autant que je sache, il en a toujours été ainsi. Maintenant que ce printfn'est pas une commande shell (mais une commande intégrée), elle n'est pas sujette à argument list too long ...une erreur fatale.

Nous pouvons donc l'utiliser en toute sécurité avec des modèles de globalisation du shell tels que *.[Pp][Dd][Ff], puis nous dirigeons sa sortie vers la rmcommande remove ( ), à travers xargs, ce qui garantit qu'il tient suffisamment de noms de fichiers dans la ligne de commande afin de ne pas échouer la rmcommande, qui est un shell commander.

Le \0en printfsert un séparateur nul pour les noms de fichier dont sont ensuite traitées par xargscommande, en l' utilisant ( -0) comme séparateur, donc rmne manque pas quand il y a des espaces blancs ou d' autres caractères spéciaux dans les noms de fichiers.

Vous pouvez créer un dossier temporaire, déplacer tous les fichiers et sous-dossiers que vous souhaitez conserver dans le dossier temporaire, puis supprimer l'ancien dossier et renommer le dossier temporaire en l'ancien dossier, essayez cet exemple jusqu'à ce que vous soyez sûr de le faire en direct:

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

le rm -r big_foldersupprimera tous les fichiers dans big_foldern'importe quel nombre. Vous devez juste être super prudent, vous devez d'abord avoir tous les fichiers / dossiers que vous souhaitez conserver, dans ce cas, c'étaitfile1.pdf

Pour tout supprimer *.pdfdans un répertoire/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/

Supprimer des fichiers spécifiques à l' rsyncaide de caractères génériques est probablement la solution la plus rapide si vous avez des millions de fichiers. Et cela corrigera les erreurs que vous obtenez.

(Étape facultative): DRY RUN. Pour vérifier ce qui sera supprimé sans le supprimer. "

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

. . .

Cliquez sur trucs et astuces rsync pour plus de hacks rsync

J'ai trouvé que pour les listes de fichiers extrêmement volumineuses (> 1e6), ces réponses étaient trop lentes. Voici une solution utilisant le traitement parallèle en python. Je sais, je sais, ce n'est pas Linux ... mais rien d'autre n'a fonctionné ici.

(Cela m'a fait gagner des heures)

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

J'ai rencontré un problème similaire lorsqu'il y avait des millions de fichiers journaux inutiles créés par une application qui remplissait tous les inodes. J'ai recouru à «localiser», j'ai obtenu tous les fichiers «localisés» d dans un fichier texte, puis les ai supprimés un par un. A pris du temps mais a fait le boulot!

Une version un peu plus sûre que l'utilisation de xargs, également non récursive: ls -p | grep -v '/$' | grep '\.pdf$' | while read file; do rm "$file"; done

Filtrer nos répertoires ici est un peu inutile car 'rm' ne le supprimera pas de toute façon, et il peut être supprimé pour plus de simplicité, mais pourquoi exécuter quelque chose qui retournera définitivement une erreur?

Utiliser GNU parallel ( sudo apt install parallel) est super facile

Il exécute les commandes multithread où '{}' est l'argument passé

Par exemple

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

Pour supprimer les 100 premiers fichiers:

rm -rf 'ls | tête -100 '

L'option ci-dessous semble simple à ce problème. J'ai obtenu cette information d'un autre fil, mais cela m'a aidé.

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

Exécutez simplement la commande ci-dessus et elle fera la tâche.