From 2c3b0bab9fb135c23d320880196ad3c0c20a5537 Mon Sep 17 00:00:00 2001 From: ptools Date: Tue, 15 Jun 2004 06:19:34 +0000 Subject: [PATCH] Merging FS QA suite over the XFS QA suite --- 005.out.irix | 17 +++ 005.out.linux | 42 +++++++ 010.out.irix | 58 ++++++++++ 010.out.linux | 58 ++++++++++ 022.out.irix | 61 +++++++++++ 022.out.linux | 59 ++++++++++ 023.out.irix | 95 ++++++++++++++++ 023.out.linux | 93 ++++++++++++++++ 025.out.irix | 87 +++++++++++++++ 025.out.linux | 87 +++++++++++++++ 030.out.irix | 287 ++++++++++++++++++++++++++++++++++++++++++++++++ 030.out.linux | 295 ++++++++++++++++++++++++++++++++++++++++++++++++++ 031.out.irix | 237 ++++++++++++++++++++++++++++++++++++++++ 031.out.linux | 237 ++++++++++++++++++++++++++++++++++++++++ 033.out.irix | 223 ++++++++++++++++++++++++++++++++++++++ 033.out.linux | 229 +++++++++++++++++++++++++++++++++++++++ 036.out.irix | 92 ++++++++++++++++ 036.out.linux | 87 +++++++++++++++ 039.out.irix | 95 ++++++++++++++++ 039.out.linux | 92 ++++++++++++++++ 043.out.irix | 110 +++++++++++++++++++ 043.out.linux | 108 ++++++++++++++++++ 055.out.irix | 95 ++++++++++++++++ 055.out.linux | 92 ++++++++++++++++ 074.out.irix | 18 +++ 074.out.linux | 18 +++ src/helpers.h | 37 +++++++ 27 files changed, 3009 insertions(+) create mode 100644 005.out.irix create mode 100644 005.out.linux create mode 100644 010.out.irix create mode 100644 010.out.linux create mode 100644 022.out.irix create mode 100644 022.out.linux create mode 100644 023.out.irix create mode 100644 023.out.linux create mode 100644 025.out.irix create mode 100644 025.out.linux create mode 100644 030.out.irix create mode 100644 030.out.linux create mode 100644 031.out.irix create mode 100644 031.out.linux create mode 100644 033.out.irix create mode 100644 033.out.linux create mode 100644 036.out.irix create mode 100644 036.out.linux create mode 100644 039.out.irix create mode 100644 039.out.linux create mode 100644 043.out.irix create mode 100644 043.out.linux create mode 100644 055.out.irix create mode 100644 055.out.linux create mode 100755 074.out.irix create mode 100755 074.out.linux create mode 100644 src/helpers.h diff --git a/005.out.irix b/005.out.irix new file mode 100644 index 00000000..d38655e5 --- /dev/null +++ b/005.out.irix @@ -0,0 +1,17 @@ +QA output created by 005 +*** touch deep symlinks + +Cannot create symlink_30: Too many symbolic links in path name traversal +Cannot create symlink_31: Too many symbolic links in path name traversal +Cannot create symlink_32: Too many symbolic links in path name traversal +Cannot create symlink_33: Too many symbolic links in path name traversal +Cannot create symlink_34: Too many symbolic links in path name traversal +Cannot create symlink_35: Too many symbolic links in path name traversal +Cannot create symlink_36: Too many symbolic links in path name traversal +Cannot create symlink_37: Too many symbolic links in path name traversal +Cannot create symlink_38: Too many symbolic links in path name traversal +Cannot create symlink_39: Too many symbolic links in path name traversal + +*** touch recusive symlinks + +Cannot create symlink_self: Too many symbolic links in path name traversal diff --git a/005.out.linux b/005.out.linux new file mode 100644 index 00000000..e8e37be0 --- /dev/null +++ b/005.out.linux @@ -0,0 +1,42 @@ +QA output created by 005 +*** touch deep symlinks + +touch: symlink_05: Too many levels of symbolic links +touch: symlink_06: Too many levels of symbolic links +touch: symlink_07: Too many levels of symbolic links +touch: symlink_08: Too many levels of symbolic links +touch: symlink_09: Too many levels of symbolic links +touch: symlink_10: Too many levels of symbolic links +touch: symlink_11: Too many levels of symbolic links +touch: symlink_12: Too many levels of symbolic links +touch: symlink_13: Too many levels of symbolic links +touch: symlink_14: Too many levels of symbolic links +touch: symlink_15: Too many levels of symbolic links +touch: symlink_16: Too many levels of symbolic links +touch: symlink_17: Too many levels of symbolic links +touch: symlink_18: Too many levels of symbolic links +touch: symlink_19: Too many levels of symbolic links +touch: symlink_20: Too many levels of symbolic links +touch: symlink_21: Too many levels of symbolic links +touch: symlink_22: Too many levels of symbolic links +touch: symlink_23: Too many levels of symbolic links +touch: symlink_24: Too many levels of symbolic links +touch: symlink_25: Too many levels of symbolic links +touch: symlink_26: Too many levels of symbolic links +touch: symlink_27: Too many levels of symbolic links +touch: symlink_28: Too many levels of symbolic links +touch: symlink_29: Too many levels of symbolic links +touch: symlink_30: Too many levels of symbolic links +touch: symlink_31: Too many levels of symbolic links +touch: symlink_32: Too many levels of symbolic links +touch: symlink_33: Too many levels of symbolic links +touch: symlink_34: Too many levels of symbolic links +touch: symlink_35: Too many levels of symbolic links +touch: symlink_36: Too many levels of symbolic links +touch: symlink_37: Too many levels of symbolic links +touch: symlink_38: Too many levels of symbolic links +touch: symlink_39: Too many levels of symbolic links + +*** touch recusive symlinks + +touch: symlink_self: Too many levels of symbolic links diff --git a/010.out.irix b/010.out.irix new file mode 100644 index 00000000..f38fe1e6 --- /dev/null +++ b/010.out.irix @@ -0,0 +1,58 @@ +QA output created by 010 +dbtest v1.0 + +Creating database containing 500 records... + performing lookups for 5 iterations... + using BLEEP as seed for srandom()... + + +There were BLEEP duplicate checksums generated + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Cleaning up database... + +There were BLEEP duplicate checksums generated diff --git a/010.out.linux b/010.out.linux new file mode 100644 index 00000000..6472a5d0 --- /dev/null +++ b/010.out.linux @@ -0,0 +1,58 @@ +QA output created by 010 +dbtest v1.0 + +Creating database containing 3000 records... + performing lookups for 5 iterations... + using BLEEP as seed for srandom()... + + +There were BLEEP duplicate checksums generated + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Performing lookups on database... + + Sequential lookups... + + + Random lookups... + +Lookups succeeded... + +Cleaning up database... + +There were BLEEP duplicate checksums generated diff --git a/022.out.irix b/022.out.irix new file mode 100644 index 00000000..fc848aef --- /dev/null +++ b/022.out.irix @@ -0,0 +1,61 @@ +QA output created by 022 +Creating directory system to dump using fsstress. + +----------------------------------------------- +fsstress : -f link=10 -f creat=10 -f mkdir=10 -f truncate=5 -f symlink=10 +----------------------------------------------- +Erasing tape +Dumping to tape... +xfsdump -s DUMP_SUBDIR -f TAPE_DEV -M stress_tape_media -L stress_022 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_022" +xfsdump: ino map phase 1: parsing subtree selections +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: pruning unneeded subtrees +xfsdump: ino map phase 4: estimating dump size +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: media block size: BLOCKSZ bytes +xfsdump: media block size: BLOCKSZ bytes +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size BLOCKSZ bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_022 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: media block size: BLOCKSZ bytes +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 28 directories and 100 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing listing of dump directory with restore directory +Files TMP.dump_dir and TMP.restore_dir are identical diff --git a/022.out.linux b/022.out.linux new file mode 100644 index 00000000..73725483 --- /dev/null +++ b/022.out.linux @@ -0,0 +1,59 @@ +QA output created by 022 +Put scsi tape driver into variable block size mode +Creating directory system to dump using fsstress. + +----------------------------------------------- +fsstress : -f link=10 -f creat=10 -f mkdir=10 -f truncate=5 -f symlink=10 +----------------------------------------------- +Erasing tape +Dumping to tape... +xfsdump -s DUMP_SUBDIR -f TAPE_DEV -M stress_tape_media -L stress_022 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_022" +xfsdump: ino map phase 1: parsing subtree selections +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: pruning unneeded subtrees +xfsdump: ino map phase 4: estimating dump size +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size BLOCKSZ bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_022 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 34 directories and 94 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing listing of dump directory with restore directory +Files TMP.dump_dir and TMP.restore_dir are identical diff --git a/023.out.irix b/023.out.irix new file mode 100644 index 00000000..1402c9dd --- /dev/null +++ b/023.out.irix @@ -0,0 +1,95 @@ +QA output created by 023 +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -s DUMP_SUBDIR -f TAPE_DEV -M stress_tape_media -L stress_023 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_023" +xfsdump: ino map phase 1: parsing subtree selections +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: pruning unneeded subtrees +xfsdump: ino map phase 4: estimating dump size +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: media block size: BLOCKSZ bytes +xfsdump: media block size: BLOCKSZ bytes +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size BLOCKSZ bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_023 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: media block size: BLOCKSZ bytes +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Comparing listing of dump directory with restore directory +Files TMP.dump_dir and TMP.restore_dir are identical diff --git a/023.out.linux b/023.out.linux new file mode 100644 index 00000000..181f24a5 --- /dev/null +++ b/023.out.linux @@ -0,0 +1,93 @@ +QA output created by 023 +Put scsi tape driver into variable block size mode +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -s DUMP_SUBDIR -f TAPE_DEV -M stress_tape_media -L stress_023 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_023" +xfsdump: ino map phase 1: parsing subtree selections +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: pruning unneeded subtrees +xfsdump: ino map phase 4: estimating dump size +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size BLOCKSZ bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_023 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Comparing listing of dump directory with restore directory +Files TMP.dump_dir and TMP.restore_dir are identical diff --git a/025.out.irix b/025.out.irix new file mode 100644 index 00000000..4d6515db --- /dev/null +++ b/025.out.irix @@ -0,0 +1,87 @@ +QA output created by 025 +Put scsi tape driver into variable block size mode +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -m -b 1048576 -l0 -f TAPE_DEV -M stress_tape_media -L stress_025 SCRATCH_MNT +xfsdump: using minimum scsi tape (drive_minrmt) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_025" +xfsdump: ino map phase 1: skipping (no subtrees specified) +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: skipping (no pruning necessary) +xfsdump: ino map phase 4: skipping (size estimated in phase 2) +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -m -b 1048576 -f TAPE_DEV -L stress_025 RESTORE_DIR +xfsrestore: using minimum scsi tape (drive_minrmt) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Only in SCRATCH_MNT: RESTORE_SUBDIR diff --git a/025.out.linux b/025.out.linux new file mode 100644 index 00000000..4d6515db --- /dev/null +++ b/025.out.linux @@ -0,0 +1,87 @@ +QA output created by 025 +Put scsi tape driver into variable block size mode +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -m -b 1048576 -l0 -f TAPE_DEV -M stress_tape_media -L stress_025 SCRATCH_MNT +xfsdump: using minimum scsi tape (drive_minrmt) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_025" +xfsdump: ino map phase 1: skipping (no subtrees specified) +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: skipping (no pruning necessary) +xfsdump: ino map phase 4: skipping (size estimated in phase 2) +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -m -b 1048576 -f TAPE_DEV -L stress_025 RESTORE_DIR +xfsrestore: using minimum scsi tape (drive_minrmt) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Only in SCRATCH_MNT: RESTORE_SUBDIR diff --git a/030.out.irix b/030.out.irix new file mode 100644 index 00000000..54f8e06a --- /dev/null +++ b/030.out.irix @@ -0,0 +1,287 @@ +QA output created by 030 +meta-data=DDEV isize=XXX agcount=N, agsize=XXX blks +data = bsize=XXX blocks=XXX, imaxpct=PCT + = sunit=XXX swidth=XXX, unwritten=X +naming =VERN bsize=XXX +log =LDEV bsize=XXX blocks=XXX +realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX +Corrupting sb 0 - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +bad primary superblock - bad magic number !!! + +attempting to find secondary superblock... +found candidate secondary superblock... +verified secondary superblock... +writing modified primary superblock +sb root inode value INO inconsistent with calculated value INO +resetting superblock root inode pointer to INO +sb realtime bitmap inode INO inconsistent with calculated value INO +resetting superblock realtime bitmap ino pointer to INO +sb realtime summary inode INO inconsistent with calculated value INO +resetting superblock realtime summary ino pointer to INO +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +Note - stripe unit (0) and width (0) fields have been reset. +Please set with mount -o sunit=,swidth= +done +Corrupting agf 0 - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... +bad magic # 0x0 for agf 0 +bad version # 0 for agf 0 +bad length 0 for agf 0, should be LENGTH +reset bad agf for ag 0 +bad agbno AGBNO for btbno root, agno 0 +bad agbno AGBNO for btbcnt root, agno 0 + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting agi 0 - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... +bad magic # 0x0 for agi 0 +bad version # 0 for agi 0 +bad length # 0 for agi 0, should be LENGTH +reset bad agi for ag 0 +bad agbno AGBNO for inobt root, agno 0 +root inode chunk not found +Phase 3 - for each AG... + - scan and clear agi unlinked lists... +error following ag 0 unlinked list + - process known inodes and perform inode discovery... +imap claims in-use inode INO is free, correcting imap + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting agfl 0 - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting sb 0 - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +bad primary superblock - bad magic number !!! + +attempting to find secondary superblock... +found candidate secondary superblock... +verified secondary superblock... +writing modified primary superblock +sb root inode value INO inconsistent with calculated value INO +resetting superblock root inode pointer to INO +sb realtime bitmap inode INO inconsistent with calculated value INO +resetting superblock realtime bitmap ino pointer to INO +sb realtime summary inode INO inconsistent with calculated value INO +resetting superblock realtime summary ino pointer to INO +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +Note - stripe unit (0) and width (0) fields have been reset. +Please set with mount -o sunit=,swidth= +done +Corrupting agf 0 - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... +bad magic # 0xffffffff for agf 0 +bad version # -1 for agf 0 +bad sequence # -1 for agf 0 +bad length -1 for agf 0, should be LENGTH +flfirst -1 in agf 0 too large (max = MAX) +fllast -1 in agf 0 too large (max = MAX) +reset bad agf for ag 0 +freeblk count 1 != flcount -1 in ag 0 +bad agbno AGBNO for btbno root, agno 0 +bad agbno AGBNO for btbcnt root, agno 0 + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting agi 0 - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... +bad magic # 0xffffffff for agi 0 +bad version # -1 for agi 0 +bad sequence # -1 for agi 0 +bad length # -1 for agi 0, should be LENGTH +reset bad agi for ag 0 +bad agbno AGBNO for inobt root, agno 0 +root inode chunk not found +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +imap claims in-use inode INO is free, correcting imap + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting agfl 0 - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done diff --git a/030.out.linux b/030.out.linux new file mode 100644 index 00000000..48fdedd8 --- /dev/null +++ b/030.out.linux @@ -0,0 +1,295 @@ +QA output created by 030 +meta-data=DDEV isize=XXX agcount=N, agsize=XXX blks +data = bsize=XXX blocks=XXX, imaxpct=PCT + = sunit=XXX swidth=XXX, unwritten=X +naming =VERN bsize=XXX +log =LDEV bsize=XXX blocks=XXX +realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX +Corrupting sb 0 - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +bad primary superblock - bad magic number !!! + +attempting to find secondary superblock... +found candidate secondary superblock... +verified secondary superblock... +writing modified primary superblock +sb root inode value INO inconsistent with calculated value INO +resetting superblock root inode pointer to INO +sb realtime bitmap inode INO inconsistent with calculated value INO +resetting superblock realtime bitmap ino pointer to INO +sb realtime summary inode INO inconsistent with calculated value INO +resetting superblock realtime summary ino pointer to INO +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +Note - stripe unit (0) and width (0) fields have been reset. +Please set with mount -o sunit=,swidth= +done +Corrupting agf 0 - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... +bad magic # 0x0 for agf 0 +bad version # 0 for agf 0 +bad length 0 for agf 0, should be LENGTH +reset bad agf for ag 0 +bad agbno AGBNO for btbno root, agno 0 +bad agbno AGBNO for btbcnt root, agno 0 + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting agi 0 - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... +bad magic # 0x0 for agi 0 +bad version # 0 for agi 0 +bad length # 0 for agi 0, should be LENGTH +reset bad agi for ag 0 +bad agbno AGBNO for inobt root, agno 0 +root inode chunk not found +Phase 3 - for each AG... + - scan and clear agi unlinked lists... +error following ag 0 unlinked list + - process known inodes and perform inode discovery... +imap claims in-use inode INO is free, correcting imap + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting agfl 0 - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting sb 0 - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +bad primary superblock - bad magic number !!! + +attempting to find secondary superblock... +found candidate secondary superblock... +verified secondary superblock... +writing modified primary superblock +sb root inode value INO inconsistent with calculated value INO +resetting superblock root inode pointer to INO +sb realtime bitmap inode INO inconsistent with calculated value INO +resetting superblock realtime bitmap ino pointer to INO +sb realtime summary inode INO inconsistent with calculated value INO +resetting superblock realtime summary ino pointer to INO +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +Note - stripe unit (0) and width (0) fields have been reset. +Please set with mount -o sunit=,swidth= +done +Corrupting agf 0 - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... +bad magic # 0xffffffff for agf 0 +bad version # -1 for agf 0 +bad sequence # -1 for agf 0 +bad length -1 for agf 0, should be LENGTH +flfirst -1 in agf 0 too large (max = MAX) +fllast -1 in agf 0 too large (max = MAX) +reset bad agf for ag 0 +freeblk count 1 != flcount -1 in ag 0 +bad agbno AGBNO for btbno root, agno 0 +bad agbno AGBNO for btbcnt root, agno 0 + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting agi 0 - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... +bad magic # 0xffffffff for agi 0 +bad version # -1 for agi 0 +bad sequence # -1 for agi 0 +bad length # -1 for agi 0, should be LENGTH +reset bad agi for ag 0 +bad agbno AGBNO for inobt root, agno 0 +root inode chunk not found +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +imap claims in-use inode INO is free, correcting imap + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting agfl 0 - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done diff --git a/031.out.irix b/031.out.irix new file mode 100644 index 00000000..6ae039be --- /dev/null +++ b/031.out.irix @@ -0,0 +1,237 @@ +QA output created by 031 +=== version 1, one entry +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done + +=== version 2, one entry (shortform) +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done + +=== version 1, twenty entries +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done + +=== version 2, twenty entries (block form) +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done + +=== version 1, thousand entries +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done + +=== version 2, thousand entries (leaf form) +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - zero log... +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done + diff --git a/031.out.linux b/031.out.linux new file mode 100644 index 00000000..baebe639 --- /dev/null +++ b/031.out.linux @@ -0,0 +1,237 @@ +QA output created by 031 +=== version 1, one entry +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done + +=== version 2, one entry (shortform) +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done + +=== version 1, twenty entries +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done + +=== version 2, twenty entries (block form) +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done + +=== version 1, thousand entries +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +Phase 7 - verify and correct link counts... +done + +=== version 2, thousand entries (leaf form) +Repairing, iteration 1 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 2 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 3 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done +Repairing, iteration 4 +Phase 1 - find and verify superblock... +Phase 2 - using log +Phase 3 - for each AG... +Phase 4 - check for duplicate blocks... +Phase 5 - rebuild AG headers and trees... +Phase 6 - check inode connectivity... +rebuilding directory inode INO +Phase 7 - verify and correct link counts... +done + diff --git a/033.out.irix b/033.out.irix new file mode 100644 index 00000000..1a2d9c3f --- /dev/null +++ b/033.out.irix @@ -0,0 +1,223 @@ +QA output created by 033 +meta-data=DDEV isize=XXX agcount=N, agsize=XXX blks +data = bsize=XXX blocks=XXX, imaxpct=PCT + = sunit=XXX swidth=XXX, unwritten=X +naming =VERN bsize=XXX +log =LDEV bsize=XXX blocks=XXX +realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX +Corrupting root inode - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0x0 on inode INO +bad version number 0x0 on inode INO +bad magic number 0x0 on inode INO, resetting magic number +bad version number 0x0 on inode INO, resetting version number +imap claims a free inode INO is in use, correcting imap and clearing inode +cleared root inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... +root inode lost + - clear lost+found (if it exists) ... + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing root directory + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +resetting inode INO nlinks from 2 to 3 +done +Corrupting rt bitmap inode - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0x0 on inode INO +bad version number 0x0 on inode INO +bad magic number 0x0 on inode INO, resetting magic number +bad version number 0x0 on inode INO, resetting version number +imap claims a free inode INO is in use, correcting imap and clearing inode +cleared realtime bitmap inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing realtime bitmap inode + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting rt summary inode - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0x0 on inode INO +bad version number 0x0 on inode INO +bad magic number 0x0 on inode INO, resetting magic number +bad version number 0x0 on inode INO, resetting version number +imap claims a free inode INO is in use, correcting imap and clearing inode +cleared realtime summary inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing realtime summary inode + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting root inode - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0xffff on inode INO +bad version number 0xffffffff on inode INO +bad (negative) size -1 on inode INO +bad magic number 0xffff on inode INO, resetting magic number +bad version number 0xffffffff on inode INO, resetting version number +bad (negative) size -1 on inode INO +cleared root inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... +root inode lost + - clear lost+found (if it exists) ... + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing root directory + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +disconnected dir inode INO, moving to lost+found +Phase 7 - verify and correct link counts... +resetting inode INO nlinks from 2 to 3 +done +Corrupting rt bitmap inode - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0xffff on inode INO +bad version number 0xffffffff on inode INO +bad (negative) size -1 on inode INO +bad magic number 0xffff on inode INO, resetting magic number +bad version number 0xffffffff on inode INO, resetting version number +bad (negative) size -1 on inode INO +cleared realtime bitmap inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing realtime bitmap inode + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +disconnected dir inode INO, moving to lost+found +Phase 7 - verify and correct link counts... +done +Corrupting rt summary inode - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0xffff on inode INO +bad version number 0xffffffff on inode INO +bad (negative) size -1 on inode INO +bad magic number 0xffff on inode INO, resetting magic number +bad version number 0xffffffff on inode INO, resetting version number +bad (negative) size -1 on inode INO +cleared realtime summary inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing realtime summary inode + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +disconnected dir inode INO, moving to lost+found +Phase 7 - verify and correct link counts... +done diff --git a/033.out.linux b/033.out.linux new file mode 100644 index 00000000..50f273d6 --- /dev/null +++ b/033.out.linux @@ -0,0 +1,229 @@ +QA output created by 033 +meta-data=DDEV isize=XXX agcount=N, agsize=XXX blks +data = bsize=XXX blocks=XXX, imaxpct=PCT + = sunit=XXX swidth=XXX, unwritten=X +naming =VERN bsize=XXX +log =LDEV bsize=XXX blocks=XXX +realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX +Corrupting root inode - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0x0 on inode INO +bad version number 0x0 on inode INO +bad magic number 0x0 on inode INO, resetting magic number +bad version number 0x0 on inode INO, resetting version number +imap claims a free inode INO is in use, correcting imap and clearing inode +cleared root inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... +root inode lost + - clear lost+found (if it exists) ... + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing root directory + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +resetting inode INO nlinks from 2 to 3 +done +Corrupting rt bitmap inode - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0x0 on inode INO +bad version number 0x0 on inode INO +bad magic number 0x0 on inode INO, resetting magic number +bad version number 0x0 on inode INO, resetting version number +imap claims a free inode INO is in use, correcting imap and clearing inode +cleared realtime bitmap inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing realtime bitmap inode + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting rt summary inode - setting bits to 0 +Wrote X.XXKb (value 0x0) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0x0 on inode INO +bad version number 0x0 on inode INO +bad magic number 0x0 on inode INO, resetting magic number +bad version number 0x0 on inode INO, resetting version number +imap claims a free inode INO is in use, correcting imap and clearing inode +cleared realtime summary inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing realtime summary inode + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +Phase 7 - verify and correct link counts... +done +Corrupting root inode - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0xffff on inode INO +bad version number 0xffffffff on inode INO +bad (negative) size -1 on inode INO +bad magic number 0xffff on inode INO, resetting magic number +bad version number 0xffffffff on inode INO, resetting version number +bad (negative) size -1 on inode INO +cleared root inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... +root inode lost + - clear lost+found (if it exists) ... + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing root directory + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +disconnected dir inode INO, moving to lost+found +Phase 7 - verify and correct link counts... +resetting inode INO nlinks from 2 to 3 +done +Corrupting rt bitmap inode - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0xffff on inode INO +bad version number 0xffffffff on inode INO +bad (negative) size -1 on inode INO +bad magic number 0xffff on inode INO, resetting magic number +bad version number 0xffffffff on inode INO, resetting version number +bad (negative) size -1 on inode INO +cleared realtime bitmap inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing realtime bitmap inode + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +disconnected dir inode INO, moving to lost+found +Phase 7 - verify and correct link counts... +done +Corrupting rt summary inode - setting bits to -1 +Wrote X.XXKb (value 0xffffffff) +Phase 1 - find and verify superblock... +Phase 2 - using log + - zero log... + - scan filesystem freespace and inode maps... + - found root inode chunk +Phase 3 - for each AG... + - scan and clear agi unlinked lists... + - process known inodes and perform inode discovery... +bad magic number 0xffff on inode INO +bad version number 0xffffffff on inode INO +bad (negative) size -1 on inode INO +bad magic number 0xffff on inode INO, resetting magic number +bad version number 0xffffffff on inode INO, resetting version number +bad (negative) size -1 on inode INO +cleared realtime summary inode INO + - process newly discovered inodes... +Phase 4 - check for duplicate blocks... + - setting up duplicate extent list... + - clear lost+found (if it exists) ... + - clearing existing "lost+found" inode + - deleting existing "lost+found" entry + - check for inodes claiming duplicate blocks... +Phase 5 - rebuild AG headers and trees... + - reset superblock... +Phase 6 - check inode connectivity... +reinitializing realtime summary inode + - resetting contents of realtime bitmap and summary inodes + - ensuring existence of lost+found directory + - traversing filesystem starting at / ... + - traversal finished ... + - traversing all unattached subtrees ... + - traversals finished ... + - moving disconnected inodes to lost+found ... +disconnected dir inode INO, moving to lost+found +Phase 7 - verify and correct link counts... +done diff --git a/036.out.irix b/036.out.irix new file mode 100644 index 00000000..7f1a04ea --- /dev/null +++ b/036.out.irix @@ -0,0 +1,92 @@ +QA output created by 036 +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -o -F -m -b 1048576 -l0 -f TAPE_DEV -M stress_tape_media -L stress_036 SCRATCH_MNT +xfsdump: using minimum scsi tape (drive_minrmt) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_036" +xfsdump: ino map phase 1: skipping (no subtrees specified) +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: skipping (no pruning necessary) +xfsdump: ino map phase 4: skipping (size estimated in phase 2) +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: WARNING: using default tape file size: 256 Mb (use -d option to adjust file size) +xfsdump: media block size: BLOCKSZ bytes +xfsdump: WARNING: media may contain data. Overwrite option specified +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -m -b 1048576 -f TAPE_DEV -L stress_036 RESTORE_DIR +xfsrestore: using minimum scsi tape (drive_minrmt) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: WARNING: using default tape file size: 256 Mb (use -d option to adjust file size) +xfsrestore: media block size: BLOCKSZ bytes +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: read_record encountered EOD : end of data +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Only in SCRATCH_MNT: RESTORE_SUBDIR diff --git a/036.out.linux b/036.out.linux new file mode 100644 index 00000000..8f7473a0 --- /dev/null +++ b/036.out.linux @@ -0,0 +1,87 @@ +QA output created by 036 +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -o -F -m -b 1048576 -l0 -f TAPE_DEV -M stress_tape_media -L stress_036 SCRATCH_MNT +xfsdump: using minimum scsi tape (drive_minrmt) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_036" +xfsdump: ino map phase 1: skipping (no subtrees specified) +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: skipping (no pruning necessary) +xfsdump: ino map phase 4: skipping (size estimated in phase 2) +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: WARNING: media may contain data. Overwrite option specified +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -m -b 1048576 -f TAPE_DEV -L stress_036 RESTORE_DIR +xfsrestore: using minimum scsi tape (drive_minrmt) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Only in SCRATCH_MNT: RESTORE_SUBDIR diff --git a/039.out.irix b/039.out.irix new file mode 100644 index 00000000..2b721e8a --- /dev/null +++ b/039.out.irix @@ -0,0 +1,95 @@ +QA output created by 039 +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -o -F -f TAPE_DEV -M stress_tape_media -L stress_039 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_039" +xfsdump: ino map phase 1: skipping (no subtrees specified) +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: skipping (no pruning necessary) +xfsdump: ino map phase 4: skipping (size estimated in phase 2) +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: WARNING: using default tape file size: 256 Mb (use -d option to adjust file size) +xfsdump: media block size: 0 bytes +xfsdump: WARNING: media may contain data. Overwrite option specified +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size 245760 bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_039 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: WARNING: using default tape file size: 256 Mb (use -d option to adjust file size) +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Only in SCRATCH_MNT: RESTORE_SUBDIR diff --git a/039.out.linux b/039.out.linux new file mode 100644 index 00000000..b5379858 --- /dev/null +++ b/039.out.linux @@ -0,0 +1,92 @@ +QA output created by 039 +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -o -F -f TAPE_DEV -M stress_tape_media -L stress_039 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_039" +xfsdump: ino map phase 1: skipping (no subtrees specified) +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: skipping (no pruning necessary) +xfsdump: ino map phase 4: skipping (size estimated in phase 2) +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: WARNING: media may contain data. Overwrite option specified +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size 245760 bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_039 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Only in SCRATCH_MNT: RESTORE_SUBDIR diff --git a/043.out.irix b/043.out.irix new file mode 100644 index 00000000..5daa6ed2 --- /dev/null +++ b/043.out.irix @@ -0,0 +1,110 @@ +QA output created by 043 +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -s DUMP_SUBDIR -f TAPE_DEV -M stress_tape_media -L stress_043 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_043" +xfsdump: ino map phase 1: parsing subtree selections +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: pruning unneeded subtrees +xfsdump: ino map phase 4: estimating dump size +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: media block size: BLOCKSZ bytes +xfsdump: media block size: BLOCKSZ bytes +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size BLOCKSZ bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_043 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: searching media for dump +xfsrestore: preparing drive +xfsrestore: media block size: BLOCKSZ bytes +xfsrestore: examining media file 0 +xfsrestore: found dump matching specified label: +xfsrestore: hostname: HOSTNAME +xfsrestore: mount point: SCRATCH_MNT +xfsrestore: volume: SCRATCH_DEV +xfsrestore: session time: TIME +xfsrestore: level: 0 +xfsrestore: session label: "stress_043" +xfsrestore: media label: "stress_tape_media" +xfsrestore: file system ID: ID +xfsrestore: session id: ID +xfsrestore: media ID: ID +xfsrestore: searching media for directory dump +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: examining media file 1 +xfsrestore: incorporating on-media session inventory into online inventory +xfsrestore: /var/xfsdump/inventory created +xfsrestore: using on-media session inventory +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Comparing listing of dump directory with restore directory +Files TMP.dump_dir and TMP.restore_dir are identical diff --git a/043.out.linux b/043.out.linux new file mode 100644 index 00000000..75cf8135 --- /dev/null +++ b/043.out.linux @@ -0,0 +1,108 @@ +QA output created by 043 +Put scsi tape driver into variable block size mode +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -s DUMP_SUBDIR -f TAPE_DEV -M stress_tape_media -L stress_043 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_043" +xfsdump: ino map phase 1: parsing subtree selections +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: pruning unneeded subtrees +xfsdump: ino map phase 4: estimating dump size +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size BLOCKSZ bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_043 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: searching media for dump +xfsrestore: preparing drive +xfsrestore: examining media file 0 +xfsrestore: found dump matching specified label: +xfsrestore: hostname: HOSTNAME +xfsrestore: mount point: SCRATCH_MNT +xfsrestore: volume: SCRATCH_DEV +xfsrestore: session time: TIME +xfsrestore: level: 0 +xfsrestore: session label: "stress_043" +xfsrestore: media label: "stress_tape_media" +xfsrestore: file system ID: ID +xfsrestore: session id: ID +xfsrestore: media ID: ID +xfsrestore: searching media for directory dump +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: examining media file 1 +xfsrestore: incorporating on-media session inventory into online inventory +xfsrestore: /var/xfsdump/inventory created +xfsrestore: using on-media session inventory +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Comparing listing of dump directory with restore directory +Files TMP.dump_dir and TMP.restore_dir are identical diff --git a/055.out.irix b/055.out.irix new file mode 100644 index 00000000..48250f08 --- /dev/null +++ b/055.out.irix @@ -0,0 +1,95 @@ +QA output created by 055 +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -o -F -f TAPE_DEV -M stress_tape_media -L stress_055 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_055" +xfsdump: ino map phase 1: skipping (no subtrees specified) +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: skipping (no pruning necessary) +xfsdump: ino map phase 4: skipping (size estimated in phase 2) +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: WARNING: using default tape file size: 256 Mb (use -d option to adjust file size) +xfsdump: media block size: 0 bytes +xfsdump: WARNING: media may contain data. Overwrite option specified +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size 245760 bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_055 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: WARNING: using default tape file size: 256 Mb (use -d option to adjust file size) +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Only in SCRATCH_MNT: RESTORE_SUBDIR diff --git a/055.out.linux b/055.out.linux new file mode 100644 index 00000000..f09dd2e4 --- /dev/null +++ b/055.out.linux @@ -0,0 +1,92 @@ +QA output created by 055 +Creating directory system to dump using src/fill. +Setup .................................... +Erasing tape +Dumping to tape... +xfsdump -o -F -f TAPE_DEV -M stress_tape_media -L stress_055 SCRATCH_MNT +xfsdump: using scsi tape (drive_scsitape) strategy +xfsdump: level 0 dump of HOSTNAME:SCRATCH_MNT +xfsdump: dump date: DATE +xfsdump: session id: ID +xfsdump: session label: "stress_055" +xfsdump: ino map phase 1: skipping (no subtrees specified) +xfsdump: ino map phase 2: constructing initial dump list +xfsdump: ino map phase 3: skipping (no pruning necessary) +xfsdump: ino map phase 4: skipping (size estimated in phase 2) +xfsdump: ino map phase 5: skipping (only one dump stream) +xfsdump: ino map construction complete +xfsdump: estimated dump size: NUM bytes +xfsdump: /var/xfsdump/inventory created +xfsdump: preparing drive +xfsdump: WARNING: media may contain data. Overwrite option specified +xfsdump: creating dump session media file 0 (media 0, file 0) +xfsdump: dumping ino map +xfsdump: dumping directories +xfsdump: dumping non-directory files +xfsdump: ending media file +xfsdump: media file size NUM bytes +xfsdump: dumping session inventory +xfsdump: beginning inventory media file +xfsdump: media file 1 (media 0, file 1) +xfsdump: ending inventory media file +xfsdump: inventory media file size NUM bytes +xfsdump: writing stream terminator +xfsdump: beginning media stream terminator +xfsdump: media file 2 (media 0, file 2) +xfsdump: ending media stream terminator +xfsdump: media stream terminator size 245760 bytes +xfsdump: dump size (non-dir files) : NUM bytes +xfsdump: dump complete: SECS seconds elapsed +xfsdump: Dump Status: SUCCESS +Rewinding tape +Restoring from tape... +xfsrestore -f TAPE_DEV -L stress_055 RESTORE_DIR +xfsrestore: using scsi tape (drive_scsitape) strategy +xfsrestore: using online session inventory +xfsrestore: searching media for directory dump +xfsrestore: preparing drive +xfsrestore: examining media file 0 +xfsrestore: reading directories +xfsrestore: 3 directories and 38 entries processed +xfsrestore: directory post-processing +xfsrestore: restoring non-directory files +xfsrestore: restore complete: SECS seconds elapsed +xfsrestore: Restore Status: SUCCESS +Comparing dump directory with restore directory +Files DUMP_DIR/big and RESTORE_DIR/DUMP_SUBDIR/big are identical +Files DUMP_DIR/small and RESTORE_DIR/DUMP_SUBDIR/small are identical +Files DUMP_DIR/sub/a and RESTORE_DIR/DUMP_SUBDIR/sub/a are identical +Files DUMP_DIR/sub/a00 and RESTORE_DIR/DUMP_SUBDIR/sub/a00 are identical +Files DUMP_DIR/sub/a000 and RESTORE_DIR/DUMP_SUBDIR/sub/a000 are identical +Files DUMP_DIR/sub/b and RESTORE_DIR/DUMP_SUBDIR/sub/b are identical +Files DUMP_DIR/sub/b00 and RESTORE_DIR/DUMP_SUBDIR/sub/b00 are identical +Files DUMP_DIR/sub/big and RESTORE_DIR/DUMP_SUBDIR/sub/big are identical +Files DUMP_DIR/sub/c and RESTORE_DIR/DUMP_SUBDIR/sub/c are identical +Files DUMP_DIR/sub/c00 and RESTORE_DIR/DUMP_SUBDIR/sub/c00 are identical +Files DUMP_DIR/sub/d and RESTORE_DIR/DUMP_SUBDIR/sub/d are identical +Files DUMP_DIR/sub/d00 and RESTORE_DIR/DUMP_SUBDIR/sub/d00 are identical +Files DUMP_DIR/sub/e and RESTORE_DIR/DUMP_SUBDIR/sub/e are identical +Files DUMP_DIR/sub/e00 and RESTORE_DIR/DUMP_SUBDIR/sub/e00 are identical +Files DUMP_DIR/sub/e000 and RESTORE_DIR/DUMP_SUBDIR/sub/e000 are identical +Files DUMP_DIR/sub/f and RESTORE_DIR/DUMP_SUBDIR/sub/f are identical +Files DUMP_DIR/sub/f00 and RESTORE_DIR/DUMP_SUBDIR/sub/f00 are identical +Files DUMP_DIR/sub/g and RESTORE_DIR/DUMP_SUBDIR/sub/g are identical +Files DUMP_DIR/sub/g00 and RESTORE_DIR/DUMP_SUBDIR/sub/g00 are identical +Files DUMP_DIR/sub/h and RESTORE_DIR/DUMP_SUBDIR/sub/h are identical +Files DUMP_DIR/sub/h00 and RESTORE_DIR/DUMP_SUBDIR/sub/h00 are identical +Files DUMP_DIR/sub/h000 and RESTORE_DIR/DUMP_SUBDIR/sub/h000 are identical +Files DUMP_DIR/sub/i and RESTORE_DIR/DUMP_SUBDIR/sub/i are identical +Files DUMP_DIR/sub/i00 and RESTORE_DIR/DUMP_SUBDIR/sub/i00 are identical +Files DUMP_DIR/sub/j and RESTORE_DIR/DUMP_SUBDIR/sub/j are identical +Files DUMP_DIR/sub/j00 and RESTORE_DIR/DUMP_SUBDIR/sub/j00 are identical +Files DUMP_DIR/sub/k and RESTORE_DIR/DUMP_SUBDIR/sub/k are identical +Files DUMP_DIR/sub/k00 and RESTORE_DIR/DUMP_SUBDIR/sub/k00 are identical +Files DUMP_DIR/sub/k000 and RESTORE_DIR/DUMP_SUBDIR/sub/k000 are identical +Files DUMP_DIR/sub/l and RESTORE_DIR/DUMP_SUBDIR/sub/l are identical +Files DUMP_DIR/sub/l00 and RESTORE_DIR/DUMP_SUBDIR/sub/l00 are identical +Files DUMP_DIR/sub/m and RESTORE_DIR/DUMP_SUBDIR/sub/m are identical +Files DUMP_DIR/sub/m00 and RESTORE_DIR/DUMP_SUBDIR/sub/m00 are identical +Files DUMP_DIR/sub/n and RESTORE_DIR/DUMP_SUBDIR/sub/n are identical +Files DUMP_DIR/sub/n00 and RESTORE_DIR/DUMP_SUBDIR/sub/n00 are identical +Files DUMP_DIR/sub/small and RESTORE_DIR/DUMP_SUBDIR/sub/small are identical +Only in SCRATCH_MNT: RESTORE_SUBDIR diff --git a/074.out.irix b/074.out.irix new file mode 100755 index 00000000..c1395bbb --- /dev/null +++ b/074.out.irix @@ -0,0 +1,18 @@ +QA output created by 074 +brevity is wit... + +----------------------------------------------- +fstest.0 : +----------------------------------------------- + +----------------------------------------------- +fstest.1 : -s 10485760 -b 8192 -m +----------------------------------------------- + +----------------------------------------------- +fstest.2 : -n 3 -Fp -f 10 -s 31457280 -b 512 +----------------------------------------------- + +----------------------------------------------- +fstest.3 : -n 3 -Fp -f 10 -s 31457280 -b 512 -m +----------------------------------------------- diff --git a/074.out.linux b/074.out.linux new file mode 100755 index 00000000..c1395bbb --- /dev/null +++ b/074.out.linux @@ -0,0 +1,18 @@ +QA output created by 074 +brevity is wit... + +----------------------------------------------- +fstest.0 : +----------------------------------------------- + +----------------------------------------------- +fstest.1 : -s 10485760 -b 8192 -m +----------------------------------------------- + +----------------------------------------------- +fstest.2 : -n 3 -Fp -f 10 -s 31457280 -b 512 +----------------------------------------------- + +----------------------------------------------- +fstest.3 : -n 3 -Fp -f 10 -s 31457280 -b 512 -m +----------------------------------------------- diff --git a/src/helpers.h b/src/helpers.h new file mode 100644 index 00000000..2b01d193 --- /dev/null +++ b/src/helpers.h @@ -0,0 +1,37 @@ +#ifndef _HELPERS_H +#define _HELPERS_H + +#include "udf_ecma167.h" +#include "udf.h" + +#ifndef howmany +#define howmany(x,y) (((x)+(y)-1)/(y)) +#endif + +extern uint8_t *test_bitmap; +extern uint8_t *test_disk; +extern uint32_t test_disk_len; +extern uint32_t test_bitmap_len; +extern struct udf_space_bitmap_desc bmap_desc; + +/* device values to decide which data to read/write from */ +#define UDF_DEV_BITMAP 1 +#define UDF_DEV_DISK 2 + +/* keep it small so that I don't need to alloc much memory :) */ +#define UDF_MY_PART_START 2 /* partition start in sectors */ + +void udf_print_space_bitmap(void); +void setup_space(dev_t dev, udf_mnt_t *udfmp, uint32_t num_sectors); +void setup_inode( + udf_mnt_t *udfmp, + bhv_desc_t *bhv_desc, + udf_inode_t *inode, + vnode_t *vnode, + cred_t *cred, + struct udf_xfile_entry *fentry); +void make_disk_ones(void); +void print_disk(void); +void free_all_extents(udf_inode_t *); + +#endif -- 2.47.3