Il mio sistema funzionerà quando riavvio?

... e come lo scopro?

Di 'che sto per riavviare un server. Vorrei ridurre al minimo i tempi di inattività, quindi pensando di avvolgere il riavvio in un alias che dice "aspetta amico, stai per colpire un fsck all'avvio".

Prossima domanda .. qual è il modo migliore per dire "facciamolo la prossima volta?" impostare la data dell'ultimo controllo?

So che tune2fs può impostare un sacco di parametri, ma come potrei ottenerli?

Se tutto ciò che vuoi fare è evitare un fsck, aggiungere l'opzione -f allo spegnimento dovrebbe essere di aiuto. spegnimento -F per forzare fsck.

tune2fs -l /dev/foo ti dirà le informazioni interessanti.

Ecco un inizio per estrarre proprio quello che ti serve:

mount -l -t ext3,ext2 | cut -d' ' -f1 | xargs -n1 tune2fs -l | egrep -i 'state|mount|check'

Se la data "Controllo successivo dopo" è passata, ci sarà un fsck.

Se lo stato del filesystem non è pulito, ci sarà un fsck. (questo potrebbe accadere anche se si verifica un problema con il sistema durante il riavvio / arresto che impedisce uno smontaggio pulito)

Se il conteggio dei mount ha raggiunto il numero massimo di mount, ci sarà un fsck.

Utilizzando tune2fs -l /path/to/device:

• Se "Numero di montaggi" sarà maggiore di "Numero di montaggi massimi", utilizzare -cper modificare il numero massimo o -Cper modificare il conteggio
• Se "Ultimo controllo" non è abbastanza recente per "Verifica intervallo", utilizzare -iper modificare l'intervallo o -Tper modificare l'ultimo controllo

l'altra opzione è che puoi farlo saltare manualmente i controlli di fsck all'avvio aggiornando il sesto campo nel tuo / etc / fstab:

/dev/sda2  /  ext3  defaults,errors=remount-ro 0       1

Questo è simile a quello che la maggior parte di fstabs avrà 1 significa che dovrebbe essere controllato ed è un file system di root, 2 significa che dovrebbe essere controllato ma sarà fatto in parallelo con altri file system e 0 significa saltare il controllo

questo vale anche indipendentemente dal file system

Se non vuoi indovinare, fai come segue:

toccare / avvio rapido

e sarai certo di evitare i controlli lenti (o peggio - un fallimento totale se un controllo fallisce e il riavvio si interrompe)

Uso il seguente script perl per verificare quando si verificherà il prossimo fsck:

#!/usr/bin/perl -w

use strict;

my $mountcount = 0;
my $maxmount = 0;
my $dev;
my $mountpoint;
my $fstype;
my $debug = 0;

my $cmd = "mount";

open MOUNT, sprintf ( "%s |", $cmd ) or die sprintf ( "ERROR: Cannot execute %s - %s\n", $cmd, $! );
while ( <MOUNT> ) {
    chomp;
    ( $dev, undef, $mountpoint, undef, $fstype, undef ) = split;
    printf "Found device %s\n", $dev if ( $debug > 0 );

    if ( $fstype =~ /^ext/i ) {
        $cmd = sprintf "dumpe2fs -h %s 2>&1", $dev;
        open DUMPE2FS, sprintf ( "%s |", $cmd ) or die sprintf ( "ERROR: Unable to execute %s - %s\n", $cmd, $! );
        while ( <DUMPE2FS> ) {
            chomp;
            if ( /^Mount count:/ ) {
                ( undef, $mountcount ) = split /:/;
                $mountcount =~ s/\s*//g;
                printf "Mount count = %s\n", $mountcount if ( $debug > 0 );
            }
            if ( /^Maximum mount count:/ ) {
                ( undef, $maxmount ) = split /:/;
                $maxmount =~ s/\s*//g;
                printf "Maximum mount count = %s\n", $maxmount if ( $debug > 0 );
            }
        }
        close DUMPE2FS;

        printf "Filesystem %s, mounted on %s will be checked in %s mounts\n", $dev, $mountpoint, $maxmount - $mountcount;
    }
}
close MOUNT;

L'ho eseguito nel mio ~ / .bashrc, quindi so sempre quando verrà controllato il mio filesystem, anche se uso ext4 ora che non soffre di tempi fsck estesi, è comunque bello saperlo.

L'output tipico è qualcosa del tipo:

Filesystem /dev/sda1, mounted on / will be checked in 5 mounts
user@localhost ~ $

Uso regolarmente tunefs per ripristinare il conteggio e il tempo di avvio prima di eseguire un riavvio a metà giornata, per prevenire fsck. La differenza nel tempo di avvio è sorprendente. Dopo le password li ho ripristinati per consentire l'avvio successivo a fsck.

Ho pensato a come ottenere un elenco di file system più comodamente:

for D in $(mount -l -t ext3,ext2 | cut -d' ' -f1 ) ; do \
echo --- $D; tune2fs -l $D | egrep -i 'mount (count|time)|check' ; done \
| awk '
  /^--- / { mydev=$2; checked=0 }
  /^Mount count:/ { mycnt=$3 }
  /^Maximum mount count:/ { if (mycnt >= $3) checked=1 }
  /^Next check after:/ {
    cmd=("date +%s -d\"" $4 FS $5 FS $6 FS $7 FS $8"\"");
    cmd | getline mydate; close(cmd);
    if ((mydate <= (systime()+120)) || (checked == 1)) print mydev;
  }
'

Immagino che potrebbe essere fatto in modo più elegante ma comunque eccolo qui. Se uno convoglia questo in xargs -r df -huno potrebbe anche vedere rapidamente quanto sono grandi i filesystem.

Si noti che nel codice sopra il tempo di "Controllo successivo" viene confrontato con (ORA + 120 secondi) supponendo che ci vorrà del tempo prima che il sistema si alzi di nuovo.

HTH

Ecco uno script che controlla il tuo filesystem per fsck ( sorgente ):

for x in $(df -t ext4 -t ext3 -t ext2 | tr -s ' ' | cut -d " " -f1 | grep -v "^$" | tail -n +2); do mmc=$(tune2fs -l $x | grep 'mount count' | tr -s ' ' | cut -d ' ' -f4) ; mc=$(tune2fs -l $x | grep 'Mount count' | tr -s ' ' | cut -d ' ' -f3) ; if [ `expr $mmc - $mc` -le 0 ] ; then fsck="0" ; else fsck="1"; fi ; CT=`date +%s` ; LCT=`date -d "\`tune2fs -l $x | grep "Last checked" | tr -s ' '| cut -d" " -f3-\`" +%s` ; CI=`tune2fs -l $x | grep "Check interval"| tr -s ' '| cut -d" " -f3` ; if [ `let $CT-$LCT` -gt `let $CI*3600*24` ] && [ $CI -gt 0 ] || [ $fsck -eq 1 ];  then echo "There will be forced fsck for $x"; else echo "There will be no fsck for $x" ; fi ; done
# Alternative script from friend with sed
# mount -t ext2,ext3,ext4|while read i j; do tune2fs -l $i|sed -n '/[Mm]ount count/{s/.*: *//;p}'|(read c; read m; [ $m -gt 0 -a $m -le $c ] && echofsck,count,$i); c="$(tune2fs -l $i|sed -n '/Next check/{s/.*r: *//;p}')"; [ -z "$c" ] || ([ `date +%s` -ge `date -d"$c" +%s` ] && echo fsck,time,$i); done