mirror of
https://github.com/amadvance/snapraid.git
synced 2026-10-12 02:10:54 +00:00
1771 lines
74 KiB
Makefile
1771 lines
74 KiB
Makefile
bin_PROGRAMS = snapraid
|
|
check_PROGRAMS = mktest mkstream checker
|
|
|
|
AM_CPPFLAGS = -DSYSCONFDIR="\"${sysconfdir}\""
|
|
CLEANFILES =
|
|
|
|
if HAVE_DISK_ARBITRATION
|
|
snapraid_LDFLAGS = -framework CoreFoundation -framework DiskArbitration
|
|
mktest_LDFLAGS = -framework CoreFoundation -framework DiskArbitration
|
|
mkstream_LDFLAGS = -framework CoreFoundation -framework DiskArbitration
|
|
endif # HAVE_DISK_ARBITRATION
|
|
|
|
# Windows
|
|
if HOST_WINDOWS
|
|
snapraid_LDADD = resource_res.o -ladvapi32 -luserenv
|
|
mktest_LDADD = -ladvapi32 -luserenv
|
|
mkstream_LDADD = -ladvapi32 -luserenv
|
|
|
|
resource_res.o: cmdline/resource.rc cmdline/resource.manifest
|
|
$(WINDRES) --include-dir=. --include-dir=$(srcdir) $< -o $@
|
|
|
|
CLEANFILES += resource_res.o
|
|
endif # HOST_WINDOWS
|
|
|
|
snapraid_SOURCES = \
|
|
raid/raid.c \
|
|
raid/check.c \
|
|
raid/module.c \
|
|
raid/tables.c \
|
|
raid/int.c \
|
|
raid/sse2.c \
|
|
raid/ssse3.c \
|
|
raid/avx2.c \
|
|
raid/avx512.c \
|
|
raid/gfni.c \
|
|
raid/neon.c \
|
|
raid/neon32.c \
|
|
raid/helper.c \
|
|
raid/memory.c \
|
|
raid/test.c \
|
|
tommyds/tommy.c \
|
|
cmdline/main.c \
|
|
cmdline/snapraid.c \
|
|
cmdline/io.c \
|
|
cmdline/bw.c \
|
|
cmdline/util.c \
|
|
cmdline/str.c \
|
|
cmdline/stream.c \
|
|
cmdline/support.c \
|
|
cmdline/memory.c \
|
|
cmdline/elem.c \
|
|
cmdline/state.c \
|
|
cmdline/scan.c \
|
|
cmdline/sync.c \
|
|
cmdline/check.c \
|
|
cmdline/dry.c \
|
|
cmdline/rehash.c \
|
|
cmdline/scrub.c \
|
|
cmdline/status.c \
|
|
cmdline/dup.c \
|
|
cmdline/list.c \
|
|
cmdline/pool.c \
|
|
cmdline/parity.c \
|
|
cmdline/locate.c \
|
|
cmdline/handle.c \
|
|
cmdline/touch.c \
|
|
cmdline/device.c \
|
|
cmdline/selftest.c \
|
|
cmdline/speed.c \
|
|
cmdline/import.c \
|
|
cmdline/search.c \
|
|
cmdline/thermal.c \
|
|
os/mingw.c \
|
|
cmdline/mingwapp.c \
|
|
os/unix.c \
|
|
cmdline/unixapp.c
|
|
|
|
noinst_HEADERS = \
|
|
raid/raid.h \
|
|
raid/helper.h \
|
|
raid/internal.h \
|
|
raid/cpu.h \
|
|
raid/gf.h \
|
|
raid/combo.h \
|
|
raid/memory.h \
|
|
raid/test.h \
|
|
tommyds/tommyarray.h \
|
|
tommyds/tommyarrayblkof.h \
|
|
tommyds/tommychain.h \
|
|
tommyds/tommyhash.h \
|
|
tommyds/tommyhashdyn.h \
|
|
tommyds/tommylist.h \
|
|
tommyds/tommytree.h \
|
|
tommyds/tommytypes.h \
|
|
tommyds/tommyarray.c \
|
|
tommyds/tommyarrayblkof.c \
|
|
tommyds/tommyhash.c \
|
|
tommyds/tommyhashdyn.c \
|
|
tommyds/tommylist.c \
|
|
tommyds/tommytree.c \
|
|
cmdline/snapraid.h \
|
|
cmdline/io.h \
|
|
cmdline/bw.h \
|
|
cmdline/util.h \
|
|
cmdline/str.h \
|
|
cmdline/stream.h \
|
|
cmdline/support.h \
|
|
cmdline/memory.h \
|
|
cmdline/elem.h \
|
|
cmdline/state.h \
|
|
cmdline/parity.h \
|
|
cmdline/locate.h \
|
|
cmdline/handle.h \
|
|
cmdline/murmur3.c \
|
|
cmdline/murmur3test.c \
|
|
cmdline/spooky2.c \
|
|
cmdline/spooky2test.c \
|
|
cmdline/museair.c \
|
|
cmdline/museairtest.c \
|
|
cmdline/import.h \
|
|
cmdline/search.h \
|
|
cmdline/thermal.h \
|
|
cmdline/app.h \
|
|
os/os.h \
|
|
os/mingw.h \
|
|
os/unix.h \
|
|
os/portable.h
|
|
|
|
mktest_SOURCES = \
|
|
cmdline/mktest.c \
|
|
os/mingw.c \
|
|
cmdline/mingwapp.c \
|
|
os/unix.c \
|
|
cmdline/unixapp.c \
|
|
cmdline/support.c \
|
|
cmdline/str.c \
|
|
cmdline/memory.c \
|
|
tommyds/tommy.c
|
|
|
|
mkstream_SOURCES = \
|
|
cmdline/mkstream.c \
|
|
os/mingw.c \
|
|
cmdline/mingwapp.c \
|
|
os/unix.c \
|
|
cmdline/unixapp.c \
|
|
cmdline/support.c \
|
|
cmdline/str.c \
|
|
cmdline/memory.c \
|
|
cmdline/util.c \
|
|
cmdline/stream.c \
|
|
raid/memory.c \
|
|
tommyds/tommy.c
|
|
|
|
# Checker binary share the snapraid variables, with the exception of the checker.c source
|
|
checker_SOURCES = $(snapraid_SOURCES:cmdline/snapraid.c=cmdline/checker.c)
|
|
checker_LDFLAGS = $(snapraid_LDFLAGS)
|
|
checker_LDADD = $(snapraid_LDADD)
|
|
|
|
# Basic dependencies
|
|
CLI_PREFIX = cmdline/
|
|
CLI_INCLUDES = \
|
|
config.h \
|
|
$(srcdir)/cmdline/app.h \
|
|
$(srcdir)/cmdline/bw.h \
|
|
$(srcdir)/cmdline/elem.h \
|
|
$(srcdir)/cmdline/handle.h \
|
|
$(srcdir)/cmdline/import.h \
|
|
$(srcdir)/cmdline/io.h \
|
|
$(srcdir)/cmdline/locate.h \
|
|
$(srcdir)/cmdline/memory.h \
|
|
$(srcdir)/cmdline/parity.h \
|
|
$(srcdir)/cmdline/search.h \
|
|
$(srcdir)/cmdline/snapraid.h \
|
|
$(srcdir)/cmdline/state.h \
|
|
$(srcdir)/cmdline/str.h \
|
|
$(srcdir)/cmdline/stream.h \
|
|
$(srcdir)/cmdline/support.h \
|
|
$(srcdir)/cmdline/thermal.h \
|
|
$(srcdir)/cmdline/util.h \
|
|
$(srcdir)/os/mingw.h \
|
|
$(srcdir)/os/os.h \
|
|
$(srcdir)/os/portable.h \
|
|
$(srcdir)/os/unix.h
|
|
|
|
$(CLI_PREFIX)bw.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)check.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)checker.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)device.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)dry.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)dup.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)elem.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)handle.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)import.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)io.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)list.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)locate.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)main.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)memory.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)mingwapp.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)mkstream.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)mktest.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)parity.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)pool.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)rehash.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)scan.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)scrub.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)search.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)selftest.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)snapraid.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)speed.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)state.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)status.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)str.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)stream.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)support.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)sync.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)thermal.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)touch.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)unixapp.$(OBJEXT): $(CLI_INCLUDES)
|
|
$(CLI_PREFIX)util.$(OBJEXT): $(CLI_INCLUDES) \
|
|
$(srcdir)/cmdline/murmur3.c \
|
|
$(srcdir)/cmdline/spooky2.c \
|
|
$(srcdir)/cmdline/museair.c
|
|
|
|
# Add the .version file in the distribution
|
|
dist-hook:
|
|
$(srcdir)/autover.sh > $(distdir)/.version
|
|
|
|
LANG_CODES = de es fr it ja ko pl pt ro ru sv uk zh
|
|
|
|
LIST_D = doc/snapraid.d doc/snapraid_log.d $(patsubst %, doc/snapraid-%.d, $(LANG_CODES))
|
|
|
|
LIST_MAN = doc/snapraid.1 doc/snapraid_log.1 $(patsubst %, doc/snapraid-%.1, $(LANG_CODES))
|
|
|
|
LIST_TXT = doc/snapraid.txt doc/snapraid_log.txt $(patsubst %, doc/snapraid-%.txt, $(LANG_CODES))
|
|
|
|
LIST_XML = doc/snapraid.xml doc/snapraid_log.xml $(patsubst %, doc/snapraid-%.xml, $(LANG_CODES))
|
|
|
|
EXTRA_DIST = \
|
|
autogen.sh autover.sh valgrind.supp \
|
|
README AUTHORS HISTORY INSTALL BLUEBOX TODO CHECK INSTALL.windows \
|
|
COPYING LICENSES/GPL-2.0 LICENSES/GPL-3.0 LICENSES/BSD-2-Clause \
|
|
$(LIST_D) \
|
|
$(LIST_MAN) \
|
|
$(LIST_TXT) \
|
|
test/test-snap.conf \
|
|
test/snapcheck-ntfs.ps1 \
|
|
test/test-par1.conf \
|
|
test/test-par2.conf \
|
|
test/test-par3.conf \
|
|
test/test-parz.conf \
|
|
test/test-par4.conf \
|
|
test/test-par5.conf \
|
|
test/test-par6.conf \
|
|
test/test-realloc-level1.conf \
|
|
test/test-realloc-level2.conf \
|
|
test/test-realloc-split1.conf \
|
|
test/test-realloc-split2.conf \
|
|
test/test-par6-hole.conf \
|
|
test/test-par6-noaccess.conf \
|
|
test/test-par6-rename.conf \
|
|
test/test-par6-thermal.conf \
|
|
snapraid.conf.example \
|
|
cmdline/resource.rc \
|
|
cmdline/resource.manifest \
|
|
configure.windows-x86 configure.windows-x64 snapraid.conf.example.windows \
|
|
m4/ax_pthread.m4 \
|
|
m4/m4_ax_check_compile_flag.m4 \
|
|
raid/README \
|
|
raid/NOTES \
|
|
raid/OTHERS \
|
|
raid/mktables.c \
|
|
raid/test/Makefile \
|
|
raid/test/fulltest.c \
|
|
raid/test/selftest.c \
|
|
raid/test/speedtest.c \
|
|
raid/test/invtest.c \
|
|
raid/test/invtestx.c \
|
|
makeslackware.sh.in \
|
|
makeslackdist.sh.in \
|
|
pkg/snapraid.SlackBuild.in \
|
|
pkg/snapraid.info.in \
|
|
pkg/slack-desc \
|
|
makedeb.sh.in \
|
|
pkg/control.in \
|
|
makerpm.sh.in \
|
|
pkg/snapraid.spec.in \
|
|
makearch.sh.in \
|
|
makearchdist.sh.in \
|
|
pkg/.PKGINFO.in \
|
|
pkg/PKGBUILD.in \
|
|
pkg/.SRCINFO.in
|
|
|
|
man1_MANS = doc/snapraid.1 doc/snapraid_log.1
|
|
|
|
clean-local:
|
|
rm -f valgrind.log callgrind.log cachegrind.log
|
|
rm -rf bench
|
|
rm -f test*.log output.log stream*.bin
|
|
rm -f cmdline/*.gcda cmdline/*.gcno cmdline/*.gcov
|
|
rm -f raid/*.gcda raid/*.gcno raid/*.gcov
|
|
rm -f tommyds/*.gcda tommyds/*.gcno tommyds/*.gcov
|
|
rm -f lcov.info
|
|
rm -f gmon.out
|
|
rm -f makeslackware.sh makeslackdist.sh pkg/snapraid.SlackBuild pkg/snapraid.info makedeb.sh pkg/control makerpm.sh pkg/snapraid.spec
|
|
rm -fr *.plist
|
|
|
|
maintainer-clean-local:
|
|
rm -f $(LIST_MAN)
|
|
rm -f $(LIST_TXT)
|
|
rm -f $(LIST_XML)
|
|
rm -f snapraid-*.txz snapraid_*.deb snapraid-*.rpm snapraid-*.tar.zst snapraid-*.zip snapraid-*.tar.gz
|
|
rm -f snapraid.src.tar.gz snapraid.tar.gz
|
|
|
|
# Install localized manpages
|
|
install-data-hook:
|
|
for lang in $(LANG_CODES); do \
|
|
mkdir -p $(DESTDIR)$(mandir)/$$lang/man1; \
|
|
$(INSTALL_DATA) $(srcdir)/doc/snapraid-$$lang.1 $(DESTDIR)$(mandir)/$$lang/man1/snapraid.1; \
|
|
done
|
|
@echo ""
|
|
@echo "=================================================================="
|
|
@echo " $(PACKAGE_NAME) installation complete!"
|
|
@echo "=================================================================="
|
|
@echo ""
|
|
@if test -z "$(DESTDIR)"; then \
|
|
if test ! -f /etc/snapraidd.conf -a ! -f $(sysconfdir)/snapraid.conf; then \
|
|
echo "Configuration:"; \
|
|
echo " 1. Create your configuration file:"; \
|
|
echo " cp $(docdir)/snapraid.conf.example /etc/snapraid.conf"; \
|
|
echo " 2. Edit /etc/snapraid.conf to match your setup."; \
|
|
echo ""; \
|
|
echo "=================================================================="; \
|
|
fi; \
|
|
fi
|
|
|
|
# Uninstall localized manpages
|
|
uninstall-hook:
|
|
for lang in $(LANG_CODES); do \
|
|
rm -f $(DESTDIR)$(mandir)/$$lang/man1/snapraid.1; \
|
|
rmdir --ignore-fail-on-non-empty $(DESTDIR)$(mandir)/$$lang/man1 2>/dev/null || true; \
|
|
rmdir --ignore-fail-on-non-empty $(DESTDIR)$(mandir)/$$lang 2>/dev/null || true; \
|
|
done
|
|
|
|
# Automatic testing
|
|
|
|
# Common options
|
|
# --test-skip-device
|
|
# Is required to allow testing in the same disk
|
|
#
|
|
# --test-skip-self
|
|
# It just makes the test a little faster
|
|
#
|
|
# --test-io-advise-none
|
|
# Keep data in the page cache to speedup the test
|
|
CHECKFLAGS_COMMON = --test-skip-device --test-skip-self --test-force-progress --no-warnings --test-parity-limit=3333333 --test-io-advise-none
|
|
|
|
# --test-force-order-alpha
|
|
# Ensures to process files always in the same order despite
|
|
# the inode, physical location, and dir order assigned by the OS.
|
|
CHECKFLAGS_ALPHA = $(CHECKFLAGS_COMMON) --test-force-order-alpha
|
|
|
|
# Directory order options
|
|
CHECKFLAGS_DIR = $(CHECKFLAGS_COMMON) --test-force-order-dir -q -q -q
|
|
|
|
# Verbose options
|
|
CHECKFLAGS_VERBOSE = $(CHECKFLAGS_ALPHA) -v --gui
|
|
|
|
# Quiet options
|
|
CHECKFLAGS = $(CHECKFLAGS_ALPHA) -q -q -q
|
|
|
|
# Snapshots with no parity limit
|
|
CHECKFLAGS_SNAP = --test-skip-device --test-skip-self --test-io-advise-none --test-force-order-alpha -q -q -q
|
|
|
|
# Short check options
|
|
if HAVE_MEMORY_CHECKER
|
|
SHORTCHECK = 1
|
|
endif # HAVE_MEMORY_CHECKER
|
|
SHORTCHECK ?= 0
|
|
|
|
# Number of files to create
|
|
if HAVE_POSIX
|
|
CHECKCOUNT_DEFAULT = 1000
|
|
else # HAVE_POSIX
|
|
CHECKCOUNT_DEFAULT = 500
|
|
endif # HAVE_POSIX
|
|
|
|
CHECKCOUNT = $(if $(filter 1,$(SHORTCHECK)),500,$(CHECKCOUNT_DEFAULT))
|
|
CHECKSIZE = $(if $(filter 1,$(SHORTCHECK)),100,4000)
|
|
|
|
CONF = $(srcdir)/test/test-par6.conf
|
|
THERMAL = $(srcdir)/test/test-par6-thermal.conf
|
|
HOLE = $(srcdir)/test/test-par6-hole.conf
|
|
NOACCESS = $(srcdir)/test/test-par6-noaccess.conf
|
|
RENAME = $(srcdir)/test/test-par6-rename.conf
|
|
PAR1 = $(srcdir)/test/test-par1.conf
|
|
PAR2 = $(srcdir)/test/test-par2.conf
|
|
PAR3 = $(srcdir)/test/test-par3.conf
|
|
PARZ = $(srcdir)/test/test-parz.conf
|
|
PAR4 = $(srcdir)/test/test-par4.conf
|
|
PAR5 = $(srcdir)/test/test-par5.conf
|
|
PAR6 = $(srcdir)/test/test-par6.conf
|
|
REALLOC_LEVEL1 = $(srcdir)/test/test-realloc-level1.conf
|
|
REALLOC_LEVEL2 = $(srcdir)/test/test-realloc-level2.conf
|
|
REALLOC_SPLIT1 = $(srcdir)/test/test-realloc-split1.conf
|
|
REALLOC_SPLIT2 = $(srcdir)/test/test-realloc-split2.conf
|
|
SNAP = $(srcdir)/test/test-snap.conf
|
|
MSG = @echo =====
|
|
SNAPRAID = ./checker$(EXEEXT)
|
|
SNAPCHECK_NTFS = powershell.exe -NoProfile -ExecutionPolicy Bypass -File "$(srcdir)/test/snapcheck-ntfs.ps1"
|
|
|
|
CLEANFILES += rm.exe mv.exe touch.exe
|
|
|
|
setupcheck:
|
|
rm -rf bench
|
|
rm -f test.log
|
|
rm -f rm.exe mv.exe touch.exe
|
|
mkdir bench
|
|
if !HAVE_POSIX
|
|
ln -sf $$(which rm) rm.exe
|
|
ln -sf $$(which mv) mv.exe
|
|
ln -sf $$(which touch) touch.exe
|
|
endif # !HAVE_POSIX
|
|
|
|
# Not included in main check because it requires root permissions
|
|
snapcheck_btrfs: mktest$(EXEEXT) checker$(EXEEXT) setupcheck
|
|
sudo $(MAKE) snapcheck_btrfs_run; \
|
|
status=$$?; \
|
|
sudo $(MAKE) snapcheck_btrfs_cleanup; \
|
|
cleanup_status=$$?; \
|
|
if test $$cleanup_status -ne 0; then exit $$cleanup_status; fi; \
|
|
exit $$status
|
|
|
|
# Not included in main check because it requires root permissions
|
|
snapcheck_bcachefs: mktest$(EXEEXT) checker$(EXEEXT) setupcheck
|
|
sudo $(MAKE) snapcheck_bcachefs_run; \
|
|
status=$$?; \
|
|
sudo $(MAKE) snapcheck_bcachefs_cleanup; \
|
|
cleanup_status=$$?; \
|
|
if test $$cleanup_status -ne 0; then exit $$cleanup_status; fi; \
|
|
exit $$status
|
|
|
|
# Not included in main check because it requires root permissions
|
|
snapcheck_zfs: mktest$(EXEEXT) checker$(EXEEXT) setupcheck
|
|
sudo $(MAKE) snapcheck_zfs_run; \
|
|
status=$$?; \
|
|
sudo $(MAKE) snapcheck_zfs_cleanup; \
|
|
cleanup_status=$$?; \
|
|
if test $$cleanup_status -ne 0; then exit $$cleanup_status; fi; \
|
|
exit $$status
|
|
|
|
# Not included in main check because it requires administrator privileges
|
|
snapcheck_ntfs: mktest$(EXEEXT) checker$(EXEEXT) setupcheck
|
|
$(MAKE) snapcheck_ntfs_run; \
|
|
status=$$?; \
|
|
$(MAKE) snapcheck_ntfs_cleanup; \
|
|
cleanup_status=$$?; \
|
|
if test $$cleanup_status -ne 0; then exit $$cleanup_status; fi; \
|
|
exit $$status
|
|
|
|
snapcheck_btrfs_run:
|
|
mkdir bench/snap1
|
|
mkdir bench/snap2
|
|
mkdir bench/snap3
|
|
$(MSG) Create Btrfs storages
|
|
dd bs=1048576 count=32 if=/dev/zero of=bench/snap1.img
|
|
dd bs=1048576 count=32 if=/dev/zero of=bench/snap2.img
|
|
dd bs=1048576 count=32 if=/dev/zero of=bench/snap3.img
|
|
/sbin/mkfs.btrfs --mixed bench/snap1.img
|
|
/sbin/mkfs.btrfs --mixed bench/snap2.img
|
|
/sbin/mkfs.btrfs --mixed bench/snap3.img
|
|
mount -o loop bench/snap1.img bench/snap1
|
|
mount -o loop bench/snap2.img bench/snap2
|
|
mount -o loop bench/snap3.img bench/snap3
|
|
$(MAKE) snapcheck_run SNAPCHECK_SHOW=snapcheck_btrfs_show
|
|
|
|
snapcheck_bcachefs_run:
|
|
mkdir bench/snap1
|
|
mkdir bench/snap2
|
|
mkdir bench/snap3
|
|
$(MSG) Create Bcachefs storages
|
|
truncate -s 1G bench/snap1.img
|
|
truncate -s 1G bench/snap2.img
|
|
truncate -s 1G bench/snap3.img
|
|
losetup --find --show bench/snap1.img > bench/snap1.loop
|
|
losetup --find --show bench/snap2.img > bench/snap2.loop
|
|
losetup --find --show bench/snap3.img > bench/snap3.loop
|
|
bcachefs format -f $$(cat bench/snap1.loop)
|
|
bcachefs format -f $$(cat bench/snap2.loop)
|
|
bcachefs format -f $$(cat bench/snap3.loop)
|
|
mount -t bcachefs $$(cat bench/snap1.loop) bench/snap1
|
|
mount -t bcachefs $$(cat bench/snap2.loop) bench/snap2
|
|
mount -t bcachefs $$(cat bench/snap3.loop) bench/snap3
|
|
$(MAKE) snapcheck_run SNAPCHECK_SHOW=snapcheck_bcachefs_show
|
|
|
|
snapcheck_zfs_run:
|
|
mkdir bench/snap1
|
|
mkdir bench/snap2
|
|
mkdir bench/snap3
|
|
$(MSG) Create ZFS storage
|
|
echo snapraid_snapcheck_$$$$ > bench/snap-zpool
|
|
truncate -s 256M bench/snap-zfs.img
|
|
zpool create -f -o cachefile=none -m none $$(cat bench/snap-zpool) $(CURDIR)/bench/snap-zfs.img
|
|
zfs create -o mountpoint=$(CURDIR)/bench/snap1 -o snapdir=visible $$(cat bench/snap-zpool)/snap1
|
|
zfs create -o mountpoint=$(CURDIR)/bench/snap2 -o snapdir=visible $$(cat bench/snap-zpool)/snap2
|
|
zfs create -o mountpoint=$(CURDIR)/bench/snap3 -o snapdir=visible $$(cat bench/snap-zpool)/snap3
|
|
$(MAKE) snapcheck_run SNAPCHECK_SHOW=snapcheck_zfs_show
|
|
|
|
snapcheck_ntfs_run:
|
|
$(MSG) Create NTFS storages
|
|
$(SNAPCHECK_NTFS) setup
|
|
$(MAKE) snapcheck_run SNAPCHECK_SHOW=snapcheck_ntfs_show
|
|
|
|
snapcheck_btrfs_show:
|
|
@for dir in bench/snap1 bench/snap2 bench/snap3; do \
|
|
echo "$$dir/.snapraid:"; \
|
|
if test -d "$$dir/.snapraid"; then ls -la "$$dir/.snapraid"; else echo " (missing)"; fi; \
|
|
done
|
|
|
|
snapcheck_bcachefs_show:
|
|
@for dir in bench/snap1 bench/snap2 bench/snap3; do \
|
|
echo "$$dir/.snapraid:"; \
|
|
if test -d "$$dir/.snapraid"; then ls -la "$$dir/.snapraid"; else echo " (missing)"; fi; \
|
|
done
|
|
|
|
snapcheck_zfs_show:
|
|
@pool=$$(cat bench/snap-zpool); \
|
|
zfs list -t snapshot -r "$$pool"
|
|
|
|
snapcheck_ntfs_show:
|
|
@$(SNAPCHECK_NTFS) show
|
|
|
|
snapcheck_run:
|
|
$(MSG) Create some files
|
|
$(TESTENV) ./mktest$(EXEEXT) generate 1 snap 3 $(CHECKCOUNT) $(CHECKSIZE)
|
|
$(MSG) Basic
|
|
# Setup
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync
|
|
$(MSG) Snapshots after initial sync
|
|
@$(MAKE) --no-print-directory $(SNAPCHECK_SHOW)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) scrub -p full
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) check -d snap1
|
|
# Recover test
|
|
$(MSG) Recover with file deletions from two disk with ONLY one parity OUTSIDE SYNC
|
|
rm -rf bench/snap1/a
|
|
rm -rf bench/snap2/a
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) fix -d snap1 -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) fix -d snap2 -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync --force-full
|
|
# Recover test
|
|
$(MSG) Recover with file deletions from two disk with ONLY one parity aborted BEFORE SYNC
|
|
# Changes (including deletion) on disk1
|
|
$(TESTENV) ./mktest$(EXEEXT) change 1 500 bench/snap1/a/* bench/snap1/b/*
|
|
# Sync aborted BEFORE
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync --test-kill-before-sync
|
|
$(MSG) Snapshots after interrupted sync BEFORE
|
|
@$(MAKE) --no-print-directory $(SNAPCHECK_SHOW)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) status
|
|
# Destroy disk2
|
|
rm -rf bench/snap2/a bench/snap2/b
|
|
# Recover disk2 (disk1 is intentionally modified, so nothing to recover)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) fix -d snap2 -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync --force-full
|
|
# Recover test
|
|
$(MSG) Recover with file deletions from two disk with ONLY one parity aborted AFTER SYNC
|
|
# Changes (including deletion) on disk1
|
|
$(TESTENV) ./mktest$(EXEEXT) change 2 500 bench/snap1/a/* bench/snap1/b/*
|
|
# Sync aborted AFTER
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync --test-kill-after-sync
|
|
$(MSG) Snapshots after interrupted sync AFTER
|
|
@$(MAKE) --no-print-directory $(SNAPCHECK_SHOW)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) status
|
|
# Destroy disk2
|
|
rm -rf bench/snap2/a bench/snap2/b
|
|
# Recover disk2 (disk1 is intentionally modified, so nothing to recover)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) fix -d snap2 -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync --force-full
|
|
# Sync recover
|
|
$(MSG) Sync recover aborted AFTER
|
|
# Change files in disk1
|
|
$(TESTENV) ./mktest$(EXEEXT) change 1 500 bench/snap1/a/*
|
|
# Sync abort and sync retry
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync --test-kill-after-sync
|
|
$(MSG) Snapshots before retry after interrupted sync AFTER
|
|
@$(MAKE) --no-print-directory $(SNAPCHECK_SHOW)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync
|
|
$(MSG) Snapshots after retry
|
|
@$(MAKE) --no-print-directory $(SNAPCHECK_SHOW)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) check
|
|
# Sync recover
|
|
$(MSG) Sync recover aborted BEFORE
|
|
# Change files in disk1
|
|
$(TESTENV) ./mktest$(EXEEXT) change 1 500 bench/snap1/b/*
|
|
# Sync abort and sync retry
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync --test-kill-before-sync
|
|
$(MSG) Snapshots before retry after interrupted sync BEFORE
|
|
@$(MAKE) --no-print-directory $(SNAPCHECK_SHOW)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) sync
|
|
$(MSG) Snapshots after retry
|
|
@$(MAKE) --no-print-directory $(SNAPCHECK_SHOW)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_SNAP) -c $(SNAP) check
|
|
|
|
snapcheck_btrfs_cleanup:
|
|
$(MSG) Cleanup Btrfs storages
|
|
status=0; \
|
|
for dir in bench/snap1 bench/snap2 bench/snap3; do \
|
|
if mountpoint -q $$dir; then umount $$dir || status=1; fi; \
|
|
done; \
|
|
if test $$status -ne 0; then exit $$status; fi; \
|
|
rm -rf bench; \
|
|
rm -f test.log
|
|
|
|
snapcheck_bcachefs_cleanup:
|
|
$(MSG) Cleanup Bcachefs storages
|
|
status=0; \
|
|
for dir in bench/snap1 bench/snap2 bench/snap3; do \
|
|
if mountpoint -q $$dir; then umount $$dir || status=1; fi; \
|
|
done; \
|
|
for loopfile in bench/snap1.loop bench/snap2.loop bench/snap3.loop; do \
|
|
if test -f $$loopfile; then \
|
|
dev=$$(cat $$loopfile); \
|
|
if losetup $$dev >/dev/null 2>&1; then losetup -d $$dev || status=1; fi; \
|
|
fi; \
|
|
done; \
|
|
if test $$status -ne 0; then exit $$status; fi; \
|
|
rm -rf bench; \
|
|
rm -f test.log
|
|
|
|
snapcheck_zfs_cleanup:
|
|
$(MSG) Cleanup ZFS storage
|
|
if test -f bench/snap-zpool; then \
|
|
pool=$$(cat bench/snap-zpool); \
|
|
if zpool list -H -o name "$$pool" >/dev/null 2>&1; then zpool destroy -f "$$pool"; fi; \
|
|
fi
|
|
rm -rf bench
|
|
rm -f test.log
|
|
|
|
snapcheck_ntfs_cleanup:
|
|
$(MSG) Cleanup NTFS storages
|
|
$(SNAPCHECK_NTFS) cleanup
|
|
rm -f test.log
|
|
|
|
check-local: setupcheck
|
|
mkdir bench/disk1
|
|
mkdir bench/disk2
|
|
mkdir bench/disk3
|
|
mkdir bench/disk4
|
|
mkdir bench/disk5
|
|
mkdir bench/disk6
|
|
mkdir bench/pool
|
|
$(MSG) Stream
|
|
$(TESTENV) ./mkstream$(EXEEXT)
|
|
if HAVE_THREAD_CHECKER
|
|
#### THREAD TEST ####
|
|
$(MSG) Create some files
|
|
$(TESTENV) ./mktest$(EXEEXT) generate 1 disk 6 $(CHECKCOUNT) $(CHECKSIZE)
|
|
$(MSG) Some commands that use threads
|
|
# First sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
# Remove, move and add some more
|
|
rm bench/disk4/a/9*
|
|
rm bench/disk5/a/9*
|
|
rm bench/disk6/a/9*
|
|
mv bench/disk1/a/9* bench/disk4/a
|
|
mv bench/disk2/a/9* bench/disk5/a
|
|
mv bench/disk3/a/9* bench/disk6/a
|
|
$(TESTENV) ./mktest$(EXEEXT) change 2 500 bench/disk2/b/* bench/disk3/b/*
|
|
# Sync again
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
# Other commands that uses threads
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) test-rewrite
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) scrub -p full
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 3
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 128
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync -F --test-io-cache 1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) scrub -p full --test-io-cache 1
|
|
else # HAVE_THREAD_CHECKER
|
|
#### COMMAND LINE ####
|
|
$(MSG) Pre test
|
|
$(TESTENV) $(SNAPRAID) --test-skip-device -H
|
|
$(TESTENV) $(SNAPRAID) --test-skip-device -V
|
|
$(TESTENV) $(SNAPRAID) test
|
|
$(TESTENV) ./mktest$(EXEEXT)
|
|
if !HAVE_MEMORY_CHECKER
|
|
if HAVE_EMULATOR
|
|
$(MSG) Speed
|
|
# Run the self test in AVX512
|
|
$(TESTENV_AVX512) $(SNAPRAID) --test-skip-device -c $(CONF) status
|
|
# Run the speed test in different architectures
|
|
$(TESTENV_SSE2) $(SNAPRAID) --test-skip-device -T
|
|
$(TESTENV_SSSE3) $(SNAPRAID) --test-skip-device -T
|
|
$(TESTENV_SSE42) $(SNAPRAID) --test-skip-device -T
|
|
$(TESTENV_AVX2) $(SNAPRAID) --test-skip-device -T
|
|
$(TESTENV_AVX512) $(SNAPRAID) --test-skip-device -T
|
|
else # HAVE_EMULATOR
|
|
# Run the self test natively
|
|
$(TESTENV) $(SNAPRAID) --test-skip-device -c $(CONF) status
|
|
# Run the speed test natively
|
|
$(TESTENV) $(SNAPRAID) --test-skip-device -T
|
|
endif # HAVE_EMULATOR
|
|
endif # !HAVE_MEMORY_CHECKER
|
|
#### EMPTY ####
|
|
$(MSG) Some commands with empty array
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) diff
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) dup
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) list > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l ">&1"
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l ">&2"
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l ">>test.log"
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l test-%D-%T.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) up
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) down -d parity -d disk1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) devices
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) probe --test-fake-device
|
|
if !CROSS_COMPILING
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) probe --test-fake-device -s
|
|
endif # !CROSS_COMPILING
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) smart --test-fake-device --test-expect-failure
|
|
if HAVE_POSIX
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) pool
|
|
endif # HAVE_POSIX
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -a check
|
|
#### CONTROLLED ####
|
|
$(MSG) Filesystem allocation test
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST
|
|
# Copy the file to trigger the copy optimization check
|
|
cp -a bench/disk1/TEST bench/disk2/TEST
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
# Now delete the file, and do a partial sync to force a deallocation in the middle of a file
|
|
rm bench/disk1/TEST
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E -S 1 -B 1 sync
|
|
# Now force a deallocation at the end
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E -S 7 -B 1 sync
|
|
rm bench/disk2/TEST
|
|
# Have the sync to fail for empty disk
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync --test-expect-failure
|
|
# Now sync will complete with -E
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E sync
|
|
$(MSG) Filesystem fragmentation test
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST1
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST2
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST3
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST4
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST5
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/TEST6
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
# Now delete some files, and create a bigger one to fill the holes
|
|
rm bench/disk1/TEST1
|
|
rm bench/disk1/TEST3
|
|
rm bench/disk1/TEST5
|
|
dd bs=1 count=65536 if=/dev/zero of=bench/disk1/TESTX
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync -l ">&1"
|
|
rm -r bench/disk1/TEST*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E sync
|
|
# Now enforce copy detection of a file without parity
|
|
# Create a file in a high number disk
|
|
dd bs=1 count=8192 if=/dev/urandom of=bench/disk6/STEP1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync --bw-limit 1M
|
|
# Create two new copies. The one in disk1 will copy
|
|
# the hash from the one in disk6, and the one in disk2
|
|
# will copy the hash from the one in disk1, that
|
|
# doesn't have parity
|
|
cp -a bench/disk6/STEP1 bench/disk1/STEP1
|
|
cp -a bench/disk6/STEP1 bench/disk2/STEP1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
# Now create, duplicate, move and partial sync
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/INVA1
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/INVA2
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/INVA3
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/MOVE1
|
|
cp -a bench/disk1/MOVE1 bench/disk1/MOVE2
|
|
cp -a bench/disk1/MOVE1 bench/disk1/MOVE3
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
mv bench/disk1/MOVE2 bench/disk2/MOVE2
|
|
mv bench/disk1/MOVE3 bench/disk3/MOVE3
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk4/MOVE4
|
|
cp -a bench/disk1/INVA1 bench/disk1/EXTRA1
|
|
cp -a bench/disk1/INVA2 bench/disk1/EXTRA2
|
|
cp -a bench/disk1/INVA3 bench/disk1/EXTRA3
|
|
rm bench/disk1/INVA1
|
|
touch bench/disk1/INVA2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
|
|
# Diff should report the need of a sync for invalid parity
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) --test-expect-need-sync diff
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
mv bench/disk2/MOVE2 bench/disk4/MOVE4
|
|
mv bench/disk3/MOVE3 bench/disk5/MOVE5
|
|
mv bench/disk4/MOVE4 bench/disk6/MOVE6
|
|
rm bench/disk1/EXTRA1
|
|
touch bench/disk1/EXTRA2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -E sync
|
|
# Change UUID
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-fake-uuid sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### NOT EMPTY ####
|
|
$(MSG) Create some files
|
|
$(TESTENV) ./mktest$(EXEEXT) generate 1 disk 6 $(CHECKCOUNT) $(CHECKSIZE)
|
|
echo DUP > bench/disk1/DUP1
|
|
echo DUP > bench/disk1/DUP2
|
|
echo -n > bench/disk1/ZERO
|
|
$(MSG) Some commands with a not empty array
|
|
# Run a sync using directory order
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_DIR) -c $(CONF) --test-expect-need-sync diff > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_DIR) -c $(CONF) sync
|
|
# Now reset the array, as we normally test with alpha order and murmur3
|
|
rm bench/content bench/?-content
|
|
# Now rebuild the array with alpha order and murmur3 and do some commands
|
|
# Later we will convert it to spooky2 to test both hashes
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-murmur3 --test-force-autosave-at 100 sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) dup -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) list -l test.log > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) test-rewrite
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) read
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status -l test.log
|
|
if HAVE_POSIX
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) pool
|
|
endif # HAVE_POSIX
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -a check
|
|
$(MSG) Dry
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) test-dry
|
|
# Thermal test
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(THERMAL) --test-fake-device test-dry
|
|
$(MSG) Copy detection
|
|
# Create a file and sync with it
|
|
echo 123 > bench/disk1/COPY
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
# Corrupt and move it to another disk
|
|
$(TESTENV) ./mktest$(EXEEXT) damage 1 1 1 bench/disk1/COPY
|
|
mv bench/disk1/COPY bench/disk2/COPY
|
|
# Now sync with failure as the data won't match. We have two points of failure, pre-hash and sync
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-expect-failure -h sync
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-expect-failure sync
|
|
# Now sync with force-nocopy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-nocopy sync
|
|
$(MSG) Nano
|
|
touch -t 200102011234.56 bench/disk1/a/a*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) touch
|
|
$(MSG) Check the --gen-conf command
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --gen-conf bench/content
|
|
$(MSG) Filter
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) -d disk1 check > output.log
|
|
if HAVE_POSIX
|
|
# Only in real unix, as with MingW the * trigger path replacement
|
|
# Like /b/a* -> B:/a* and SnapRAID then complain
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) -f \\*a -f a/ -f /b/a\\* check > output.log
|
|
endif # HAVE_POSIX
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-failure -f . check > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-failure -f ./ check > output.log
|
|
$(MSG) Delete some files and sync
|
|
rm bench/disk4/a/9*
|
|
rm bench/disk5/a/9*
|
|
rm bench/disk6/a/9*
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) sync -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Move some files, sync and check
|
|
mv bench/disk1/a/9* bench/disk4/a
|
|
mv bench/disk2/a/9* bench/disk5/a
|
|
mv bench/disk3/a/9* bench/disk6/a
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(CONF) --test-expect-need-sync diff > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
#### MORE FILES ####
|
|
$(MSG) Create some more files, hardlinks and empty directories, delete others, sync PAR1 and check
|
|
rm bench/disk4/a/8*
|
|
rm bench/disk5/a/8*
|
|
rm bench/disk6/a/8*
|
|
$(TESTENV) ./mktest$(EXEEXT) generate 2 disk 6 $(CHECKCOUNT) $(CHECKSIZE)
|
|
mkdir bench/disk1/empty1
|
|
mkdir bench/disk2/empty2
|
|
mkdir bench/disk3/empty3a
|
|
mkdir bench/disk3/empty3a/emptyinner
|
|
mkdir bench/disk3/empty3b
|
|
echo TARGET1 > bench/disk1/target1
|
|
ln bench/disk1/target1 bench/disk1/file_hardlink1
|
|
ln bench/disk1/target1 bench/disk1/file_hardlink2
|
|
ln bench/disk1/target1 bench/disk1/file_hardlink3
|
|
# CHECKFLAGS forces alpha order, so the modified main file is scanned before its hardlink
|
|
echo ORIGINAL > bench/disk1/a-hardlink-main
|
|
ln bench/disk1/a-hardlink-main bench/disk1/b-hardlink-link
|
|
if HAVE_POSIX
|
|
ln -s bench/disk1/target1 bench/disk1/file_symlink1
|
|
ln -s bench/disk1/target1 bench/disk1/file_symlink2
|
|
ln -s bench/disk1/target1 bench/disk1/file_symlink3
|
|
endif # HAVE_POSIX
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) --test-expect-need-sync diff > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-skip-fallocate -c $(PAR1) sync
|
|
$(MSG) Modified hardlink scan and recovery
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) --gui-verbose -c $(PAR1) list -l test.log > output.log
|
|
grep -q '^file:disk1:a-hardlink-main:' test.log
|
|
grep -q '^link_hardlink:disk1:b-hardlink-link:a-hardlink-main$$' test.log
|
|
! grep -q '^file:disk1:b-hardlink-link:' test.log
|
|
echo MODIFIED-CONTENT-WITH-DIFFERENT-SIZE > bench/hardlink-expected
|
|
echo MODIFIED-CONTENT-WITH-DIFFERENT-SIZE > bench/disk1/a-hardlink-main
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) --gui-verbose -c $(PAR1) list -l test.log > output.log
|
|
grep -q '^file:disk1:a-hardlink-main:' test.log
|
|
grep -q '^link_hardlink:disk1:b-hardlink-link:a-hardlink-main$$' test.log
|
|
! grep -q '^file:disk1:b-hardlink-link:' test.log
|
|
$(MSG) Missing hardlink recovery preserves its present target
|
|
rm bench/disk1/b-hardlink-link
|
|
echo NEWER-UNSYNCED-CONTENT-WITH-DIFFERENT-SIZE > bench/hardlink-missing-expected
|
|
cp bench/hardlink-missing-expected bench/disk1/a-hardlink-main
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) -m fix -l test.log
|
|
cmp bench/hardlink-missing-expected bench/disk1/a-hardlink-main
|
|
cmp bench/hardlink-missing-expected bench/disk1/b-hardlink-link
|
|
if HAVE_POSIX
|
|
test bench/disk1/a-hardlink-main -ef bench/disk1/b-hardlink-link
|
|
endif # HAVE_POSIX
|
|
rm bench/hardlink-missing-expected
|
|
rm bench/disk1/a-hardlink-main bench/disk1/b-hardlink-link
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
|
|
test -f bench/disk1/a-hardlink-main
|
|
test -f bench/disk1/b-hardlink-link
|
|
cmp bench/hardlink-expected bench/disk1/a-hardlink-main
|
|
cmp bench/hardlink-expected bench/disk1/b-hardlink-link
|
|
if HAVE_POSIX
|
|
test bench/disk1/a-hardlink-main -ef bench/disk1/b-hardlink-link
|
|
endif # HAVE_POSIX
|
|
rm bench/hardlink-expected bench/disk1/a-hardlink-main bench/disk1/b-hardlink-link
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-none -c $(PAR1) sync -F --test-io-cache 1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-sequential -c $(PAR1) sync -F --test-io-stats
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-flush -c $(PAR1) sync -F --test-io-cache 1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-flush-window -c $(PAR1) sync -F
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-discard-window -c $(PAR1) sync -F
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-io-advise-direct -c $(PAR1) sync -F
|
|
#### CHANGE LINKS ####
|
|
# Use a different size ("22" instead of "1") to ensure to recognize the file different
|
|
# even if it gets the same timestamp in case subsecond timestamp is no available
|
|
echo TARGET22 > bench/disk1/target2
|
|
rm bench/disk1/file_hardlink1
|
|
ln bench/disk1/target2 bench/disk1/file_hardlink1
|
|
if HAVE_POSIX
|
|
rm bench/disk1/file_symlink1
|
|
ln -s bench/disk1/target2 bench/disk1/file_symlink1
|
|
endif # HAVE_POSIX
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) --test-expect-need-sync diff > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) sync -l ">&1"
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) check -l ">&1"
|
|
#### MISC COMMANDS ####
|
|
$(MSG) Some commands with a not empty array
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) dup
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt file > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt disk > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) list --test-fmt path > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) locate --test-fmt file > output.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) -c $(PAR1) locate -t 10K --test-fmt path > output.log
|
|
if HAVE_POSIX
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) pool
|
|
endif # HAVE_POSIX
|
|
$(MSG) Extend PAR1 to max parity with fix and check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(CONF) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -d 2-parity -d 3-parity -d 4-parity -d 5-parity -d 6-parity -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check -l ">&1"
|
|
$(MSG) Fix with unaccessible parity and disk
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(NOACCESS) fix --test-expect-failure
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(NOACCESS) fix --force-device --test-expect-recoverable -l test.log
|
|
$(MSG) Rename a disk
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(RENAME) --test-match-first-uuid sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-match-first-uuid sync
|
|
#### SCRUB ####
|
|
$(MSG) Scrub some times
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 100 scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 1000 scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-at 100000 scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
#### SYNC WITH RUNTIME CHANGE ####
|
|
$(MSG) Modify files during a sync
|
|
echo RUN > bench/disk1/RUN-RM
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "rm bench/disk1/RUN-RM" --test-expect-failure sync
|
|
echo RUN > bench/disk1/RUN-CHMOD
|
|
if HAVE_POSIX
|
|
# Doesn't run this test as root because the root user override permissions
|
|
if test "$$EUID" -ne 0; then \
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "chmod a-r bench/disk1/RUN-CHMOD" --test-expect-failure sync; \
|
|
fi
|
|
endif # HAVE_POSIX
|
|
echo RUN > bench/disk1/RUN-SIZE
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "echo RUNRUN > bench/disk1/RUN-SIZE" --test-expect-failure sync
|
|
echo RUN > bench/disk1/RUN-TOUCH
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "touch -t 200001011200 bench/disk1/RUN-TOUCH" --test-expect-failure sync
|
|
echo RUN > bench/disk1/RUN-INODE
|
|
cp -p bench/disk1/RUN-INODE bench/disk1/RUN-INODE-COPY
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "mv bench/disk1/RUN-INODE-COPY bench/disk1/RUN-INODE" --test-expect-failure sync
|
|
rm bench/disk1/RUN-CHMOD
|
|
rm bench/disk1/RUN-SIZE
|
|
rm bench/disk1/RUN-TOUCH
|
|
rm bench/disk1/RUN-INODE
|
|
echo HASH > bench/disk1/HASH-RM
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "rm bench/disk1/HASH-RM" --test-expect-failure -h sync
|
|
echo HASH > bench/disk1/HASH-CHMOD
|
|
if HAVE_POSIX
|
|
# Doesn't run this test as root because the root user override permissions
|
|
if test "$$EUID" -ne 0; then \
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "chmod a-r bench/disk1/HASH-CHMOD" --test-expect-failure -h sync; \
|
|
fi
|
|
endif # HAVE_POSIX
|
|
echo HASH > bench/disk1/HASH-SIZE
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "echo HASHHASH > bench/disk1/HASH-SIZE" --test-expect-failure -h sync
|
|
echo HASH > bench/disk1/HASH-TOUCH
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "touch -t 200001011200 bench/disk1/HASH-TOUCH" --test-expect-failure -h sync
|
|
echo HASH > bench/disk1/HASH-INODE
|
|
cp -p bench/disk1/HASH-INODE bench/disk1/HASH-INODE-COPY
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-run "mv bench/disk1/HASH-INODE-COPY bench/disk1/HASH-INODE" --test-expect-failure -h sync
|
|
rm bench/disk1/HASH-CHMOD
|
|
rm bench/disk1/HASH-SIZE
|
|
rm bench/disk1/HASH-TOUCH
|
|
rm bench/disk1/HASH-INODE
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### SILENT ERRORS ####
|
|
$(MSG) Silently corrupt some files, scrub and fix filtering for error. Test scrub patterns.
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) ./mktest$(EXEEXT) damage 1 1 1 bench/disk1/a/*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-expect-recoverable -p full scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -e
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --percentage bad scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --plan 1.5 scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -o 0 scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -p full scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -p new scrub
|
|
$(MSG) Silently corrupt some files, and sync with error presents
|
|
$(TESTENV) ./mktest$(EXEEXT) write 2 1 1 bench/disk1/a/*
|
|
$(TESTENV) ./mktest$(EXEEXT) damage 3 1 1 bench/disk2/a/*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-expect-recoverable sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
# Note that this fix -e command doesn't fix all the errors because
|
|
# only the blocks touched by the sync are marked bad
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -e
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check --test-expect-recoverable
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -p full scrub
|
|
$(MSG) Full sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -F sync
|
|
$(MSG) Realloc partial/full sync
|
|
# Full realloc to compact the parity
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-realloc sync
|
|
cat bench/parity.* > bench/saved-parity-before
|
|
# Create a big file
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/REALLOC1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
cat bench/parity.* > bench/saved-parity-first-file
|
|
# Create another big file
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/REALLOC2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
cat bench/parity.* > bench/saved-parity-second-file
|
|
# Now remove the first one creating a hole
|
|
rm bench/disk1/REALLOC1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
|
|
cat bench/parity.* > bench/saved-parity-hole
|
|
# Reallocate the second file
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-realloc-tail 10k sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
|
|
cat bench/parity.* > bench/saved-parity-remove-hole
|
|
# Remove also the second file
|
|
rm bench/disk1/REALLOC2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --tail 10k locate
|
|
cat bench/parity.* > bench/saved-parity-after
|
|
# Adding files should grow the parity
|
|
@ [ $$(wc -c < bench/saved-parity-before) -lt $$(wc -c < bench/saved-parity-first-file) ] || exit 1
|
|
@ [ $$(wc -c < bench/saved-parity-first-file) -lt $$(wc -c < bench/saved-parity-second-file) ] || exit 1
|
|
# Creating the hold should not change parity size
|
|
@ [ $$(wc -c < bench/saved-parity-second-file) -eq $$(wc -c < bench/saved-parity-hole) ] || exit 1
|
|
# Removing the hole should return to the first file size
|
|
@ [ $$(wc -c < bench/saved-parity-first-file) -eq $$(wc -c < bench/saved-parity-remove-hole) ] || exit 1
|
|
# Removing both files should return to initial parity size
|
|
@ [ $$(wc -c < bench/saved-parity-before) -eq $$(wc -c < bench/saved-parity-after) ] || exit 1
|
|
#### SYNC PARTIAL ####
|
|
$(MSG) Abort sync with additions. Delete some of them, and add others and sync again.
|
|
$(MSG) This triggers files reallocation inside parity
|
|
mkdir bench/disk1/c
|
|
mkdir bench/disk1/d
|
|
mkdir bench/disk1/e
|
|
cp -pR bench/disk2/a/c* bench/disk1/c
|
|
cp -pR bench/disk2/a/d* bench/disk1/d
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
|
|
rm -r bench/disk1/c
|
|
cp -pR bench/disk2/a/e* bench/disk1/e
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Abort sync with both deletions and additions. And delete and add some more and sync again.
|
|
# Note that here we are depending of the previous state leaving dirs "d" and "e"
|
|
mkdir bench/disk1/f
|
|
cp -pR bench/disk3/a/f* bench/disk1/f
|
|
rm -r bench/disk1/d
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
|
|
mkdir bench/disk1/g
|
|
cp -pR bench/disk4/a/g* bench/disk1/g
|
|
rm -r bench/disk1/e
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
rm -r bench/disk1/f
|
|
rm -r bench/disk1/g
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Make a hole in the disk array and sync with --force-empty
|
|
mv bench/disk2 bench/disk2.old
|
|
mkdir bench/disk2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-empty sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Use with the hole
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) check
|
|
rm -r bench/disk1/a
|
|
rm -r bench/disk3/a
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(HOLE) test-dry
|
|
$(MSG) Fill the hole with a new disk
|
|
rm -r bench/disk2
|
|
mv bench/disk2.old bench/disk2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Corrupt the content file
|
|
$(TESTENV) ./mktest$(EXEEXT) write 1 100 100 bench/content
|
|
$(FAILENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-failure -c $(CONF) sync
|
|
rm bench/content
|
|
#### AGAIN MORE FILES ####
|
|
$(MSG) Delete some files, create some new, sync and check
|
|
rm bench/disk1/a/1*
|
|
rm bench/disk2/a/2*
|
|
rm bench/disk3/a/3*
|
|
rm bench/disk4/a/4*
|
|
$(TESTENV) ./mktest$(EXEEXT) generate 3 disk 6 $(CHECKCOUNT) $(CHECKSIZE)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Move some files, sync and check
|
|
mv bench/disk1/a/7* bench/disk1/b/
|
|
mv bench/disk2/a/7* bench/disk2/b/
|
|
mv bench/disk3/a/7* bench/disk3/b/
|
|
mv bench/disk4/a/7* bench/disk4/b/
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
#### SNAPRAIDIGNORE
|
|
echo "a*" > bench/disk1/a/.snapraidignore
|
|
echo "b*" > bench/disk1/.snapraidignore
|
|
echo "c/" > bench/disk1/.snapraidignore
|
|
echo "/d/" > bench/disk1/.snapraidignore
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
if !HAVE_MEMORY_CHECKER
|
|
#### RECOVER 1 ####
|
|
$(MSG) Delete one disk, fix and check with PAR1
|
|
rm -r bench/disk3
|
|
mkdir bench/disk3
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### RECOVER 2 ####
|
|
$(MSG) Delete two disks, fix and check with PAR2
|
|
rm -r bench/disk1
|
|
mkdir bench/disk1
|
|
rm -r bench/disk2
|
|
mkdir bench/disk2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-strategy1.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### RECOVER 3 ####
|
|
$(MSG) Delete three disks, fix and check with PAR3
|
|
rm -r bench/disk1
|
|
mkdir bench/disk1
|
|
rm -r bench/disk2
|
|
mkdir bench/disk2
|
|
rm -r bench/disk3
|
|
mkdir bench/disk3
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR2) fix -l test-fail-strategy2.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR3) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR3) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### RECOVER Z ####
|
|
$(MSG) Compute PARZ - keeping PAR1 and PAR2 as they are
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PARZ) fix -d 3-parity -l test.log
|
|
$(MSG) Delete three disks, fix and check with PARZ
|
|
rm -r bench/disk3
|
|
mkdir bench/disk3
|
|
rm -r bench/disk4
|
|
mkdir bench/disk4
|
|
rm -r bench/disk5
|
|
mkdir bench/disk5
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PARZ) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PARZ) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### RECOVER 4 ####
|
|
$(MSG) Delete four disks, fix and check with PAR4
|
|
rm -r bench/disk3
|
|
mkdir bench/disk3
|
|
rm -r bench/disk4
|
|
mkdir bench/disk4
|
|
rm -r bench/disk5
|
|
mkdir bench/disk5
|
|
rm -r bench/disk6
|
|
mkdir bench/disk6
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR3) fix -l test-fail-strategy3.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR4) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR4) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### RECOVER 5 ####
|
|
$(MSG) Delete five disks, fix and check with PAR5
|
|
rm -r bench/disk1
|
|
mkdir bench/disk1
|
|
rm -r bench/disk2
|
|
mkdir bench/disk2
|
|
rm -r bench/disk3
|
|
mkdir bench/disk3
|
|
rm -r bench/disk5
|
|
mkdir bench/disk5
|
|
rm -r bench/disk6
|
|
mkdir bench/disk6
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR4) fix -l test-fail-strategy4.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR5) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR5) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### RECOVER 6 ####
|
|
$(MSG) Delete six disks, fix and check with PAR6
|
|
rm -r bench/disk1
|
|
mkdir bench/disk1
|
|
rm -r bench/disk2
|
|
mkdir bench/disk2
|
|
rm -r bench/disk3
|
|
mkdir bench/disk3
|
|
rm -r bench/disk4
|
|
mkdir bench/disk4
|
|
rm -r bench/disk5
|
|
mkdir bench/disk5
|
|
rm -r bench/disk6
|
|
mkdir bench/disk6
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR5) fix -l test-fail-strategy5.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR6) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR6) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
endif # !HAVE_MEMORY_CHECKER
|
|
#### MULTI STEP ####
|
|
$(MSG) Delete some files and create some new, sync and check in multiple steps
|
|
rm bench/disk1/a/4*
|
|
rm bench/disk2/a/5*
|
|
rm bench/disk3/a/6*
|
|
rm bench/disk4/a/6*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -B 10 sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check -l test.log
|
|
$(TESTENV) ./mktest$(EXEEXT) generate 4 disk 6 $(CHECKCOUNT) $(CHECKSIZE)
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -B 100 sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -B 1000 sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Rehash to spooky2 and rehash even blocks
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-spooky2 rehash
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-force-scrub-even scrub
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Full sync to complete rehash
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -F sync
|
|
$(MSG) Delete files from three disks and check/fix with import by data in PAR2
|
|
rm -r bench/disk1/a
|
|
rm -r bench/disk2/a
|
|
mv bench/disk3/a bench/a
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-import-content bench/a -c $(PAR2) fix -l test.log
|
|
rm -r bench/a
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Delete files from three disks and check/fix with import by timestamp in PAR2
|
|
rm -r bench/disk1/a
|
|
rm -r bench/disk2/a
|
|
mv bench/disk3/a bench/a
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -i bench/a -c $(PAR2) fix -l test.log
|
|
rm -r bench/a
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Delete files from three disks and check/fix with automatic import in PAR2
|
|
rm -r bench/disk1/a
|
|
rm -r bench/disk2/a
|
|
mv bench/disk3/a bench/disk1/a_from_disk3
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
rm -r bench/disk1/a_from_disk3
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### SYNC ABORT ####
|
|
$(MSG) Abort sync late with additions, delete them and recover with PAR2
|
|
$(MSG) This triggers the recovering with q using p to check the validity
|
|
cp -pR bench/disk1/a bench/disk1/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) sync
|
|
rm -r bench/disk1/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
rm -r bench/disk1/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Abort sync early with additions, delete them and recover with PAR2
|
|
$(MSG) This triggers the recovering with q using p to check the validity, but failing for new blocks being filled with zero
|
|
cp -pR bench/disk1/a bench/disk1/a_copy
|
|
# Ensure that there is at least one zero filled file
|
|
dd bs=1 count=8192 if=/dev/zero of=bench/disk1/a_copy/ZERO_FILLED
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -B 1 --test-kill-after-sync -c $(CONF) sync
|
|
rm -r bench/disk1/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR2) fix -l test-fail-earlysyncadd.log
|
|
rm -r bench/disk1/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Abort sync late with additions with prehash and then delete the new additions and sync again
|
|
cp -pR bench/disk1/a bench/disk1/a_copy
|
|
cp -pR bench/disk2/a bench/disk2/a_copy
|
|
cp -pR bench/disk3/a bench/disk3/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) -h sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
rm -r bench/disk1/a_copy
|
|
rm -r bench/disk2/a_copy
|
|
rm -r bench/disk3/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Abort sync late with additions and then delete the new additions and sync again
|
|
cp -pR bench/disk1/a bench/disk1/a_copy
|
|
cp -pR bench/disk2/a bench/disk2/a_copy
|
|
cp -pR bench/disk3/a bench/disk3/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-kill-after-sync -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
rm -r bench/disk1/a_copy
|
|
rm -r bench/disk2/a_copy
|
|
rm -r bench/disk3/a_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Abort sync late with additions and then delete some unchanged stuff and fix with PAR1
|
|
cp -pR bench/disk1/b bench/disk1/b_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) --test-kill-after-sync sync
|
|
rm -r bench/disk2
|
|
mkdir bench/disk2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
|
|
$(MSG) Fixes again to restore all the parity
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -l test.log
|
|
rm -r bench/disk1/b_copy
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Abort sync late with more deletions than additions and then delete some unchanged stuff and fix with PAR1
|
|
cp -pR bench/disk1/a bench/disk1/a_copy
|
|
mv bench/disk1/a bench/a
|
|
mv bench/disk1/b bench/b
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-sync sync
|
|
rm -r bench/disk2
|
|
mkdir bench/disk2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
|
|
$(MSG) Fixes again to restore all the parity
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) fix -l test.log
|
|
-rm -r bench/disk1/a
|
|
-rm -r bench/disk1/b
|
|
rm -r bench/disk1/a_copy
|
|
mv bench/a bench/disk1/a
|
|
mv bench/b bench/disk1/b
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Abort sync early with more deletions than additions and then delete some unchanged stuff and fix with PAR2
|
|
cp -pR bench/disk1/a bench/disk1/a_copy
|
|
mv bench/disk1/a bench/a
|
|
mv bench/disk1/b bench/b
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -B 1 --test-kill-after-sync sync
|
|
rm -r bench/disk2
|
|
mkdir bench/disk2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-earlysyncdel.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
-rm -r bench/disk1/a
|
|
-rm -r bench/disk1/b
|
|
rm -r bench/disk1/a_copy
|
|
mv bench/a bench/disk1/a
|
|
mv bench/b bench/disk1/b
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
#### FORCE-FULL REBUILD TESTS ####
|
|
$(MSG) Test interrupted force-full with complete parity
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) list > bench/mapping_before.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-full --test-kill-before-sync sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) list > bench/mapping_rebuild.txt
|
|
diff bench/mapping_before.txt bench/mapping_rebuild.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) list > bench/mapping_after.txt
|
|
diff bench/mapping_before.txt bench/mapping_after.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Test interrupted force-full with physically truncated parity
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) list > bench/mapping_trunc_before.txt
|
|
@ orig_size=$$(wc -c < bench/parity.0) && truncate -s $$(( orig_size / 2 )) bench/parity.0
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-full --test-kill-before-sync sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) list > bench/mapping_trunc_after.txt
|
|
diff bench/mapping_trunc_before.txt bench/mapping_trunc_after.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Test check and status on interrupted REBUILD state
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-full --test-kill-before-sync sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) status
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Test explicit force-realloc after REBUILD
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --force-full --test-kill-before-sync sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -R sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
#### RECOVER MISSING ####
|
|
$(MSG) Delete some files, fix with -m and check with PAR1
|
|
rm bench/disk1/a/8*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) -m fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Delete some dirs in six disk, fix with -m and check
|
|
rm -r bench/disk1/b
|
|
rm -r bench/disk2/b
|
|
rm -r bench/disk3/b
|
|
rm -r bench/disk4/b
|
|
rm -r bench/disk5/b
|
|
rm -r bench/disk6/b
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR5) fix -l test-full5.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(CONF) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -m fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
#### RECOVER BY DISK ####
|
|
$(MSG) Delete some dirs in two disks, fix and check with PAR2 using the -d option for each disk
|
|
rm -r bench/disk2/b
|
|
rm -r bench/disk5/b
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-full1.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) -d disk2 fix -l test-part1.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) -d disk5 fix -l test-part2.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
#### RECOVER PARITY ####
|
|
$(MSG) Delete the parity, fix and check with PAR1
|
|
rm bench/parity*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Delete the parity and the 2-parity, fix and check with PAR2
|
|
rm bench/parity*
|
|
rm bench/2-parity*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Delete the parity and a disk, fix and check with PAR2
|
|
rm bench/parity*
|
|
rm -r bench/disk2/b
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Delete the 2-parity and a disk, fix and check with PAR2
|
|
rm bench/2-parity*
|
|
rm -r bench/disk3/a
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Corrupt the parity, fix and check with PAR1
|
|
$(TESTENV) ./mktest$(EXEEXT) write 1 100 10000 bench/parity*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) -a check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Corrupt the parity and the 2-parity, fix and check with PAR2
|
|
$(TESTENV) ./mktest$(EXEEXT) write 2 100 10000 bench/parity*
|
|
$(TESTENV) ./mktest$(EXEEXT) write 2 100 10000 bench/2-parity*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -a check
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
#### RECOVER FILES AND PARITY ####
|
|
$(MSG) Corrupt some files, fix and check with PAR1
|
|
$(TESTENV) ./mktest$(EXEEXT) change 3 500 bench/disk2/b/*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) -a check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR1) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Corrupt some files, fix and check with PAR2 in verbose mode
|
|
$(TESTENV) ./mktest$(EXEEXT) change 4 500 bench/disk2/b/*
|
|
$(TESTENV) ./mktest$(EXEEXT) change 4 500 bench/disk3/b/*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) --test-expect-unrecoverable -c $(PAR1) check -l test.log > /dev/null
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS_VERBOSE) --test-expect-unrecoverable -c $(PAR1) fix -l test-fail-corrupt-verbose.log > /dev/null
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) -a check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Corrupt some files, fix and check with PAR2
|
|
$(TESTENV) ./mktest$(EXEEXT) change 5 500 bench/disk2/b/*
|
|
$(TESTENV) ./mktest$(EXEEXT) change 5 500 bench/disk3/b/*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-fail-corrupt-data.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Corrupt the parity and some files, fix and check with PAR2
|
|
$(TESTENV) ./mktest$(EXEEXT) write 6 100 10000 bench/parity*
|
|
$(TESTENV) ./mktest$(EXEEXT) change 6 500 bench/disk1/a/*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-unrecoverable -c $(PAR1) check -l test-fail-corrupt-parity.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Corrupt the 2-parity and some files, fix and check with PAR2
|
|
$(TESTENV) ./mktest$(EXEEXT) write 7 100 10000 bench/2-parity*
|
|
$(TESTENV) ./mktest$(EXEEXT) change 7 500 bench/disk1/a/*
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR1) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) --test-expect-recoverable -c $(PAR2) check -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(PAR2) fix -l test.log
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
$(MSG) Sync after all the fixes
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
rm -rf bench/realloc-level
|
|
mkdir -p bench/realloc-level/disk1
|
|
mkdir -p bench/realloc-level/disk2
|
|
mkdir -p bench/realloc-level/disk3
|
|
mkdir -p bench/realloc-level/disk4
|
|
mkdir -p bench/realloc-level/disk5
|
|
mkdir -p bench/realloc-level/disk6
|
|
dd bs=1024 count=2048 if=/dev/urandom of=bench/realloc-level/disk1/data
|
|
#### NEW PARITY CONFIGURATION CRASH TESTS ####
|
|
$(MSG) Test interrupted force-realloc after adding a parity level
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL1) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) -R --test-kill-after-resize sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) locate > /dev/null
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) check
|
|
rm -rf bench/realloc-split
|
|
mkdir -p bench/realloc-split/disk1
|
|
mkdir -p bench/realloc-split/disk2
|
|
mkdir -p bench/realloc-split/disk3
|
|
mkdir -p bench/realloc-split/disk4
|
|
mkdir -p bench/realloc-split/disk5
|
|
mkdir -p bench/realloc-split/disk6
|
|
dd bs=1024 count=2048 if=/dev/urandom of=bench/realloc-split/disk1/data1
|
|
$(MSG) Test interrupted force-realloc after adding a parity split
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT1) sync
|
|
dd bs=1024 count=2048 if=/dev/urandom of=bench/realloc-split/disk1/data2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT2) -R --test-kill-after-resize sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT2) locate > /dev/null
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT2) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT2) check
|
|
$(MSG) Test adding a parity level after an interrupted normal shrink
|
|
rm -rf bench/realloc-level
|
|
mkdir -p bench/realloc-level/disk1
|
|
mkdir -p bench/realloc-level/disk2
|
|
mkdir -p bench/realloc-level/disk3
|
|
mkdir -p bench/realloc-level/disk4
|
|
mkdir -p bench/realloc-level/disk5
|
|
mkdir -p bench/realloc-level/disk6
|
|
dd bs=1024 count=1 if=/dev/urandom of=bench/realloc-level/disk1/data
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL1) sync
|
|
dd bs=1024 count=1 if=/dev/urandom of=bench/realloc-level/disk1/tail
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL1) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) -d 2-parity fix
|
|
rm bench/realloc-level/disk1/tail
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL1) --test-kill-after-resize sync
|
|
cp bench/realloc-level/content bench/realloc-level/content.checkpoint
|
|
$(MSG) Accept the new level initialized at the old logical size
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) check
|
|
cp bench/realloc-level/content.checkpoint bench/realloc-level/content
|
|
$(MSG) Accept the new level initialized at the checkpoint allocation
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) -d 2-parity fix
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) check
|
|
cp bench/realloc-level/content.checkpoint bench/realloc-level/content
|
|
$(MSG) Accept the checkpoint allocation after adding files since fix
|
|
dd bs=1024 count=2 if=/dev/urandom of=bench/realloc-level/disk1/growth
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) check
|
|
$(MSG) Test fix leaving pending parity shorter than the checkpoint allocation
|
|
cp -p bench/realloc-level/disk1/data bench/realloc-level/disk2/data
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) sync
|
|
cp -p bench/realloc-level/disk1/growth bench/realloc-level/disk1/tail
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL1) --test-kill-after-sync sync
|
|
rm bench/realloc-level/disk2/data
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL1) fix
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) fix
|
|
cp bench/realloc-level/content bench/realloc-level/content.checkpoint
|
|
$(MSG) Resume after removing the pending additions
|
|
mv bench/realloc-level/disk1/tail bench/realloc-level/tail
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) check
|
|
$(MSG) Resume with the pending additions still allocated
|
|
mv bench/realloc-level/tail bench/realloc-level/disk1/tail
|
|
cp bench/realloc-level/content.checkpoint bench/realloc-level/content
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_LEVEL2) check
|
|
$(MSG) Test interrupted normal shrink after adding a parity split
|
|
rm -rf bench/realloc-split
|
|
mkdir -p bench/realloc-split/disk1
|
|
mkdir -p bench/realloc-split/disk2
|
|
mkdir -p bench/realloc-split/disk3
|
|
mkdir -p bench/realloc-split/disk4
|
|
mkdir -p bench/realloc-split/disk5
|
|
mkdir -p bench/realloc-split/disk6
|
|
dd bs=1024 count=2048 if=/dev/urandom of=bench/realloc-split/disk1/data
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT1) sync
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/realloc-split/disk1/NORMAL_SPLIT_SHRINK
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT1) sync
|
|
rm bench/realloc-split/disk1/NORMAL_SPLIT_SHRINK
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT2) --test-kill-after-resize sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT2) locate > /dev/null
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT2) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(REALLOC_SPLIT2) check
|
|
#### FORCE-REALLOC CRASH TESTS ####
|
|
$(MSG) Test interrupted force-realloc post-resize crash
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/REALLOC_CRASH1
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/REALLOC_CRASH2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
rm bench/disk1/REALLOC_CRASH1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/realloc_crash_before.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -R --test-kill-after-resize sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/realloc_crash_after.txt
|
|
! diff bench/realloc_crash_before.txt bench/realloc_crash_after.txt > /dev/null
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/realloc_crash_final.txt
|
|
diff bench/realloc_crash_after.txt bench/realloc_crash_final.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
rm bench/disk1/REALLOC_CRASH2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(MSG) Test interrupted force-realloc-tail post-resize crash
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/REALLOC_TAIL1
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/REALLOC_TAIL2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
rm bench/disk1/REALLOC_TAIL1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/realloc_tail_crash_before.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) -W 10M --test-kill-after-resize sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/realloc_tail_crash_after.txt
|
|
! diff bench/realloc_tail_crash_before.txt bench/realloc_tail_crash_after.txt > /dev/null
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/realloc_tail_crash_final.txt
|
|
diff bench/realloc_tail_crash_after.txt bench/realloc_tail_crash_final.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
rm bench/disk1/REALLOC_TAIL2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
#### NORMAL SHRINK CRASH TESTS ####
|
|
$(MSG) Test interrupted normal shrink post-resize crash
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/SHRINK_CRASH1
|
|
dd bs=1024 count=1024 if=/dev/urandom of=bench/disk1/SHRINK_CRASH2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/shrink_crash_before.txt
|
|
rm bench/disk1/SHRINK_CRASH2
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) --test-kill-after-resize sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/shrink_crash_after.txt
|
|
! diff bench/shrink_crash_before.txt bench/shrink_crash_after.txt > /dev/null
|
|
! grep SHRINK_CRASH2 bench/shrink_crash_after.txt > /dev/null
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) locate > bench/shrink_crash_final.txt
|
|
diff bench/shrink_crash_after.txt bench/shrink_crash_final.txt
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) check
|
|
rm bench/disk1/SHRINK_CRASH1
|
|
$(TESTENV) $(SNAPRAID) $(CHECKFLAGS) -c $(CONF) sync
|
|
endif # HAVE_THREAD_CHECKER
|
|
$(MSG) Regression test completed with SUCCESS!
|
|
$(MSG) Please ignore any error message printed above, they are expected!
|
|
$(MSG) Everything OK
|
|
|
|
# Manual testing
|
|
|
|
MANUAL = ./snapraid --test-skip-device -c test/test-par1.conf sync
|
|
|
|
run:
|
|
$(MANUAL)
|
|
|
|
valgrind:
|
|
valgrind \
|
|
--tool=memcheck \
|
|
--track-origins=yes \
|
|
--read-var-info=yes \
|
|
--leak-check=full \
|
|
-v $(MANUAL) \
|
|
2> valgrind.log
|
|
tail valgrind.log
|
|
|
|
callgrind:
|
|
valgrind \
|
|
--tool=callgrind \
|
|
--dump-instr=yes \
|
|
--trace-jump=yes \
|
|
--collect-systime=yes \
|
|
-v $(MANUAL) \
|
|
2> callgrind.log
|
|
tail callgrind.log
|
|
|
|
cachegrind:
|
|
valgrind \
|
|
--tool=cachegrind \
|
|
-v $(MANUAL) \
|
|
2> cachegrind.log
|
|
tail cachegrind.log
|
|
|
|
heaptrack:
|
|
/usr/local/heaptrack/bin/heaptrack $(MANUAL)
|
|
|
|
perf:
|
|
@trap 'perf report; exit 1' INT; perf record -g -- $(MANUAL)
|
|
|
|
perfstat:
|
|
perf stat -d -- $(MANUAL)
|
|
|
|
perfmem:
|
|
@trap 'perf mem report; exit 1' INT; perf mem record -- $(MANUAL)
|
|
|
|
lcov_reset:
|
|
lcov --directory . -z
|
|
rm -f ./lcov.info
|
|
|
|
lcov_capture:
|
|
lcov --directory . --capture -o lcov.info
|
|
|
|
lcov_html:
|
|
rm -rf ./cov
|
|
mkdir cov
|
|
genhtml -o ./cov lcov.info
|
|
|
|
# Rules for documentation
|
|
if HAVE_ADVD2
|
|
%.1 : %.d
|
|
advd2 man < $< > $@
|
|
|
|
%.txt : %.d
|
|
advd2 txt < $< | todos > $@
|
|
|
|
%.html : %.d
|
|
advd2 html < $< > $@
|
|
|
|
%.xml : %.d
|
|
advd2 xml < $< > $@
|
|
endif # HAVE_ADVD2
|
|
|
|
# Web distribution
|
|
|
|
web: $(LIST_XML)
|
|
|
|
# All docs
|
|
|
|
doc: $(LIST_MAN) $(LIST_TXT)
|
|
|
|
# Windows distribution
|
|
|
|
DISTWIN = \
|
|
$(LIST_TXT) \
|
|
snapraid.exe
|
|
|
|
distwindows-x86: $(DISTWIN)
|
|
rm -f $(PACKAGE)-$(VERSION)-windows-x86.zip
|
|
mkdir tmp
|
|
cp $(DISTWIN) tmp
|
|
cp $(srcdir)/support/smartctl.exe tmp/smartctl.exe
|
|
todos < $(srcdir)/snapraid.conf.example.windows > tmp/snapraid.conf.example
|
|
todos < $(srcdir)/README > tmp/readme.txt
|
|
todos < $(srcdir)/AUTHORS > tmp/authors.txt
|
|
todos < $(srcdir)/HISTORY > tmp/history.txt
|
|
todos < $(srcdir)/BLUEBOX > tmp/bluebox.txt
|
|
todos < $(srcdir)/LICENSES/GPL-3.0 > tmp/copying.txt
|
|
cd tmp && zip -r ../$(PACKAGE)-$(VERSION)-windows-x86.zip *
|
|
rm -r tmp
|
|
|
|
distwindows-x64: $(DISTWIN)
|
|
rm -f $(PACKAGE)-$(VERSION)-windows-x64.zip
|
|
mkdir tmp
|
|
cp $(DISTWIN) tmp
|
|
cp $(srcdir)/support/smartctl.exe tmp/smartctl.exe
|
|
todos < $(srcdir)/snapraid.conf.example.windows > tmp/snapraid.conf.example
|
|
todos < $(srcdir)/README > tmp/readme.txt
|
|
todos < $(srcdir)/AUTHORS > tmp/authors.txt
|
|
todos < $(srcdir)/HISTORY > tmp/history.txt
|
|
todos < $(srcdir)/BLUEBOX > tmp/bluebox.txt
|
|
todos < $(srcdir)/LICENSES/GPL-3.0 > tmp/copying.txt
|
|
cd tmp && zip -r ../$(PACKAGE)-$(VERSION)-windows-x64.zip *
|
|
rm -r tmp
|