]>
git.proxmox.com Git - mirror_zfs.git/blob - scripts/zimport.sh
3 # Verify that an assortment of known good reference pools can be imported
4 # using different versions of the ZoL code.
6 # By default references pools for the major ZFS implementation will be
7 # checked against the most recent ZoL tags and the master development branch.
8 # Alternate tags or branches may be verified with the '-s <src-tag> option.
9 # Passing the keyword "installed" will instruct the script to test whatever
10 # version is installed.
12 # Preferentially a reference pool is used for all tests. However, if one
13 # does not exist and the pool-tag matches one of the src-tags then a new
14 # reference pool will be created using binaries from that source build.
15 # This is particularly useful when you need to test your changes before
16 # opening a pull request. The keyword 'all' can be used as short hand
17 # refer to all available reference pools.
19 # New reference pools may be added by placing a bzip2 compressed tarball
20 # of the pool in the scripts/zfs-images directory and then passing
21 # the -p <pool-tag> option. To increase the test coverage reference pools
22 # should be collected for all the major ZFS implementations. Having these
23 # pools easily available is also helpful to the developers.
25 # Care should be taken to run these tests with a kernel supported by all
26 # the listed tags. Otherwise build failure will cause false positives.
31 # The following example will verify the zfs-0.6.2 tag, the master branch,
32 # and the installed zfs version can correctly import the listed pools.
33 # Note there is no reference pool available for master and installed but
34 # because binaries are available one is automatically constructed. The
35 # working directory is also preserved between runs (-k) preventing the
36 # need to rebuild from source for multiple runs.
38 # zimport.sh -k -f /var/tmp/zimport \
39 # -s "zfs-0.6.2 master installed" \
40 # -p "zevo-1.1.1 zol-0.6.2 zol-0.6.2-173 master installed"
42 # --------------------- ZFS on Linux Source Versions --------------
43 # zfs-0.6.2 master 0.6.2-175_g36eb554
44 # -----------------------------------------------------------------
45 # Clone SPL Local Local Skip
46 # Clone ZFS Local Local Skip
47 # Build SPL Pass Pass Skip
48 # Build ZFS Pass Pass Skip
49 # -----------------------------------------------------------------
50 # zevo-1.1.1 Pass Pass Pass
51 # zol-0.6.2 Pass Pass Pass
52 # zol-0.6.2-173 Fail Pass Pass
53 # master Pass Pass Pass
54 # installed Pass Pass Pass
56 basedir
="$(dirname $0)"
58 SCRIPT_COMMON
=common.sh
59 if [ -f "${basedir}/${SCRIPT_COMMON}" ]; then
60 .
"${basedir}/${SCRIPT_COMMON}"
62 echo "Missing helper script ${SCRIPT_COMMON}" && exit 1
67 SRC_TAGS
="zfs-0.6.1 zfs-0.6.2 master"
68 POOL_TAGS
="all master"
69 TEST_DIR
=`mktemp -u -d -p /var/tmp zimport.XXXXXXXX`
73 REPO
="https://github.com/zfsonlinux"
74 IMAGES_DIR
="$SCRIPTDIR/zfs-images/"
75 IMAGES_TAR
="https://github.com/zfsonlinux/zfs-images/tarball/master"
78 CONFIG_LOG
="configure.log"
79 CONFIG_OPTIONS
=${CONFIG_OPTIONS:-""}
81 MAKE_OPTIONS
=${MAKE_OPTIONS:-"-s -j$(nproc)"}
86 zimport.sh [hvl] [-r repo] [-s src-tag] [-i pool-dir] [-p pool-tag] [-f path]
89 ZPOOL import verification tests
95 -k Keep temporary directory
96 -r <repo> Source repository ($REPO)
97 -s <src-tag>... Verify ZoL versions with the listed tags
98 -i <pool-dir> Pool image directory
99 -p <pool-tag>... Verify pools created with the listed tags
100 -f <path> Temporary directory to use
105 while getopts 'hvckr:s:i:p:f:?' OPTION
; do
142 # Initialize the test suite
144 check_modules || die
"ZFS modules must be unloaded"
146 SRC_DIR
="$TEST_DIR/src"
147 SRC_DIR_SPL
="$SRC_DIR/spl"
148 SRC_DIR_ZFS
="$SRC_DIR/zfs"
150 if [ $COLOR -eq 0 ]; then
158 echo -n -e "${COLOR_GREEN}Pass${COLOR_RESET}\t\t"
162 echo -n -e "${COLOR_BROWN}Skip${COLOR_RESET}\t\t"
166 echo -n -e "${COLOR_RED}Fail${COLOR_RESET}\t\t"
170 # Set several helper variables which are derived from a source tag.
172 # SPL_TAG - The tag zfs-x.y.z is translated to spl-x.y.z.
173 # SPL_DIR - The spl directory name.
174 # SPL_URL - The spl github URL to fetch the tarball.
175 # ZFS_TAG - The passed zfs-x.y.z tag
176 # ZFS_DIR - The zfs directory name
177 # ZFS_URL - The zfs github URL to fetch the tarball
182 SPL_TAG
=`echo $TAG | sed -e 's/zfs/spl/'`
183 SPL_DIR
=$SRC_DIR_SPL/$SPL_TAG
184 SPL_URL
=$REPO/spl
/tarball
/$SPL_TAG
187 ZFS_DIR
=$SRC_DIR_ZFS/$ZFS_TAG
188 ZFS_URL
=$REPO/zfs
/tarball
/$ZFS_TAG
190 if [ "$TAG" = "installed" ]; then
191 ZPOOL_CMD
=`which zpool`
193 ZFS_SH
="/usr/share/zfs/zfs.sh"
194 ZPOOL_CREATE
="/usr/share/zfs/zpool-create.sh"
196 ZPOOL_CMD
="./cmd/zpool/zpool"
197 ZFS_CMD
="./cmd/zfs/zfs"
198 ZFS_SH
="./scripts/zfs.sh"
199 ZPOOL_CREATE
="./scripts/zpool-create.sh"
204 # Set several helper variables which are derived from a pool name such
205 # as zol-0.6.x, zevo-1.1.1, etc. These refer to example pools from various
206 # ZFS implementations which are used to verify compatibility.
208 # POOL_TAG - The example pools name in scripts/zfs-images/.
209 # POOL_BZIP - The full path to the example bzip2 compressed pool.
210 # POOL_DIR - The top level test path for this pool.
211 # POOL_DIR_PRISTINE - The directory containing a pristine version of the pool.
212 # POOL_DIR_COPY - The directory containing a working copy of the pool.
213 # POOL_DIR_SRC - Location of a source build if it exists for this pool.
219 POOL_BZIP
=$IMAGES_DIR/$POOL_TAG.
tar.bz2
220 POOL_DIR
=$TEST_DIR/pools
/$POOL_TAG
221 POOL_DIR_PRISTINE
=$POOL_DIR/pristine
222 POOL_DIR_COPY
=$POOL_DIR/copy
223 POOL_DIR_SRC
=`echo -n "$SRC_DIR_ZFS/"; \
224 echo "$POOL_TAG" | sed -e 's/zol/zfs/'`
228 # Construct a non-trivial pool given a specific version of the source. More
229 # interesting pools provide better test coverage so this function should
230 # extended as needed to create more realistic pools.
236 if [ "$POOL_TAG" != "installed" ]; then
240 $ZFS_SH zfs
="spa_config_path=$POOL_DIR_PRISTINE" || fail
1
242 # Create a file vdev RAIDZ pool.
243 FILEDIR
="$POOL_DIR_PRISTINE" $ZPOOL_CREATE \
244 -c file-raidz
-p $POOL_TAG -v -x >/dev
/null || fail
2
246 # Create a pool/fs filesystem with some random contents.
247 $ZFS_CMD create
$POOL_TAG/fs || fail
3
248 populate
/$POOL_TAG/fs
/ 10 100
250 # Snapshot that filesystem, clone it, remove the files/dirs,
251 # replace them with new files/dirs.
252 $ZFS_CMD snap
$POOL_TAG/fs@snap || fail
4
253 $ZFS_CMD clone
$POOL_TAG/fs@snap
$POOL_TAG/clone || fail
5
254 rm -Rf /$POOL_TAG/clone
/* || fail
6
255 populate
/$POOL_TAG/clone
/ 10 100
257 # Scrub the pool, delay slightly, then export it. It is now
258 # somewhat interesting for testing purposes.
259 $ZPOOL_CMD scrub
$POOL_TAG || fail
7
261 $ZPOOL_CMD export $POOL_TAG || fail
8
266 # If the zfs-images directory doesn't exist fetch a copy from Github then
267 # cache it in the $TEST_DIR and update $IMAGES_DIR.
268 if [ ! -d $IMAGES_DIR ]; then
269 IMAGES_DIR
="$TEST_DIR/zfs-images"
271 curl
-sL $IMAGES_TAR | \
272 tar -xz -C $IMAGES_DIR --strip-components=1 || fail
10
275 # Given the available images in the zfs-images directory substitute the
276 # list of available images for the reserved keywork 'all'.
277 for TAG
in $POOL_TAGS; do
279 if [ "$TAG" = "all" ]; then
280 ALL_TAGS
=`ls $IMAGES_DIR | grep "tar.bz2" | \
281 sed 's/.tar.bz2//' | tr '\n' ' '`
282 NEW_TAGS
="$NEW_TAGS $ALL_TAGS"
284 NEW_TAGS
="$NEW_TAGS $TAG"
287 POOL_TAGS
="$NEW_TAGS"
289 if [ $VERBOSE -ne 0 ]; then
290 echo "---------------------------- Options ----------------------------"
291 echo "VERBOSE=$VERBOSE"
294 echo "SRC_TAGS="$SRC_TAGS""
295 echo "POOL_TAGS="$POOL_TAGS""
296 echo "PATH=$TEST_DIR"
300 if [ ! -d $TEST_DIR ]; then
304 if [ ! -d $SRC_DIR ]; then
308 # Print a header for all tags which are being tested.
309 echo "--------------------- ZFS on Linux Source Versions --------------"
311 for TAG
in $SRC_TAGS; do
314 if [ "$TAG" = "installed" ]; then
315 ZFS_VERSION
=`modinfo zfs | awk '/version:/ { print $2; exit }'`
316 if [ -n "$ZFS_VERSION" ]; then
317 printf "%-16s" $ZFS_VERSION
319 echo "ZFS is not installed\n"
326 echo -e "\n-----------------------------------------------------------------"
329 # Attempt to generate the tarball from your local git repository, if that
330 # fails then attempt to download the tarball from Github.
332 printf "%-16s" "Clone SPL"
333 for TAG
in $SRC_TAGS; do
336 if [ -d $SPL_DIR ]; then
338 elif [ "$SPL_TAG" = "installed" ]; then
343 if [ ! -d $SRC_DIR_SPL ]; then
344 mkdir
-p $SRC_DIR_SPL
347 git archive
--format=tar --prefix=$SPL_TAG/ $SPL_TAG \
348 -o $SRC_DIR_SPL/$SPL_TAG.
tar &>/dev
/nul || \
349 rm $SRC_DIR_SPL/$SPL_TAG.
tar
350 if [ -s $SRC_DIR_SPL/$SPL_TAG.
tar ]; then
351 tar -xf $SRC_DIR_SPL/$SPL_TAG.
tar -C $SRC_DIR_SPL
352 rm $SRC_DIR_SPL/$SPL_TAG.
tar
353 echo -n -e "${COLOR_GREEN}Local${COLOR_RESET}\t\t"
355 mkdir
-p $SPL_DIR || fail
1
356 curl
-sL $SPL_URL |
tar -xz -C $SPL_DIR \
357 --strip-components=1 || fail
2
358 echo -n -e "${COLOR_GREEN}Remote${COLOR_RESET}\t\t"
365 # Attempt to generate the tarball from your local git repository, if that
366 # fails then attempt to download the tarball from Github.
368 printf "%-16s" "Clone ZFS"
369 for TAG
in $SRC_TAGS; do
372 if [ -d $ZFS_DIR ]; then
374 elif [ "$ZFS_TAG" = "installed" ]; then
379 if [ ! -d $SRC_DIR_ZFS ]; then
380 mkdir
-p $SRC_DIR_ZFS
383 git archive
--format=tar --prefix=$ZFS_TAG/ $ZFS_TAG \
384 -o $SRC_DIR_ZFS/$ZFS_TAG.
tar &>/dev
/nul || \
385 rm $SRC_DIR_ZFS/$ZFS_TAG.
tar
386 if [ -s $SRC_DIR_ZFS/$ZFS_TAG.
tar ]; then
387 tar -xf $SRC_DIR_ZFS/$ZFS_TAG.
tar -C $SRC_DIR_ZFS
388 rm $SRC_DIR_ZFS/$ZFS_TAG.
tar
389 echo -n -e "${COLOR_GREEN}Local${COLOR_RESET}\t\t"
391 mkdir
-p $ZFS_DIR || fail
1
392 curl
-sL $ZFS_URL |
tar -xz -C $ZFS_DIR \
393 --strip-components=1 || fail
2
394 echo -n -e "${COLOR_GREEN}Remote${COLOR_RESET}\t\t"
400 # Build the listed tags
401 printf "%-16s" "Build SPL"
402 for TAG
in $SRC_TAGS; do
405 if [ -f $SPL_DIR/module
/spl
/spl.ko
]; then
407 elif [ "$SPL_TAG" = "installed" ]; then
411 make distclean
&>/dev
/null
412 .
/autogen.sh
>>$CONFIG_LOG 2>&1 || fail
1
413 .
/configure
$CONFIG_OPTIONS >>$CONFIG_LOG 2>&1 || fail
2
414 make ${MAKE_OPTIONS} >>$MAKE_LOG 2>&1 || fail
3
420 # Build the listed tags
421 printf "%-16s" "Build ZFS"
422 for TAG
in $SRC_TAGS; do
425 if [ -f $ZFS_DIR/module
/zfs
/zfs.ko
]; then
427 elif [ "$ZFS_TAG" = "installed" ]; then
431 make distclean
&>/dev
/null
432 .
/autogen.sh
>>$CONFIG_LOG 2>&1 || fail
1
433 .
/configure
--with-spl=$SPL_DIR $CONFIG_OPTIONS \
434 >>$CONFIG_LOG 2>&1 || fail
2
435 make ${MAKE_OPTIONS} >>$MAKE_LOG 2>&1 || fail
3
440 echo "-----------------------------------------------------------------"
442 # Either create a new pool using 'zpool create', or alternately restore an
443 # existing pool from another ZFS implementation for compatibility testing.
444 for TAG
in $POOL_TAGS; do
448 printf "%-16s" $POOL_TAG
450 mkdir
-p $POOL_DIR_PRISTINE
452 # Use the existing compressed image if available.
453 if [ -f $POOL_BZIP ]; then
454 tar -xjf $POOL_BZIP -C $POOL_DIR_PRISTINE \
455 --strip-components=1 || fail
1
456 # Use the installed version to create the pool.
457 elif [ "$TAG" = "installed" ]; then
459 # A source build is available to create the pool.
460 elif [ -d $POOL_DIR_SRC ]; then
466 # Verify 'zpool import' works for all listed source versions.
467 for TAG
in $SRC_TAGS; do
469 if [ $SKIP -eq 1 ]; then
475 if [ "$TAG" != "installed" ]; then
478 $ZFS_SH zfs
="spa_config_path=$POOL_DIR_COPY"
480 cp -a --sparse=always
$POOL_DIR_PRISTINE \
481 $POOL_DIR_COPY || fail
2
482 POOL_NAME
=`$ZPOOL_CMD import -d $POOL_DIR_COPY | \
483 awk '/pool:/ { print $2; exit 0 }'`
485 $ZPOOL_CMD import
-N -d $POOL_DIR_COPY $POOL_NAME &>/dev
/null
486 if [ $?
-ne 0 ]; then
490 $ZPOOL_CMD export $POOL_NAME || fail
3
494 rm -Rf $POOL_DIR_COPY