¿Se fsck mi sistema cuando reinicio?

... y cómo me entero?

Digamos que estoy a punto de reiniciar un servidor. Me gustaría minimizar el tiempo de inactividad, así que pensando en reiniciar el envoltorio en un alias que diga "espera amigo, vas a golpear un fsck en el arranque".

Siguiente pregunta ... ¿cuál es la mejor manera de decir "hagámoslo la próxima vez?" establecer la última fecha de verificación?

Sé que tune2fs puede establecer un montón de parámetros, pero ¿cómo podría obtenerlos?

Si todo lo que quiere hacer es evitar un fsck, agregar la opción -f para apagar debería ayudar con eso. apagado -F para forzar fsck.

tune2fs -l /dev/foo le dirá los fragmentos interesantes de información.

Aquí hay un comienzo para extraer justo lo que necesita:

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

Si la fecha "Siguiente verificación después" está en el pasado, habrá un fsck.

Si el estado del sistema de archivos no está limpio, habrá un fsck. (Esto también podría suceder si hay un problema con el sistema durante el reinicio / apagado que impide un desmontaje limpio)

Si el recuento de monturas ha alcanzado el recuento máximo de monturas, habrá un fsck.

Utilizando tune2fs -l /path/to/device:

• Si "Montar recuento" será mayor que "Montar recuentos máximos", utilice -cpara cambiar el máximo o -Cpara cambiar el recuento
• Si "Última comprobación" no es lo suficientemente reciente para el "Intervalo de comprobación", utilice -ipara cambiar el intervalo o -Tpara cambiar la última comprobación

la otra opción es que puede hacer que omita manualmente las comprobaciones de fsck en el arranque actualizando el sexto campo en su / etc / fstab:

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

Esto es similar a lo que la mayoría de los fstabs tendrán 1 significa que debe verificarse y es un sistema de archivos raíz, 2 significa que debe verificarse pero se realizará en paralelo con otros sistemas de archivos y 0 significa omitir la verificación

esto también es cierto sin importar el sistema de archivos

Si no quieres adivinar, haz esto:

táctil / arranque rápido

y se asegurará de evitar verificaciones lentas (o peor, una falla total si una verificación falla y el reinicio se detiene)

Utilizo el siguiente script perl para verificar cuándo ocurrirá el siguiente 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;

Lo tengo ejecutado en mi ~ / .bashrc, así que siempre sé cuándo se verificarán mis sistemas de archivos, aunque ahora uso ext4 que no sufre de tiempos de fsck extendidos, todavía es bueno saberlo.

La salida típica es algo como:

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

Regularmente uso tunefs para restablecer los recuentos de arranque y el tiempo antes de hacer un reinicio de medio día, para evitar fsck. La diferencia en el tiempo de arranque es impresionante. Afterwords los reinicio para permitir que el próximo arranque se ejecute.

Pensé en cómo obtener una lista de sistemas de archivos más cómodamente:

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;
  }
'

Supongo que podría hacerse con más elegancia, pero de todos modos aquí está. Si uno canaliza esto en xargs -r df -huno, también podría ver rápidamente qué tan grandes son los sistemas de archivos.

Tenga en cuenta que en el código anterior, el tiempo de "Próxima verificación" se compara con (AHORA + 120 segundos) suponiendo que el sistema tarde algún tiempo en volver a funcionar.

HTH

Aquí hay un script que comprueba sus sistemas de archivos para fsck ( fuente ):

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