recepies/smart/smart-test-relocate.pl

#!/usr/bin/perl

use warnings;
use strict;

my $drive = $ARGV[0] || die "usage: $0 /dev/sda\n";
my $delay = 15;
my $rewrite_sectors = 16;

my $test_started = 0;

sub write_sector {
        my $s = shift;
        system "hdparm --write-sector $s --yes-i-know-what-i-am-doing $drive";
}

sub smart_test {
        my $sector = shift;
        my $cmd = "smartctl -t select,$sector-max $drive";
        warn "$cmd\n";
        system $cmd;
        $test_started = 1;
}

sub smart {
        my $cmd = "smartctl -l selective $drive";
        warn "$cmd\n";
        open(my $fh, '-|', $cmd);
        while(<$fh>) {
                chomp;
                print "# $_\n";
                if ( m/Completed_read_failure.*\((\d+)-\d+\)/ ) {
                        my $sector = $1;
                        print "rewrite sector: $sector\n";
                        foreach my $s ( $sector .. $sector + $rewrite_sectors ) {
                                write_sector $s;
                        }
                        smart_test $sector;
                        return 1;
                } elsif ( m/Self_test_in_progress/ ) {
                        $test_started = 1;
                        return 1;
                } elsif ( m/Not_testing/ ) {
                        if ( $test_started ) {
                                smart_last_error();
                                return 1 if $test_started;
                        }
                        smart_test 0; # first-time invocation
                }
        }
        return 0;
}

sub smart_last_error {
        my $cmd = "smartctl -l selftest $drive";
        warn "$cmd\n";
        open(my $fh, '-|', $cmd);
        while(<$fh>) {
                chomp;
                print "# $_\n";
                if (/^#\s+1.+Completed: read failure\s+\S+\s+\S+\s+(\d+)/) {
                        write_sector $1;
                        smart_test $1;
                        return 1;
                }
        }
}

smart_last_error || smart_test 0;

while ( smart ) {
        warn "sleep $delay s", ( $test_started ? " smart test running..." : "idle" ), "\n";
        sleep $delay;
}
1	dpavlin	287	#!/usr/bin/perl
2
3			use warnings;
4			use strict;
5
6			my $drive = $ARGV[0] \|\| die "usage: $0 /dev/sda\n";
7			my $delay = 15;
8			my $rewrite_sectors = 16;
9
10			my $test_started = 0;
11
12	dpavlin	304	sub write_sector {
13			my $s = shift;
14			system "hdparm --write-sector $s --yes-i-know-what-i-am-doing $drive";
15			}
16
17	dpavlin	287	sub smart_test {
18			my $sector = shift;
19			my $cmd = "smartctl -t select,$sector-max $drive";
20			warn "$cmd\n";
21			system $cmd;
22			$test_started = 1;
23			}
24
25			sub smart {
26	dpavlin	288	my $cmd = "smartctl -l selective $drive";
27			warn "$cmd\n";
28			open(my $fh, '-\|', $cmd);
29	dpavlin	287	while(<$fh>) {
30			chomp;
31			print "# $_\n";
32			if ( m/Completed_read_failure.*\((\d+)-\d+\)/ ) {
33			my $sector = $1;
34			print "rewrite sector: $sector\n";
35			foreach my $s ( $sector .. $sector + $rewrite_sectors ) {
36	dpavlin	304	write_sector $s;
37	dpavlin	287	}
38			smart_test $sector;
39			return 1;
40			} elsif ( m/Self_test_in_progress/ ) {
41	dpavlin	288	$test_started = 1;
42	dpavlin	287	return 1;
43			} elsif ( m/Not_testing/ ) {
44	dpavlin	304	if ( $test_started ) {
45			smart_last_error();
46			return 1 if $test_started;
47			}
48	dpavlin	287	smart_test 0; # first-time invocation
49			}
50			}
51			return 0;
52			}
53
54	dpavlin	304	sub smart_last_error {
55			my $cmd = "smartctl -l selftest $drive";
56			warn "$cmd\n";
57			open(my $fh, '-\|', $cmd);
58			while(<$fh>) {
59			chomp;
60			print "# $_\n";
61			if (/^#\s+1.+Completed: read failure\s+\S+\s+\S+\s+(\d+)/) {
62			write_sector $1;
63			smart_test $1;
64	dpavlin	305	return 1;
65	dpavlin	304	}
66			}
67			}
68
69	dpavlin	305	smart_last_error \|\| smart_test 0;
70	dpavlin	304
71	dpavlin	287	while ( smart ) {
72	dpavlin	288	warn "sleep $delay s", ( $test_started ? " smart test running..." : "idle" ), "\n";
73	dpavlin	287	sleep $delay;
74			}