浅谈Linux磁盘修复e2fsck命令

linux下磁盘检查修复命令e2fsck

-a: 检查 partition，如发现问题会自动修复。

-b: 设定 superblock 位置。

-B size: 指定 size 作为区块大小。

-c: 检查 partition 是否有坏轨。

-C file: 将检查结果储存到 file。

-d: 输出 e2fsck debug 结果。

-f: e2fsck 预设只会对错误的档案系统检查，加上 -f 是强制检查。

-F: 在检查前将硬盘的 buffer cache 清空，避免发生错误。

-l list: 记录了坏轨区块加入 list 中。

-d : 打印 e2fsck 的 debug 结果。

-f : 强制检查。

-n: 以 (read-only) 开启档案系统

-p: 关闭互动模式，如有问题自动修复，等同 -a。

-v: 显示详细报告。

-y: 启用使用者互动模式。

使用例子

检查 /dev/mapper/VolGroup00-LogVol02 是否有问题，如发现问题便自动修复:

e2fsck -a /dev/mapper/VolGroup00-LogVol02

执行 e2fsck 或 fsck 前请先 umount partition，否则有机会令档案系统毁损。

分区忙的情况，需要将所有涉及该分区的进程杀掉，有个快速的方法是执行 fuser -k /home 。

如果需要对根目录 (/) 进行检查及修复，便需要进入 singal user mode 执行。

最后别忘了将分区mount上。

#!/usr/bin/env python2.7

# coding: utf-8

"""

It only handle the following two situations:

1. There is only one primary partiion in the disk with a format of ext2/3/4 or xfs;

2. The disk is raw with a file system whose format is ext2/3/4 or xfs.

"""

import struct

import array

import fcntl

import time

import sys

import os

import glob

import logging

import commands

import argparse

import atexit

import re

BLKSSZGET = 0x1268

BLKGETSIZE = 0x1260

BLKRRPART = 0x125f

BLKGETSIZE64 = 0x80041272

NORMAL_DEVICE_NAME = r"\/dev\/\D+$"

SPECITIAL_DEVICE_NAME = r"\/dev\/\D+\d$"

logger = None

def read_ub(data):

"""read little-endian unsigned byte"""

return struct.unpack('B', data[0])[0]

def read_us(data):

"""read little-endian unsigned short(2 bytes)"""

return struct.unpack('<H', data[0:2])[0]

def read_ui(data):

"""read little-endian unsigned int(4 bytes)"""

return struct.unpack('<I', data[0:4])[0]

def read_ul(data):

"""read little-endian unsigned long(8 bytes)"""

return struct.unpack('<Q', data[0:8])[0]

def init_log():

"""初始化日志"""

global logger

log_file = 'devresize.log'

fmt_file = '%(asctime)s - [%(levelname)-5.5s]- %(filename)s:%(lineno)s - %(message)s'

fmt_stream = '[%(levelname)s] - %(message)s'

logger = logging.getLogger('devresize')

logger.setLevel(logging.DEBUG)

file_handler = logging.FileHandler(log_file)

file_handler.setLevel(logging.DEBUG)

file_handler.setFormatter(logging.Formatter(fmt_file))

logger.addHandler(file_handler)

stream_handler = logging.StreamHandler()

stream_handler.setLevel(logging.INFO)

stream_handler.setFormatter(logging.Formatter(fmt_stream))

logger.addHandler(stream_handler)

class PartitionEntry(object):

"""表示一个磁盘分区"""

PartitionTypes = {

0x05: "Microsoft Extended",

0x83: "Linux",

0x85: "Linux Extended"

}

def __init__(self, data):

self.data = data

self.boot_sig = data[0]

self.start_head, self.start_sector, self.start_cylinder = (

PartitionEntry.get_hsc(data[1:1 + 3]))

self.partition_type = read_ub(data[4])

self.end_head, self.end_sector, self.end_cylinder = (

PartitionEntry.get_hsc(data[5:5 + 3]))

self.start_lba = read_ui(data[8:8 + 4])

self.sector_num = read_ui(data[12:12 + 4])

self.partition_type_name = PartitionEntry.PartitionTypes.get(self.partition_type, "other")

@staticmethod

def get_hsc(data):

"""获取(head, sector, cylindar)"""

h, s, c = struct.unpack('BBB', data[0:3])

c = (c | ((s & 0xC0) << 2))

s = (s & 0x3F)

return h, s, c

@staticmethod

def cal_hsc(sector, hh, ss):

"""计算(head, sector, cylindar)"""

s = sector % ss + 1

sector /= ss

h = sector % hh

sector /= hh

c = sector & 0xFF

s |= (sector >> 2) & 0xC0

return h, s, c

def vaild_type(self):

"""校验分区类型是否在可处理的名单里"""

return self.partition_type in self.PartitionTypes

def isprimary(self):

"""是否为主分区"""

return self.partition_type == 0x83

def __str__(self):

if not self.vaild_type():

logger.info("%x" % self.partition_type)

return "This isn't a Linux Partition!"

return """

Start h,s,c: %u %u %u

End h,s,c: %u %u %u

Partition Type Name:%s

Start LBA: %u

Sector Number: %u

""" % (self.start_head, self.start_sector, self.start_cylinder,

self.end_head, self.end_sector, self.end_cylinder,

self.partition_type_name, self.start_lba, self.sector_num)

class MBR(object):

def __init__(self, data):

self.data = data

self.boot_code = data[:446]

self.mbr_sig = data[510:512]

if self.check_mbr_sig(): # 如果存在分区

self.partitions = ([PartitionEntry(data[446 + 16 * i:446 + 16 * (i + 1)])

for i in range(0, 4)])

else: # 否则为裸盘文件系统

self.partitions = None

if self.partitions is not None:

self.vaild_part_num = len(filter(lambda x: x.vaild_type(), self.partitions))

else:

self.vaild_part_num = 0

self.device_heads = 0

self.device_sectors = 0

self.cal_device_hs()

def cal_device_hs(self):

"""计算设备的heads和sectors"""

if self.partitions is not None and self.vaild_part_num == 1:

self.device_heads = self.partitions[0].end_head + 1

self.device_sectors = self.partitions[0].end_sector & 0x3F

def check_mbr_sig(self):

"""检查MBR签名"""

mbr_sig = read_us(self.mbr_sig)

if mbr_sig == 0xAA55:

return True

else:

return False

def get_device_size(fd):

"""获取块设备大小"""

buf = array.array('c', [chr(0)] * 8)

fcntl.ioctl(fd, BLKSSZGET, buf, True)

logical_sector_size = read_ul(buf)

buf = array.array('c', [chr(0)] * 8)

try:

fcntl.ioctl(fd, BLKGETSIZE, buf, True)

device_size = read_ul(buf) * 512

except IOError:

fcntl.ioctl(fd, BLKGETSIZE64, buf, True)

device_size = read_ul(buf)

device_sector_number = device_size / logical_sector_size

logger.debug(

"""device_size:%d

device_sector_number:%d

logical_sector_size:%d""" % (device_size, device_sector_number, logical_sector_size))

return device_size, device_sector_number, logical_sector_size

def is_ext_fs(fstype):

return 'ext' in fstype

def check_fs_block_size(part, fstype, mount_dir):

"""获取文件系统块大小和块数"""

if is_ext_fs(fstype):

block_size = commands.getoutput("tune2fs -l %s | grep 'Block size' | awk '{print $3}'" % part)

# block_count = commands.getoutput("tune2fs -l %s | grep 'Block count' | awk '{print $3}'" % part)

else:

mount_fs(part, mount_dir)

output = commands.getoutput("xfs_info %s | grep '^data' | awk -F '[= ,]+' '{print $3, $5}'" % part).split()

umount_fs(part)

block_size = output[0]

# block_count = output[1]

if not block_size:

logger.error("Check filesystem %s block size error, cannot get block size." % part)

sys.exit(1)

if int(block_size) != 4096:

logger.error("Only can process filesystem with block size 4KB (actual block size is %s bytes)" % block_size)

sys.exit(1)

return mount_dir

def backup_mbr(part, data):

"""备份MBR元数据"""

bak_name = '/tmp/MBR_%s_%s_bak' % (os.path.basename(part), time.strftime("%Y-%m-%d_%X", time.localtime()))

bak_file = open(bak_name, 'w')

bak_file.write(data)

bak_file.close()

logger.info("Backup MBR to %s" % bak_name)

return bak_name

def cal_new_part(part_data, mbr, start_lab, new_end):

"""计算新的MBR分区"""

device_heads, device_sectors = mbr.device_heads, mbr.device_sectors

new_partition_sector_num = new_end - start_lab + 1

begin_h, begin_s, begin_c = PartitionEntry.cal_hsc(start_lab, device_heads, device_sectors)

end_h, end_s, end_c = PartitionEntry.cal_hsc(new_end, device_heads, device_sectors)

new_part_data = list(part_data[:])

new_part_data[1:1 + 3] = list(struct.pack('BBB', begin_h, begin_s, begin_c))

new_part_data[5:5 + 3] = list(struct.pack('BBB', end_h, end_s, end_c))

new_part_data[0xc:] = list(

struct.pack('BBBB', (new_partition_sector_num & 0xff), ((new_partition_sector_num >> 8) & 0xff),

((new_partition_sector_num >> 16) & 0xff), ((new_partition_sector_num >> 24) & 0xff)))

logger.debug("""

Start h,s,c: %u %u %u

End h,s,c: %u %u %u

Partition Type Name:%s

Start LBA: %u

Sector Number: %u

""" % (begin_h, begin_s, begin_c,

end_h, end_s, end_c,

mbr.partitions[0].partition_type_name,

mbr.partitions[0].start_lba,

new_partition_sector_num))

return new_part_data

def check_partition(dev, mbr):

"""检查磁盘分区"""

resize_part_flag = True

target_partition = ''

part_count = int(commands.getoutput("ls %s* | wc -w" % dev)) - 1

if part_count > 0 and part_count != mbr.vaild_part_num:

logger.debug(commands.getoutput('ls %s*' % dev))

logger.debug("%s != %s", part_count, mbr.vaild_part_num)

logger.error("Disk %s has invalid partition" % dev)

sys.exit(1)

if mbr.vaild_part_num > 1:

logger.error("Disk %s has multiple partitions." % dev)

sys.exit(1)

elif mbr.vaild_part_num == 1: # only one partition, which is the primary partition

if not mbr.partitions[0].isprimary(): # and the filesystem type is ext2/3/4.

logger.error("Must be primary partition.")

sys.exit(1)

resize_part_flag = True

if dev[-1].isdigit():

target_partition = dev + 'p1' # ex: /dev/nbd0 -> /dev/nbd0p1

else:

target_partition = dev + '1' # ex: /dev/vdb -> /dev/vdb1

logger.debug('target_partition:%s' % target_partition)

elif mbr.vaild_part_num == 0: # no partition but whole disk is ext2/3/4

resize_part_flag = False

target_partition = dev

return target_partition, resize_part_flag

def check_format(part):

"""检查是否为支持的分区类型"""

output = commands.getoutput('blkid %s' % part)

if not output:

logger.error("check filesystem format error, please ensure %s is a valid filesystem" % part)

sys.exit(1)

for fmt in ['ext2', 'ext3', 'ext4', 'xfs']:

if fmt in output:

return fmt

logger.error("Only can process ext2/3/4 and xfs.")

sys.exit(1)

def check_fs_healthy(part, fstype = 'ext'):

"""检查文件系统完整性"""

logger.info("checking filesystem healthy")

if is_ext_fs(fstype):

ret = os.system('e2fsck -af %s' % part)

logger.debug('e2fsck ret is %d' % ret)

if ret == 1:

logger.info('File system errors have been corrected')

ret = ret not in [0, 1]

else:

ret = os.system('xfs_repair %s' % part)

logger.debug('xfs_repair ret is %d' % ret)

if ret:

logger.error('File system %s error!' % part)

sys.exit(1)

def mount_fs(part, mount_dir):

"""挂载块设备"""

# first need to mount fs

if not os.path.exists(mount_dir):

os.mkdir(mount_dir)

ret = os.system('mount %s %s' % (part, mount_dir))

if ret != 0:

raise RuntimeError('mount failed! (return code %s)' % ret)

logger.info('mount %s %s' % (part, mount_dir))

def umount_fs(part):

"""解挂块设备"""

mount_dir = commands.getoutput("mount | grep '%s ' | awk '{print $3}'" % part)

if not mount_dir: # if not mounted

return

else:

ret = os.system('umount %s' % part)

logger.info('umount %s' % part)

if ret != 0:

raise RuntimeError('umount failed! (return code %s)' % ret)

def resize2fs(part):

"""使用resize2fs扩容ext文件系统"""

logger.info("resize filesystem")

ret = os.system('resize2fs -f %s' % part)

logger.debug('resize2fs ret is %d' % ret)

if ret != 0:

raise RuntimeError('resize2fs failed! (return code %s)' % ret)

def resize_xfs(mount_dir):

"""扩容xfs文件系统"""

logger.info("resize filesystem")

ret = os.system('xfs_growfs %s' % mount_dir)

logger.debug('xfs_growfs ret is %d' % ret)

if ret != 0:

raise RuntimeError('xfs_growfs failed! (return code %s)' % ret)

def check_mount(target_dev): # target_dev is mounted!

"""确认要扩容的块设备未挂载"""

output = commands.getoutput('mount | grep "%s "' % target_dev)

if output:

logger.error("Target partition %s must be unmounted." % target_dev)

sys.exit(1)

def part_probe(fd):

"""将写入文件的数据落到磁盘上"""

if logger:

logger.debug('part_probe')

fd.flush()

time.sleep(1)

ret = os.system("partprobe %s" % (fd.name))

if ret != 0:

logger.error("partprobe %s returned non-zero value %s" % (fd.name, ret))

sys.exit(1)

# fcntl.ioctl(fd, BLKRRPART)

def write_mbr(fd, mbr_data):

"""将mbr数据写入文件"""

fd.seek(0)

fd.write(mbr_data)

time.sleep(1)

part_probe(fd)

time.sleep(1)

def check_permission(device):

"""检查设备访问权限"""

if not os.access(device, os.W_OK):

logger.error("Permission denied")

sys.exit(1)

def check_args(device):

"""检查传入的参数是否为设备名而不是分区名"""

exclude_devices = ["/dev/loop", "/dev/nbd"]

normal_device = True

for name in exclude_devices:

if device.startswith(name):

normal_device = False

if normal_device and not re.match(NORMAL_DEVICE_NAME, device):

logger.error("The argument should be a whole disk, not a partition! Example: /dev/vdb")

sys.exit(1)

elif not normal_device and not re.match(SPECITIAL_DEVICE_NAME, device):

logger.error("The argument should be a whole disk, not a partition! Example: /dev/loop1")

sys.exit(1)

def check_partition_need_resize(target_partition):

"""检查分区是否可扩容"""

output = commands.getoutput("parted %s unit MiB print free | tail -n 2 | head -n 1" % target_partition)

return "Free Space" in output

def check_mbr(device):

"""检查是否为mbr分区"""

output = commands.getoutput("parted %s print | grep 'Partition Table'" % device)

if 'gpt' in output:

logger.error("Not support GPT disk currently")

sys.exit(1)

def check_commands(command_list=[]):

"""检查运行环境和工具是否支持"""

for cmd in command_list:

ret, _ = commands.getstatusoutput("which %s" % cmd)

if ret:

logger.error("%s: command not found" % cmd)

sys.exit(1)

# def get_disk_path(partation_name):

# """从*分区名*解析出块设备名"""

# for i, ch in enumerate(os.path.basename(partation_name)[::-1]):

# if not ch.isdigit():

# return partation_name[::-1][i::][::-1]

# logger.error("invalid para %s" % partation_name)

# raise Exception("invalid para %s" % partation_name)

def closefd(fd):

if not fd.closed:

logger.debug("close fd")

fd.close()

def main():

"""

Steps:

1. check filesystem format

2. check unmounted

3. check filesystem healthy

4. check filesystem block size

5. backup MBR

6. rewrite MBR(resize partition)

7. resize filesystem

"""

init_log()

logger.debug("user input:%s" % ' '.join(sys.argv))

parser = argparse.ArgumentParser()

parser.add_argument("device", help="your device path (not a partition)")

parser.add_argument("-f", "--force", help="ignore all prompts", action="store_true")

args = parser.parse_args()

device = args.device

check_args(device)

check_permission(device)

check_commands(["parted", "partprobe", "blkid"])

check_mbr(device)

fd = open(device, 'r+')

data = fd.read(512)

mbr = MBR(data)

bak_mbr_data = ''

mount_dir = '/tmp/mount_point_%s_%s' % \

(os.path.basename(device), time.strftime("%Y-%m-%d_%X", time.localtime()))

atexit.register(closefd, fd)

device_size, device_sector_number, logical_sector_size = get_device_size(fd)

target_partition, resize_part_flag = check_partition(device, mbr)

fstype = check_format(target_partition)

if is_ext_fs(fstype):

check_commands(["resize2fs", "e2fsck", "tune2fs"])

else:

check_commands(["xfs_growfs", "xfs_repair", "xfs_info"])

check_mount(target_partition)

check_fs_healthy(target_partition, fstype)

check_fs_block_size(target_partition, fstype, mount_dir)

if not args.force:

user_input = raw_input("This operation will extend %s to the last sector of device. \n"

"To ensure the security of your valuable data, \n"

"please create a snapshot of this volume before resize its file system, continue? [Y/n]\n" % target_partition)

if user_input.lower() != 'y' and user_input != '':

logger.warn("User input neither 'y' nor '[Enter]',exit.")

sys.exit(1)

if not args.force:

user_input = raw_input("It will resize (%s).\n"

"This operation may take from several minutes to several hours, continue? [Y/n]\n" % target_partition)

if user_input.lower() != 'y' and user_input != '':

logger.warn("User input neither 'y' nor '[Enter]',exit.")

sys.exit(1)

if resize_part_flag and check_partition_need_resize(device): # if need to resize partition

logger.debug("Begin to change the partation")

if (mbr.partitions[0].start_lba + mbr.partitions[0].sector_num) == device_sector_number:

logger.error("No free sectors available.")

sys.exit(1)

if mbr.partitions[0].sector_num > 0xFFFFFFFF * 512 / logical_sector_size:

logger.error("Can't process the partition which have exceeded 2TB.")

sys.exit(1)

new_start_sector = mbr.partitions[0].start_lba

new_end_sector = device_sector_number - 1

if (new_end_sector - new_start_sector + 1) * logical_sector_size > 0xFFFFFFFF * 512:

if not args.force:

user_input = raw_input("The size of this disk is %.2fTB (%d bytes).\n"

"But DOS partition table format can not be used on drives for volumes "

"larger than 2TB (2199023255040 bytes).\n"

"Do you want to resize (%s) to 2TB? [Y/n]\n"

% (round(device_size / 1024.0 / 1024 / 1024 / 1024, 2), device_size,

target_partition))

if user_input.lower() != 'y' and user_input != '':

logger.warn("User input neither 'y' nor '[Enter]',exit.")

sys.exit(1)

new_end_sector = 0xFFFFFFFF * 512 / logical_sector_size + new_start_sector - 1

new_mbr_data = list(data)[:]

new_mbr_data[446:446 + 16] = cal_new_part(data[446:446 + 16], mbr,

new_start_sector, new_end_sector)

backup_mbr(target_partition, data)

bak_mbr_data = data

else:

logger.info("No need to resize partition, try to resize filesystem")

resize_part_flag = False

time.sleep(1)

# rewrite MBR(if necessary), resize file system

try:

if resize_part_flag:

umount_fs(target_partition)

write_mbr(fd, ''.join(new_mbr_data))

umount_fs(target_partition)

if is_ext_fs(fstype):

resize2fs(target_partition)

else:

mount_fs(target_partition, mount_dir)

resize_xfs(mount_dir)

umount_fs(target_partition)

except Exception, e:

umount_fs(target_partition)

logger.error(e)

# logger.error('Some error occurred! Please make sure the e2fsprogs version is above 1.42.13.')

logger.error('Some error occurred! Maybe you should call the customer service staff.')

if resize_part_flag:

logger.error('Resize filesystem aborted, restore MBR')

write_mbr(fd, bak_mbr_data)

sys.exit(1)

logger.info("Finished")

if __name__ == '__main__':

main()