Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

Défragmenteur naïf

pnprog

Bonjour à tous !
J'ai réalisé un petit script bash qui permet de défragmenter ses dossiers sur une partition ext3.
En fait, il ne défragmente pas, il duplique/supprime/recrée les fichiers qui sont fragmentés. Autrement dit, il aide ext3 à "s'auto-défragmenter à l'usage" et c'est pour ça que je l'appelle défragmenteur naïf.

Il utilise la commande filefrag pour fonctionner. Filefrag permet de tester la fragmentation d'un fichier. Donc le script ne déplace que les fichiers fragmentés.

Voici le code du script:

#!/bin/bash
#défragmenteur naïf
#auteur: pnprog AT no-log DOT org
#fichier: n_defrag.sh
#version 0.3
#ce script est proposé sous licence GPL2 (General Public License)



########################################
############ initialisation ############
########################################

#nom d'essais par defaut
nb_max_try=10
#le fichier qui servira de buffer
buffer=$(pwd)/buffer
#le fichier de "journalisation"
current_operation=$(pwd)/current

#variables pour les statistiques
nb_fragmented_files=0
nb_files=0
nb_error_files=0
nb_undefragmentable_files=0
fbmo_sum_before=0
fbmo_sum_after=0


########################################
###### affichage du mode d'emploi ######
########################################

display_usage_and_quit()
{
	echo Usage:
	echo -e "\t$0 [-t try] directory"
	echo -e "\tAnalyse and defragment files in directory."
	echo -e "\tThe -t option indcates how many times the programme can try"
	echo -e "\tto defragment a file. Default value is 10."
	echo ""
	echo -e "\t$0 -r"
	echo -e "\tUse this option in case an analyse has been interrupted."
	exit 1
}


########################################
###### vérification des arguments ######
########################################

#répertoire à défragmenter
rep_start=""

#l'utilisateur peut lancer le mode recovery, si l'analyse a été intérompue
if let "$#==1"
then
	if [ "$1" = "-r" ] ;
	then
		#### mode recovery ####
		#on récupere le fichier en cours de l'analyse, si intérompue
		file=$(cat "$current_operation" 2>>/dev/null)
		interrupted=$?
		if [ "$interrupted" = "0" ]
		then
			#recréation du fichier
			cp -p "$buffer" "$file" 2>>/dev/null
		fi
		echo "Recovery done."
		exit 0
	else
		##### mode normal ####
		rep_start="$1"
	fi
fi

#l'utilisateur peut spécifier le nombre d'essais
if let "$#==3"
then
	if [ "$1" = "-t" ] && [ "$2" -ge 0 ] ;
	then
		#### l'utilisateur spécifie le nombre d'essais ####
		rep_start="$3"
		nb_max_try="$2"
	else
		display_usage_and_quit
	fi
fi

#nombre d'argument incohérent (0, 2, 4 ou plus)
if [ "$rep_start" = "" ]
then
	display_usage_and_quit
fi

########################################
#### vérification de filefrag et bc ####
########################################

#http://www.debian.org/doc/developers-reference/ch-best-pkging-practices.fr.html
which filefrag >> /dev/null
if [ "$?" = "1" ]
then
	echo You must install filefrag.
fi

which bc >> /dev/null
if [ "$?" = "1" ]
then
	echo You must install bc.
fi


########################################
#### vérification des droits (root) ####
########################################

UID_ROOT=0
if [ "$UID" -ne "$UID_ROOT" ]
then
	echo You must be root to run filefrag.
	exit 1
fi



########################################
############### fonctions ##############
########################################

function count_fragments
	{
	#4 cas possibles
		#chaine vide, filefrag a causé une erreur
		#file: 1 extent found
		#file: X extents found
		#file: X extents found, perfection would be 1 extent
	file=$1
	result=$(sudo filefrag "$file" 2>> /dev/null)
	if [ "$result" = "" ]
	then
		echo "-1"
	else
		result=${result#"$file":}
		result=${result%% extent*}
		echo $result
	fi
	}

function file_size
	{
	file=$1
	size=$(du -k "$file")
	size=${size%%"$file"}
	echo $size
	}

function frag_by_mo
	{
	file=$1
	nb_fragments=$(count_fragments "$file")
	size=$(file_size "$file")
	if let "$size>0"
	then
		echo "scale=2 ; 1024 * ( $nb_fragments - 1 ) / $size " | bc
	else
		echo 0
	fi
	}

one_more_analyse()
{
	file=$1
	#on compte le nombre de fragments
	nb_fragments=$(count_fragments "$file")
	if let "$nb_fragments>1"
	then
		assemble "$file"
	else
		echo -n " ok"
	fi
}

assemble()
{
	#recollage du fichier
	file=$1
	#on augmente le compteur du nombre de tentatives
	nb_try=$(($nb_try + 1))
	if let "nb_try<=nb_max_try"
	then
		#il reste des tentatives possibles
		#on copie donc le fichier dans le buffer
		cp -p "$file" "$buffer"
		#création du journal
		$(echo "$(pwd)/$file" > "$current_operation")
		#suppression du fichier original
		rm "$file"
		#recréation du fichier original grâce au buffer
		cp -p "$buffer" "$file"
		#suppression du journal
		$(rm "$current_operation")
		#suppression du buffer
		rm "$buffer"
		#remarque, on pourrait se contenter de déplacer le buffer
		#plutôt qu'en faire une copie
		#mais en cas de coupure, on garde ainsi l'orginal
		echo -n "."
		
		#on relance une alnalyse sur le fichier (récursivement)
		one_more_analyse "$1"
	else
		#on a dépassé le nombre de tentatives autorisé
		nb_undefragmentable_files=$(($nb_undefragmentable_files + 1))
		fbmo=$(frag_by_mo "$file") && fbmo_sum_after=$(echo "scale=2 ; $fbmo_sum_after + $fbmo " | bc)
		echo -n " "
		echo -n $(count_fragments "$file")
	fi
}

analyse()
{
	file=$1
	#on compte le nombre de fragments
	nb_fragments=$(count_fragments "$file")
	if let "$nb_fragments>1"
	then
		#le fichier est fragmenté
		#mise à jour des statistiques
		nb_fragmented_files=$(($nb_fragmented_files + 1))
		fbmo=$(frag_by_mo "$file") && fbmo_sum_before=$(echo "scale=2 ; $fbmo_sum_before + $fbmo " | bc)
		nb_try=0
		echo -n "$(pwd)/$file" $(count_fragments "$file") ""
		#on essaye de le recoller
		assemble "$file"
		echo ""
	elif [ "$nb_fragments" = "-1" ]
	then
		#erreur générée par filefrag
		echo Erreur: filefrag can not analyse $(pwd)/$file
		nb_error_files=$(($nb_error_files + 1))
	fi
}



analyse_only()
{
	file=$1
	#on compte le nombre de fragments
	nb_fragments=$(count_fragments "$file")
	if let "$nb_fragments>1"
	then
		#le fichier est fragmenté
		#mise à jour des statistiques
		nb_fragmented_files=$(($nb_fragmented_files + 1))
		fbm=$(frag_by_mo "$file")
		sum_fbm=$(echo "scale=2 ; $sum_fbm + $fbm " | bc)
		
		
		#echo -n "$(pwd)/$file" $(count_fragments "$file") ""

	elif [ "$nb_fragments" = "-1" ]
	then
		#erreur générée par filefrag
		#echo Erreur: filefrag can not analyse $(pwd)/$file
		nb_error_files=$(($nb_error_files + 1))
	fi
}



########################################
########## fonction principale #########
########################################

#parcours récursif des répertoires
scan()
{

	rep=$1
	#on tente de se placer dans le répertoire
	cd "$rep"
	cd_ok=$?

	if [ "$cd_ok" = "0" ]
	then
		#on est dans le répertoire
		#on liste les fichiers
		for file in *
		do
			#on evite les liens symboliques, les périfériques etc.
			if test ! -h "$file"
			then
				#si c'est un fichier, on l'analyse
				#si c'est un répertoire, on l'explore
				if test -f "$file"
				then
					nb_files=$(($nb_files + 1))
					#lancement de l'analyse
					analyse "$file"
				else
					if test -d "$file"
					then
						#exploration récursive
						scan "$file"
					fi
				fi
			fi
		done
		#le répertoire a été analysé
		#on revient au répertoire parent
		cd ..
	else
		echo Erreur: ne peut ouvrir le répertoire $(pwd)/$rep
	fi
}

#lancement
scan "$rep_start"

#affichage des statistiques
echo "Analyse results for $rep_start"

echo -n $nb_files files
if let "$nb_files>0"
then
	echo -n ": "$(echo "scale=2 ; $fbmo_sum_after / $nb_files " | bc)" f/Mo"
	echo " (before: "$(echo "scale=2 ; $fbmo_sum_before / $nb_files " | bc)" f/Mo)"
else
	echo ""
fi


if let "$nb_error_files>0"
then
	echo $nb_error_files files have not been analysed
fi



echo -n $nb_fragmented_files files were fragmented
if let "$nb_fragmented_files>0"
then
	echo ": "$(echo "scale=2 ; $fbmo_sum_before / $nb_fragmented_files " | bc)" f/Mo"
else
	echo ""
fi


echo -n $nb_undefragmentable_files files are still fragmented
if let "$nb_undefragmentable_files>0"
then
	echo ": "$(echo "scale=2 ; $fbmo_sum_after / $nb_undefragmentable_files " | bc)" f/Mo"
else
	echo ""
fi

#echo $nb_undefragmentable_files files are still fragmented: $(echo "scale=2 ; $fbmo_sum_after / $nb_undefragmentable_files " | bc) f/Mo

exit 0

pnprog

Pour s'en servir, il faut recopier le code dans un fichier, le rendre exécutable et le lancer (dans une console) en mode administrateur en donnant en paramètre un dossier.

sudo ./n_defrag.sh ~/Documents/

Deux options sont disponibles:

-t: qui permet de spécifier le nombre d'essais pour chaque fichier. En effet, même après recopie, un fichier peut parfois être encore fragmenté. Le script recommence alors plusieurs fois jusqu'à défragmentation complète, ou jusqu'à ce que la limite -t soit atteinte. Par défaut, t vaut 10.
Utiliser -t 0 fait que le script analyse uniquement la fragmentation du dossier, et ne cherche pas à le défragmenter. Utile pour avoir une idée de la fragmentation du dossier sans prendre de risques.

sudo ./n_defrag.sh -t 20 ~/Documents/

-r: lance un mode de récupération. Si une précédente défragmentation a été interrompue, il est TRES FORTEMENT recommandé de s'en servir. Vous pourriez sinon perdre le fichier qui était en cours d'analyse.

sudo ./n_defrag.sh -r

Pendant l'analyse, vous verrez défiler les noms des fichiers fragmentés, et les tentatives successives pour les défragmenter:

/home/user/Document/monfichier1.doc 4 ... ok
/home/user/Document/monfichier2.doc 12 .......... 5

Le premier étant un fichier défragmenté avec succes, le second étant un fichier qui n'a pas pu être défragmenté. Le premier chiffre indique le nombre de fragments avant la tentative de fragmentation. Le second chiffre indique le nombre de fragment après, ok voulant dire un seul fragment. Il peut arriver que le second chiffre soit plus important que le premier, autrement dit, le fichier est alors plus fragmenté qu'au début, même si vous aviez beaucoup de place libre sur votre disque. Je ne sais pas à quoi cela est dû.

A la fin de la défragmentation, le programme affiche un petit résumé:

sudo ./n_defrag.sh ~/Documents/
[...]
Analyse results for ~/Documents/
30570 files: 0 f/Mo (before: .01 f/Mo)
2 files have not been analysed
43 files were fragmented: 9.60 f/Mo
28 files are still fragmented: 1.87 f/Mo

Les fichiers non analysés sont liés à un bug de filefrag qui plante en lisant les fichiers commençant par "-" comme par exemple "-monfichier.doc". Le créateur a dû se planter dans la manière de parser l'option "-s" du programme.

L'unité f/Mo signifie en quelque sorte "fragmentation par Mega Octet". Plus précisément, si un fichier de taille X Mo est fragmenté en N morceaux, alors la fragmentation par Mega Octet se calcule ainsi:

fragmentation par Mega Octet = (N-1)/X

Et par conséquent, un fichier non fragmenté a 0 f/Mo. Les futures versions de ce script devront permettre de fixer un seuil minimal de f/Mo au dessous duquel le script n'essaye pas de défragmenter le fichier. En effet, qu'un fichier de 700Mo (une image iso par exemple) soit fragmenté en 4 morceaux (0,004 f/Mo) n'est pas vraiment problématique, car le temps de déplacement de la tête de lecture du disque entre les morceaux sera certainement négligeable devant le temps de lecture complet des données. Donc inutile d'essayer de le défragmenter, opération lourde vu la taille du fichier, et qui peut tout simplement être impossible si il n'y a pas sur la partition 700Mo d'espace libre contigu. Par contre, on aura tout intérêt à défragmenter un fichier de 5Mo fragmenté en plus de 20 morceaux (3,8 f/Mo).

J'ai fait de mon mieux pour éviter les mauvaises surprises, il y a plein de vérifications partout. Cependant, je n'ai pas l'habitude du bash, et je suis sûr que beaucoup d'améliorations pourraient être faites, ou bien certaines parties du code ré-écrites proprement.

Je l'ai lancé sur mon répertoire racine et je n'ai pas eu de problèmes, mais je ne peux pas garantir à tout le monde que ce sera pareil, donc prudence. Prudence en particulier si vous voulez l'utiliser sur les données vitales du système (le noyau dans le dossier /boot par exemple). Le risque étant un plantage du système (si le système cherche à accéder à des fichiers fragmentés en cours de défragmentation) et dans le pire des cas, l'impossibilité de redémarrer le système (si le système a planté au mauvais moment). Utilisez le paramètre -t 0 dans un premier temps pour vérifier si ces données ont réellement besoin d'être défragmentées.

Je l'ai aussi testé sur des partions FAT et NTFS, et ça n'a pas posé pas de problèmes non plus. Donc apparemment ce script peut être utilisé pour défragmenter vos partitions Windows.

Les fichiers souvent fragmentés sont par exemple:
* Les fichiers téléchargés, quand plusieurs fichiers sont téléchargés en même temps depuis des logiciels qui ne réservent pas la place avant le début du téléchargement. Ça me semble être le cas d'Amule et Firefox entre autre (à confirmer).
* Les fichiers sur des partitions partagées avec Windows. Donc les clefs USB et disques externes.

Ferod

Salut

Il se trouve sur quels dépot le paquet de filefrag parce que je le trouve pas... J'ai pourtant les main, universe, restricted et multiverse d'activé. Je suis sous Ubtuntu v8.04.

sebastien@Daneel:520-Script$ sudo apt-get install filefrag
[sudo] password for sebastien: 
Lecture des listes de paquets... Fait
Construction de l'arbre des dépendances       
Lecture des informations d'état... Fait
E: Impossible de trouver le paquet filefrag

OK. Je viens de voir qu'il est installé par défaut...

Ferod

Bon maintenant que ça a tourné je peux faire quelques remarques ! 😛

Analyse results for Vidéos
4260 files
0 files have not been analysed
101 files were fragmented
28 files are still fragmented

Je l'ai lancé avec le nombre d'essais par défaut donc 10.

Mes suggestions :
-> remplacer "0 files have not been analysed" par "all files analysed !" ça fait moins mal à la tête... 🙂
-> créer un fichier log par défaut. Tout ce qui s'écrit sur le terminal ça peut être intéressant à voir surtout en cas de plantage.
-> rajouter le temps pris pour l'exécution.

Voilà ! 🙂

Brunod

Salut,
Un peu HS mais je dois dire que je suis très partisan d'un défrag Linux !
Cela me permettrait de faire le ménage sur mes disques partagés en Fat et ntfs sans plus devoir utiliser un pc Win pour cela.
Donc bravo pour l'initiative !
BD

sakul

oui mais là si j'ai bien compris, c'est un défrag pour ext3 et je doute que tu ai installé winwin sur du ext3 ....:rolleyes:

pnprog

Ferod a écritIl se trouve sur quels dépot le paquet de filefrag parce que je le trouve pas... J'ai pourtant les main, universe, restricted et multiverse d'activé. Je suis sous Ubtuntu v8.04.

OK. Je viens de voir qu'il est installé par défaut...

Autant pour moi, je croyais que c'était un paquet que j'avais installé. En fait c'est une commande.
J'ai commencé à écrire ce script avant ma migration à Hardy Heron (au cas ou je casse tout mon système en faisant les tests, que ça ne soit pas trop grâve !) et je ne me souvenais pas.

J'ai corrigé mon post, merci !

pnprog

Ferod a écritMes suggestions :
-> remplacer "0 files have not been analysed" par "all files analysed !" ça fait moins mal à la tête... 🙂

Ou même ne pas l'afficher du tout dans ce cas ! En fait, les fichiers commençants par "-" doivent être assez rares, une chance que j'en avais pour me rendre compte du bug de filefrag.
Il y a peut-être d'autres types fichiers qui le font planter, mais ça m'étonnerait.
Je pourrais écrire une rustine pour contourner le problème, par exemple renommer le fichier avant analyse, mais ça ne serait pas très propre. J'enverrai un email à l'auteur pour lui signaler plutôt.

Ferod a écrit-> créer un fichier log par défaut. Tout ce qui s'écrit sur le terminal ça peut être intéressant à voir surtout en cas de plantage.

Le log est une bonne idée. En fait, l'idéal serait de récupérer le nombre de fragments des fichiers non défragmentés. J'ai remarqué que certains de mes fichiers sont vraiment très fragmentés (fichiers audios de quelques Mo fragmentés en 20 ou 30 morceaux par exemple).
Certains résistent à mon script même si je passe le nombre d'essais à 100 ou plus ! le nombre de fragments oscille alors autour de la même valeur.
Mais pour l'instant j'ai beaucoup de mal avec bash, je ne sais pas comment faire une simple fonction qui retournerait un résultat (le nombre de fragments). C'est vraiment "bizarre" comme langage :-)

Ferod a écrit-> rajouter le temps pris pour l'exécution.

Oui, je commencerai par ça, ça ne doit pas être difficile.

Ferod a écritVoilà ! 🙂

Merci d'avoir testé, je suis un peu rassuré en voyant que ça ne cause pas de dégâts. On ne sait jamais :-)

pnprog

Brunod a écritUn peu HS mais je dois dire que je suis très partisan d'un défrag Linux !
Cela me permettrait de faire le ménage sur mes disques partagés en Fat et ntfs sans plus devoir utiliser un pc Win pour cela.

sakul a écritoui mais là si j'ai bien compris, c'est un défrag pour ext3 et je doute que tu ai installé winwin sur du ext3 ....roll

En fait je ne sais pas comment le FAT ou le NTFS est géré par Linux. Est-ce que ces deux formats de partition fragmentent aussi sous Linux ? auquel cas la fragmentation est inhérente à ces formats. Ou bien est-ce qu'ils ne formatent que sous Windows ? auquel cas la fragmentation vient de la manière dont l'OS travaille avec ces types de partitions.

Je n'y ai pas pensé, mais je peux me servir de ma clef USB pour tester avec le FAT ou le NTFS. Je le ferai demain.

NicoA380

Je testerai à l'occasion 🙂

pnprog

J'ai fait quelques modifications dans le script:

* Affichage du nombre de fragments avant et après.
* Gestion des partions FAT et NTFS.
* Un peu de nettoyage du code pour gagner en clarté.

Dans le détail:

La première version ne plantait pas pour les partions FAT ou NTFS, mais le script ne remarquais pas les fichiers fragmentés, donc il ne touchait pas à ces partitions.

J'ai rajouté une fonction qui retourne le nombre de fragment, ça permet de l'afficher et de voir clairement l'amélioration apportée par le script, ou pas. En effet, certains de mes fichiers sont absolument indéframentables, bien que mon disque possède plus de 20 Go de mémoire libre. Plusieurs passage successif du script n'arrange en rien la situation, je me demande pourquoi.

Avec cette fonction, le code est un peu plus clair. Mais surtout, je vais pouvoir m'en servir pour rendre le script plus "intelligent". Par exemple, faire une copie du fichier fragmenté, et si la copie est moins fragmentée, alors remplacer l'original par la copie, sinon, supprimer la copie et recommencer...

Voila voila...

figaro

A lire pour comprendre la fragmentation :

PS le nouveau format ext4 augmentera la taille réservée à la première écriture par rapport à ext3 et diminuera encore plus le risque de fragmentation sur les partitions Linux.

ogaby

Je n'ai pas tester ce programme mais j'ai déjà fait des defrags "à la main": en gros déplacé le fichier sur une autre partition et le remettre à l'emplacement d'origine.

Un jour, j'ai voulu défragmenter mon noyau.... et je ne pouvais plus démarrer. 🙁

Défragmentez uniquement vos documents mais pas le système.

pnprog

figaro a écritA lire pour comprendre la fragmentation :

Cela confirme ce que je pensais déjà. Ainsi, si un jour Windows supporte ext3 ou un autre format de partition libre, il le fera fragmenter...
Je m'en suis aussi rendu compte en utilisant le script sur une partition ntfs: tout les fichiers étaient défragmentés et répartis sur l'ensemble du disque avec de l'espace entre chacun. On peut le voir en utilisant le défragmenteur de Windows.
J'ai alors forcé Windows à le redéfragmenter à nouveau, et il a compacté tout les fichiers ensembles au début du disques, donc sans laisser d'espace entre. C'est une autre stratégie: rassembler tout les fichiers au même endroits, et au début du disques doit aussi diminuer le temps d'acces au fichiers, la tête de lecture du disque se déplace moins. Par contre, quand la taille de certains fichiers augmente, ils sont automatiquement fragmentés.

pnprog

ogaby a écritJe n'ai pas tester ce programme mais j'ai déjà fait des defrags "à la main": en gros déplacé le fichier sur une autre partition et le remettre à l'emplacement d'origine.
Un jour, j'ai voulu défragmenter mon noyau.... et je ne pouvais plus démarrer. 🙁
Défragmentez uniquement vos documents mais pas le système.

J'ai déjà lancé le script sur l'ensemble de mon disque (donc noyau inclus), sans rencontrer de problèmes.
Cela dit, le script ne déplace un fichier QUE s'il est fragmenté, ce qui n'était peut-être pas le cas du noyau. Ou est situé le noyau sur la partition ?

Autre chose, lors de défragmentations à la main avec cp, n'oubliez pas d'utiliser l'option -p qui préserve par défaut les attributs mode, ownership et timestamps.

cp -p fichier copie

ogaby

le noyau se trouve dans boot/
avec les fichiers initrd.img-2.6.22-14-generic et vmlinuz-2.6.22-14-generic

Si tu souhaites essayer, sois prudent. Fais une copie de ces 2 fichiers et modifie ton grub pour pouvoir les lancer en cas de pépins.

pnprog

J'ai regardé dans mon dossier /boot mais les fichiers qui s'y trouvent ne sont pas fragmentés. Impossible de dire s'ils l'étaient avant par contre. Et s'ils ne l'étaient pas, alors c'est normal que la défragmentation n'ait pas posée de problèmes, vu que le script n'aura fait que survoler ce dossier sans rien toucher.

Dans tout les cas, je vais rajouter un avertissement dans le mode d'emploi.
Si des casse-cous (ou plutôt des casse-systèmes) ayant leurs noyaux fragmentés veulent essayer...

pnprog

Mise à jour du script:

* Correction de petits bugs (qui étaient sans dangers) dans la lecture des résultats de filefrag.
* Mise à jour du rapport de fragmentation.

En particulier, j'ai imaginé une nouvelle mesure de la fragmentation que je trouve plus claire que les habituels pourcentages.
En effet, dire que sous Linux, la fragmentation ne dépasse pas 3% n'est pas très clair, que signifie ces 3% ?
* 3% des fichiers sont fragmentés ?
* Les fichiers fragmentés representent 3% du disque ? (je crois que c'est plutôt celle-ci)

Bref, le script calcule quelque chose que j'appele la fragmentation par Mega Octet: f/Mo
Si un fichier de taille X Mo est fragmenté en N morceaux, alors la fragmentation par Mega Octet se calcule ainsi:

fragmentation par Mega Octet = (N-1)/X

Analyse results for /var/
9797 files: 1.42 f/Mo (before: 2.12 f/Mo)
359 files were fragmented: 58.07 f/Mo
231 files are still fragmented: 60.56 f/Mo

Bref, on peut voir que la fragmentation a globalement baissé, mais les fichiers restant sont toujours aussi fragmentés.
J'ai eu l'impression que seuls les fichiers les plus lourds se retrouvaient plus fragmentés qu'avant, et que les fichiers légers étaient correctement défragmentés.
Si c'est effectivement le cas, alors c'est plutôt bon pour le système.
Il faudrait que le programme retienne la fragmentation moyenne des ces fichiers particulier avant défragmentation pour comparaison... peut-être dans une prochaine version.

En tout cas, il faudra attendre un peu avant de voir arriver d'autres options: je dois d'abords apprendre à me servir de getopt pour ne pas pondre une usine à gaz...

uboops

Hello,
Merci pour ce script utile, qui fonctionne très bien (sur ext3, le seul que j'ai testé pour le moment) .

code pour visualiser la fragmentation:
sudo bash n_defrag.sh -t 0 /home/hardy

code pour defragmenter:
sudo bash n_defrag.sh -t 20 /home/hardy

Analyse results for /home/hardy
3253 files: 0 f/Mo (before: .03 f/Mo)
4 files were fragmented: 30.33 f/Mo
0 files are still fragmented

J'ai fait ca aussi sur la racine / , c'est très long (1h05 mais pour 138047 files: .06 f/Mo (before: .43 f/Mo) ) , et il y a quelques erreurs, mais c'est normal sur la racine /.

Ferod

Hello

J'ai pas retesté encore la nouvelle version mais j'avais une petite idée d'amélioration. C'était de ne déplacer et de défragementer que les fichiers en dessous d'une certaine taille qu'on pourrait spécifier en argument dans la commande d'exécution du script.

Page suivante »