#!/usr/bin/env python2.7
# RaidGuessFS, a FUSE pseudo-filesystem to guess RAID parameters of a damaged device
# Copyright (C) 2015 Ludovic Pouzenc <ludovic@pouzenc.fr>
#
# Inspired by various python-fuse examples :
# hello.py
# Copyright (C) 2006 Andrew Straw <strawman@astraw.com>
#
# nullfs.py
# Copyright (C) 2001 Jeff Epler <jepler@unpythonic.dhs.org>
# Copyright (C) 2006 Csaba Henk <csaba.henk@creo.hu>
#
# templatefs.py
# Copyright (c) 2009 Matt Giuca
#
# Since they use LGPL and BSD licence, I choose GPLv3 (seems okay)
# This file is part of RaidGuessFS.
#
# RaidGuessFS is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# RaidGuessFS is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with RaidGuessFS. If not, see <http://www.gnu.org/licenses/>
# Standard modules
import sys, os, errno, logging, re, fuse
# Custom modules
import mystat, mydisks, mybinview, myraid, mytasks
if not hasattr(fuse, '__version__'):
raise RuntimeError, \
"your fuse-py doesn't know of fuse.__version__, probably it's too old."
class RaidGuessFS(fuse.Fuse):
"""Main class, implementing the actual pseudo-filesystem"""
def __init__(self, *args, **kwargs):
logging.info("Initializing filesystem")
logging.debug("Enter RaidGuessFS.__init__()")
super(RaidGuessFS,self).__init__(*args, **kwargs)
# Early initialisations (notably modules and the static directory tree part)
self.d = mydisks.MyDisks()
self.raid = myraid.MyRaid()
self.bmp = mybinview.MyBinView()
self.st = mystat.MyStat()
self.tasks = mytasks.MyTasks(self.d)
self.bmp.refresh_bmp()
self.dattr = { '/': self.st.make_fake_dir() }
self.fattr = { '/fsinit_has_failed': self.st.make_fake_file(0) }
self.settings = [
'disk_count',
'raid_start', 'raid_end', 'raid_chunk_size',
'raid_disk_order', 'raid_layout',
'bmp_height', 'bmp_width', 'bmp_start_offset',
'task_start', 'task_kill', 'task_find_files_pathlist'
]
self.settings_getters = [
self.d.get_disk_count,
self.raid.get_raid_start, self.raid.get_raid_end, self.raid.get_raid_chunk_size,
self.raid.get_raid_disk_order_str, self.raid.get_raid_layout,
self.bmp.get_bmp_height, self.bmp.get_bmp_width, self.bmp.get_bmp_start_offset,
self.get_task_start, self.get_task_kill, self.tasks.get_find_files_pathlist_str,
]
self.settings_updaters = [
self.update_disk_count,
self.update_raid_start, self.update_raid_end, self.update_raid_chunk_size, self.update_raid_disk_order,
self.raid.set_raid_layout,
self.update_bmp_height, self.update_bmp_width, self.update_bmp_start_offset,
self.tasks.task_start, self.tasks.task_kill, self.tasks.append_find_files_pathlist
]
self.dentries = {
'/' : [ fuse.Direntry(name) for name in ['config','disk','raid','tasks','visual'] ],
'/config': [ fuse.Direntry(name) for name in self.settings ],
'/raid' : [ fuse.Direntry(name) for name in myraid.MyRaid.RAID_TYPES ],
'/tasks' : [ fuse.Direntry(name) for name in self.tasks.TASK_NAMES ],
'/disk' : [ ], # Filled in _refresh_disk_dentries()
'/visual': [ ], # Filled in _refresh_disk_dentries()
}
for raid_type in myraid.MyRaid.RAID_TYPES:
self.dentries.update( {
'/raid/%s'%raid_type: [ fuse.Direntry(name) for name in ['disk_parity','disk_xor','raid_result'] ],
}
)
logging.debug("Exit. RaidGuessFS.__init__()")
def _refresh_disk_dentries(self):
"""Internal function to update directory entries about all disks"""
logging.debug("Enter _refresh_disk_dentries()")
disk_dentries = []
visual_dentries = []
for d in range(self.d.disk_count):
st_img = self.st.make_fake_file(self.d.disks_size[d])
st_bmp = self.st.make_fake_file(self.bmp.bmp_size)
self.fattr.update( {
'/disk/disk%02d.img'%d: st_img,
'/visual/disk%02d.bmp'%d: st_bmp,
}
)
disk_dentries.append( fuse.Direntry('disk%02d.img'%d) )
visual_dentries.append( fuse.Direntry('disk%02d.bmp'%d) )
self.dentries.update( { '/disk': disk_dentries } )
self.dentries.update( { '/visual': visual_dentries } )
logging.debug("Exit. _refresh_disk_dentries()")
def _refresh_raid_fattr(self):
"""Update the raid computed attributes after a config change"""
logging.debug("Enter _refresh_raid_fattr()")
for raid_type in myraid.MyRaid.RAID_TYPES:
self.fattr['/raid/%s/disk_parity'%raid_type].st_size = self.raid.sizeof_disk_parity(raid_type)
self.fattr['/raid/%s/disk_xor' %raid_type].st_size = self.raid.sizeof_disk_xor (raid_type)
self.fattr['/raid/%s/raid_result'%raid_type].st_size = self.raid.sizeof_raid_result(raid_type)
logging.debug("Exit. _refresh_raid_fattr()")
def _split_path(self,path):
"""Internal function to explode path for read() and write() calls"""
m = re.match('/([^/]+)/([^./0-9]*)([0-9+]*)(\.[^/]+)?(?:/([^/]+))?$', path)
if m:
return m.groups()
else:
return []
def _aton(self,arg,allow_zero=True):
i = int(arg)
if allow_zero:
if i < 0:
raise ValueError("Negative value make no sense here")
else:
if i <= 0:
raise ValueError("Non-positive value make no sense here")
return i
def update_disk_count(self,arg):
i = self._aton(arg)
self.d.set_disk_count(i)
self.d.open_disks()
self._refresh_disk_dentries()
self.raid.set_disks(self.d)
self.raid.set_raid_end(min(self.d.disks_size)-1)
self.update_raid_disk_order(range(i))
def update_bmp_start_offset(self, arg):
i = self._aton(arg)
self.bmp.set_bmp_start_offset(i)
self.bmp.refresh_bmp()
self._refresh_disk_dentries()
def update_bmp_width(self, arg):
i = self._aton(arg,False)
self.bmp.set_bmp_width(i)
self.bmp.refresh_bmp()
self._refresh_disk_dentries()
def update_bmp_height(self, arg):
i = self._aton(arg,False)
self.bmp.set_bmp_height(i)
self.bmp.refresh_bmp()
self._refresh_disk_dentries()
def update_raid_start(self, arg):
i = self._aton(arg)
self.raid.set_raid_start(i)
self._refresh_raid_fattr()
def update_raid_end(self, arg):
i = self._aton(arg)
self.raid.set_raid_end(i)
self._refresh_raid_fattr()
def update_raid_chunk_size(self, arg):
i = self._aton(arg,False)
self.raid.set_raid_chunk_size(i)
def update_raid_disk_order(self, arg):
logging.debug("Enter update_raid_disk_order(%s)"%arg)
if type(arg) is str:
l = map(int,arg.split())
elif type(arg) is list:
l = arg
else:
raise TypeError('update_raid_disk_order() wants a list or str')
logging.debug("==> %s (%d/%d)"%(l,len(l),self.d.disk_count))
self.raid.set_raid_disk_order(l)
self._refresh_raid_fattr()
logging.debug("Exit. update_raid_disk_order(%s)"%arg)
def get_task_start(self):
return 'Write a task_name in this pseudo-file to start it\n'
def get_task_kill(self):
return 'Write a task_name in this pseudo-file to kill it\n'
########################################################
# Actual File System operations implementation follows #
########################################################
def fsinit(self):
"""Make some run-time initalisations after argument parsing"""
logging.info("Mounting filesystem...")
# WARNING : this method is called by FUSE in a context that don't show fatal exceptions,
# even with -d[ebug] flag set, so log all exceptions
try:
self.dattr = {
path: self.st.make_fake_dir() for path in self.dentries.keys()
}
self.fattr = {
'/config/%s'%s: self.st.make_fake_file(4096,0666) for s in self.settings
}
self.fattr.update( {
'/tasks/%s'%s: self.st.make_fake_file(4096) for s in self.tasks.TASK_NAMES
})
for raid_type in myraid.MyRaid.RAID_TYPES:
self.fattr.update( {
'/raid/%s/disk_parity'%raid_type: self.st.make_fake_file(0),
'/raid/%s/disk_xor'%raid_type: self.st.make_fake_file(0),
'/raid/%s/raid_result'%raid_type: self.st.make_fake_file(0),
})
self.d.set_disks_path([getattr(self.parser.values,'disk%02d'%d) for d in range(self.d.max_disks)])
self.update_disk_count(len(self.d.disk_paths))
self._refresh_disk_dentries()
self._refresh_raid_fattr()
logging.info("Mounted.")
except Exception as e:
logging.exception(e)
def fsdestroy(self):
#TODO Kill tasks and see why some python processes stay alive on fusermount -u
return
def getattr(self, path):
logging.info("getattr: %s" % path)
res = self.dattr.get(path) or self.fattr.get(path) or -errno.ENOENT
logging.debug("==> " + str(res))
return res
def fgetattr(self, path, fh=None):
#logging.debug("fgetattr: %s (fh %s)" % (path, fh))
return self.getattr(path)
def readdir(self, path, offset, dh=None):
logging.info("readdir: %s (offset %s, dh %s)" % (path, offset, dh))
return self.dentries[path]
def truncate(self, path, size):
logging.info("truncate: %s (size %s)" % (path, size))
if path == '/config/task_find_files_pathlist':
self.tasks.set_find_files_pathlist([])
elif path.startswith('/config/'):
return # Ignore truncates on others pseudo config files
else:
return -errno.EOPNOTSUPP
def ftruncate(self, path, size, fh=None):
logging.info("ftruncate: %s (size %s, fh %s)" % (path, size, fh))
return self.truncate(path, size)
def read(self, path, size, offset, fh=None):
logging.info("read: %s (size %s, offset %s, fh %s)" % (path, size, offset, fh))
path_chuncks = self._split_path(path)
if path_chuncks:
try:
if path_chuncks[0] == 'config':
# TODO take care here
idx = self.settings.index(path_chuncks[1])
return str(self.settings_getters[idx]()) + "\n"
if path_chuncks[0] == 'disk':
if path_chuncks[1] == 'disk':
i = int(path_chuncks[2])
if 0 <= i <= self.d.disk_count:
if path_chuncks[3] == '.img':
return self.d.read(i,offset,size)
if path_chuncks[3] == '.bmp':
return self.bmp.read(self.d.disks[i],offset,size)
if path_chuncks[0] == 'visual':
if path_chuncks[1] == 'disk':
i = int(path_chuncks[2])
if 0 <= i <= self.d.disk_count:
if path_chuncks[3] == '.bmp':
return self.bmp.read(self.d.disks[i],offset,size)
if path_chuncks[0] == 'raid':
raid_type=path_chuncks[2]
if raid_type in myraid.MyRaid.RAID_TYPES:
if path_chuncks[4] == 'disk_parity':
return self.raid.read_disk_parity(raid_type,offset,size)
if path_chuncks[4] == 'disk_xor':
return self.raid.read_disk_xor(raid_type,offset,size)
if path_chuncks[4] == 'raid_result':
return self.raid.read_raid_result(raid_type,offset,size)
if path_chuncks[0] == 'tasks':
if path_chuncks[1] == 'find_bootsect':
return self.tasks.read_find_bootsect()[offset:offset+size]
if path_chuncks[1] == 'find_files':
return self.tasks.read_find_files()[offset:offset+size]
except Exception as e:
logging.exception(e)
return -errno.ENOENT
logging.error("Unimplemented read of '%s' (%s)"%(path, str(path_chuncks)))
return -errno.ENOENT
def write(self, path, buf, offset, fh=None):
logging.info("write: %s (offset %s, fh %s)" % (path, offset, fh))
path_chuncks = self._split_path(path)
if path_chuncks:
try:
if path_chuncks[0] == 'config':
# TODO take care here
idx = self.settings.index(path_chuncks[1])
try:
self.settings_updaters[idx](buf.rstrip())
return len(buf)
except Exception as e:
logging.exception(e)
return -errno.EIO
except Exception as e:
logging.exception(e)
return -errno.ENOENT
logging.error("Unimplemented write of '%s' (%s)"%(path, str(path_chuncks)))
return -errno.ENOENT
def main():
usage = fuse.Fuse.fusage + """
RaidGuessFS is a pseudo-filesystem that allows to guess parameters and disk order of a damaged RAID devices.
Takes disk image files as arguments (defaults to ./diskNN.img).
Could take advantage of ddrecue logs file (metadata about unreadable sectors)
"""
fuse.fuse_python_api = (0, 2)
LOG_FILENAME = "/tmp/raidguessfs.log"
#logging.basicConfig(filename=LOG_FILENAME,level=logging.WARN,)
#logging.basicConfig(filename=LOG_FILENAME,level=logging.INFO,)
logging.basicConfig(filename=LOG_FILENAME,level=logging.DEBUG,)
server = RaidGuessFS(version="%prog " + fuse.__version__,usage=usage,dash_s_do='setsingle')
server.multithreaded = False
cwd = os.getcwd()
# TODO : only 2 parameters, but taking a parametrized string
for num in range(server.d.max_disks):
server.parser.add_option(
mountopt="disk%02d"%num,
metavar="ABS_PATH",
default="%s/disk%02d.img"%(cwd,num),
help="Disk #%d image file path [default: ./disk%02d.img]"%(num,num)
)
server.parser.add_option(
mountopt="logf%02d"%num,
metavar="ABS_PATH",
default="%s/disk%02d.log"%(cwd,num),
help="Disk #%d ddrescue log file [default: ./disk%02d.log]"%(num,num)
)
server.parse(errex=1)
server.main()
if __name__ == '__main__':
main()