Desfragmentando seu HD com linux

Acho que o único fs pro Linux que possui ferramenta nativa para isso é o XFS. Mesmo assim é uma boa dica.

Antonio eu agradeco a dica, porem... isso e meio que chuver no molhado... trocar 6 por meia-duzia...

E como instalar anti-virus no desktop, eu nao sei oque passa na cabeca de um grupo de pessoas que insiste que devemos instalar anti-virus no Linux mesmo que seja um desktop, sendo que o foco principal de um anti-virus no Linux e para o uso em servidores, ja que muitos usuarios do windows vao logar no site ou baixar o e-mail para o computador deles, sendo assim o anti-virus vai proteger o usuario do windows que logar no site que o servidor estara hospedando... agora em um desktop, oque o anti-virus vai fazer???? tirar virus do windows que "podem infectar o Linux?", pior ainda "tirar os virus que funcionam no Linux?"...

Quanto a desfragmentacao... quem vai desfragmentar um ext3 ? sendo que o proprio nao fragmenta os arquivos, particoes em fat32 precisam ser desfragmentadas porque existe um limite de 2Gb de armazenamento nos blocos do fat32, o NTFS precisar ser desfragmentado porque o limite do bloco dele e de 4Gb, ja o ext3 e os posteriores a ele tem uma distribuicao dinamica de blocos, sendo assim ele nao tem um limite de tamanho de arquivo para ser armazenado.

Quer fazer um teste? pega um dvd-dual layer, aqueles de 9Gb copia ele como uma imagem de iso usando um dos ripadores do Linux, essa imagem vai ser por volta de 5GB a 9GB dependendo do filme, depois disso tenta copiar o arquivo para o windows em qualquer tipo de particao NTFS ou FAT32, voce vai ver que vai dar erro e se voce com muita sorte conseguir copiar vai ser somente uma vez, porque quando voce tentar mandar o arquivo devolta para o outro HD ou particao, vai dar o bendito erro... feito isso pega esse mesmo arquivo que voce copiou para o FAT32/NTFS e copie ele livremente entre suas particoes Linux, ele vai e vem em qualquer particao sem auteracao, pode ate rodar um md5sum encima do arquivo que vai ser o numero certinho, porque o LINUX NAO FRAGMENTA O ARQUIVO.

Na minha opiniao esse programa e FAKE, agora se alguem quiser discordar, seja livre para fazer isso.
:)

Existe a possibilidade de alguma fragmentação no Linux, porém jamais como sucede no Windows.
Este último trabalha fragmentando constantemente, pois procura gravar em qualquer "vaga" que encontrar, procurando com isso otimizar o acionamento das cabeças do HD.
No entanto, se prestarmos atenção, isso somente será conseguido nas primeiras vezes, pois nas subsequentes, essas mesmas cabeças terão de se mover para lá e para cá - constantemente - para poder ler os mesmos dados.
Linux utiliza a técnica de "commitment", ou seja, envia um bloco inteiro para uma "vaga" onde o caiba. Quando apagamos um bloco, nesse momento - e somente então - aparece uma vaga, que no windows seria candidata a receber um fragmento.
Mas Linux não grava onde não caiba o bloco inteiro, e por isso a fragmentação é menor, melhor dizendo, podem existir "buracos" (e não fragmentos propriamente ditos) entre os blocos, mas isso não interferirá no desempenho do sistema.

PS. Um lembrete: Alguns arquivos são compostos de mais de um bloco, portanto esses blocos poderão estar separados (e geralmente o estarão).

desculpe a minha desconfianca mais se tem alguem fera em perl diz ai oque esse programa faz?

Pelo que eu consegui entender ele faz uma vasculhada no diretorio, seleciona os arquivos de acordo com o tamanho deles e cria uma lista desses arquivos, depois ele compara a quantidade de arquivos com o tamanho e faz uma porcentagem de arquivos que suspostamente estao fragmentados, pede para o usuario entrar um numero que 1 a 100 que segundo o autor e a porcentagem da fragmentacao, depois ele comeca a copiar os arquivos de lugar A para Lugar B, depois apaga o arquivo A copia de B para A e apaga o B e apaga o arquivo da lista ate essa lista chegar a 0... e ai? oque ele fez de mais???


#!/usr/bin/perl
# defragfs.pl -- Measurement and Report and Defrag fs/file fragmentation
# CanHao Xu <xucanhao@gmail.com>, 2007

($DIR, $FORCE) = @ARGV;

if (($DIR eq "") || ($DIR eq "-f")) {
die "Usage: defragfs.pl DIRECTORY [-f], -f means force defragmentation";
}

if (!(-e $DIR) || !(-d $DIR)) {
die "You must specify a correct directory name!";
}

#number of files
my $files = 0;
#number of fragment before defrag
my $fragments_before = 0;
#number of fragmented files before defrag
my $fragfiles_before = 0;
#number of fragment after defrag
my $fragments_after = 0;
#number of fragmented files after defrag
my $fragfiles_after = 0;
my $TMP_filefrag_before_1 = "/tmp/frags-result-before-tmp";
my $TMP_filefrag_before_2 = "/tmp/frags-result-before";
my $TMP_filefrag_after_1 = "/tmp/frags-result-after-tmp";
my $TMP_filefrag_after_2 = "/tmp/frags-result-after";
my $TMP_defrag_filelist_1 = "/tmp/defrag-filelist-tmp";
my $TMP_defrag_filelist_2 = "/tmp/defrag-filelist";
#max "File Fragmentation Rate" used to determine whether worth defrag.
my $max_fragrate = 20;
#max "Avg File Fragments" used to determine whether worth defrag.
my $max_avgfrags = 60;
#default defragmentation ratio in percentage
my $default_defrag_ratio;
#display how much files in report
my $max_display_num = 10;
#which files to be defrag, determined after user input the ratio
my $total_defrag_files = 0;
#sub routine measurefs measure before/after
my $measure_ba = "before";

#search fs for all file
system("rm -f $TMP_filefrag_before_1");
system("rm -f $TMP_filefrag_before_1");
system("rm -f $TMP_filefrag_after_1");
system("rm -f $TMP_filefrag_after_2");
system("rm -f $TMP_defrag_filelist_1");
system("rm -f $TMP_defrag_filelist_2");

sub measurefs {
open (FILES, "find \"" . $DIR . "\" -xdev -type f |");
while (defined (my $file = <FILES>)) {
$file =~ s/!/\\!/g;
$file =~ s/#/\\#/g;
$file =~ s/&/\\&/g;
$file =~ s/>/\\>/g;
$file =~ s/</\\</g;
$file =~ s/\$/\\\$/g;
$file =~ s/\(/\\\(/g;
$file =~ s/\)/\\\)/g;
$file =~ s/\|/\\\|/g;
$file =~ s/'/\\'/g;
$file =~ s/ /\\ /g;
open (FRAG, "filefrag $file |");
my $res = <FRAG>;
if ($res =~ m/.*:\s+(\d+) extents? found/) {
if ($_[0] eq "before") {
system("echo \"$res\" >> $TMP_filefrag_before_1");
my $fragment = $1;
$fragments_before+=$fragment;
if ($fragment > 1) {
$fragfiles_before++;
}
$files++;
}
else {
system("echo \"$res\" >> $TMP_filefrag_after_1");
my $fragment = $1;
$fragments_after+=$fragment;
if ($fragment > 1) {
$fragfiles_after++;
}
$files++;
}
}
close (FRAG);
}
close (FILES);
}
print ("defragfs 0.8, Released under GPL by xucanhao\@gmail.com\n");
print ("Analysis in progress...\n");
print ("NOTE: if the directory you specified contains too much files(e.g. tens of thousands), it could take you several minutes on analysis, you may disturb it by CTRL+C at anytime. And BTW: the program is CURRENTLY not accurate on Reiser4 due to its default tailing policy(you may see a high fragment rate before and even after)\n");
$measure_ba = "before";
&measurefs($measure_ba);
if ($files eq 0) {
print ("The selected directory contains no file!\n");
exit;
}
system("sort $TMP_filefrag_before_1 -g -t : -k 2 -r | sed \"/^\$/d\" > $TMP_filefrag_before_2");

print ("Statistics for $DIR\n");
print ("Total Files:\t\t\t" . $files . "\n");
print ("Fragmented Files:\t\t" . $fragfiles_before . "\n");
print ("File Fragmentation Rate:\t" . $fragfiles_before / $files * 100 . "%\n");
print ("Avg File Fragments(1 is best):\t" . $fragments_before / $files . "\n");
print ("Most Fragmented Files(for details see $TMP_filefrag_before_2):\n");
system("head $TMP_filefrag_before_2 -n $max_display_num");

$default_defrag_ratio = int($fragfiles_before / $files * 100);
if ($default_defrag_ratio > 50) {
$default_defrag_ratio = 50;
}
if ((($fragfiles_before / $files * 100) > $max_fragrate) || (($fragments_before / $files) > $max_avgfrags) || ($FORCE eq "-f")) {
print ("You need a defragmentation!\n");
}
else {
print ("You do not need a defragmentation!\n");
exit;
}

defrag:
print ("Please specify the percentage of files should be defrag(1-100, default $default_defrag_ratio):");
$defrag_ratio = <STDIN>;
chop($defrag_ratio);
if (!($defrag_ratio eq "") && (($defrag_ratio < 1) || ($defrag_ratio > 100))) {
print ("Error percentage numbers, please re-enter!\n");
goto defrag;
}
else {
$default_defrag_ratio = ($defrag_ratio || $default_defrag_ratio);
}
$total_defrag_files = int($default_defrag_ratio * $files / 100);
print ("Preparing defragmentation, please wait...");

print ("\nFiles to be defragmented:" . $total_defrag_files . "\n");
if ($total_defrag_files eq 0) {
exit;
}
system("head $TMP_filefrag_before_2 -n $total_defrag_files > $TMP_defrag_filelist_1");

open TMPFRAGLIST, "$TMP_defrag_filelist_1";
while (<TMPFRAGLIST>) {
m/(.*):\s+(\d+) extents? found/;
my $filename = $1;
system("echo \"$1\" >> $TMP_defrag_filelist_2");
}

open GETSIZE, "$TMP_defrag_filelist_2";
my $max = 0;
while (<GETSIZE>) {
s/(.*)\n/$1/;
$size = -s "$_";
if ($size > $max) {
$max = $size;
}
}

print ("You need AT LEAST " . $max . " Bytes temporarily used for defragmentation(at the directory where you specified), continue(Y/N)?[N] ");
$confirm = <STDIN>;
chop($confirm);
if (($confirm eq "y") || ($confirm eq "Y")) {
print ("OK, please drink a cup of tea and wait...\n");

open DEFRAG, "$TMP_defrag_filelist_2";
while (<DEFRAG>) {
s/(.*)\n/$1/;
$from = $_;
s/(.*)/$1.fragstmp/;
$to = $_;
system("cp -af \"$from\" \"$to\" 2>/dev/null");
system("rm -f \"$from\"");

#NOTE: CTIME will change here!!
system("cp -af \"$to\" \"$from\" 2>/dev/null");
system("rm -f \"$to\"");
print "#";
}

system("sync");
print ("Done!\n");
print ("Now lets see the results...\n");

$files = 0;
$measure_ba = "after";
&measurefs($measure_ba);
system("sort $TMP_filefrag_after_1 -g -t : -k 2 -r | sed \"/^\$/d\" > $TMP_filefrag_after_2");

print ("Statistics for $DIR\n");
print ("Total Files:\t\t\t" . $files . "\n");
print ("Fragmented Files:\t\t" . $fragfiles_after . "\n");
print ("File Fragmentation Rate:\t" . $fragfiles_after / $files * 100 . "%\n");
print ("Avg File Fragments(1 is best):\t" . $fragments_after / $files . "\n");
print ("Most Fragmented Files(for details see $TMP_filefrag_after_2):\n");
system("head $TMP_filefrag_after_2 -n $max_display_num");
}
else {
exit;
}

Ei, colega, pessoas que entendem de Linux não recomendam instalar o sistema em ext nos netbooks com disco SSD, pois dizem que a vida útil diminui. Aí recomendam a instalação em fat32. Esse programa resolveria o problema da fragmentação em instalação Linux com sistema fat32?

este programa fuleiro tem seus meritos, mas basicamente o que ele faz ja rolou ha seculos na Linux GAzette. Pra desfragmentar um sistema é so recopiar os arquivos dele... DUHHH

Pessoal, segue minha experiência com o software citado, apenas para conhecimento, caso alguém esteja em dúvida ou venha a ter problemas também..

Baixei o programa citado e rodei no meu sistema (CentOS 5.5 64bits) para testar, pois estava meio lento e o mesmo levou um bom tempo rodando até que passou a dar um erro constante na console a respeito do arquivo /lib64/libc.so.6 e eu não conseguia fazer mais nada.. então bootei o sistema e o mesmo não subia mais.. tive que bootar com o CD de instalação do CentOS e através da opção F5 - Rescue ele montou meu sistema como sysimage e eu tive acesso aos arquivos... aí tive que copiar o arquivo mencionado (que na verdade é um link simbólico para outro arquivo - libc-2.5.so) a partir do CD, alterei as permissões dos mesmos, reiniciei e meu sistema voltou a funcionar. Portanto não sei o que houve, se foi só coincidência, mas o mesmo não parece ser muito confiável, apesar de que eu notei uma boa melhora na performance depois que eu o recuperei..

Abçs.

esse programa acabou sumindo com alguns arquivos aqui ¬¬