[functional-tests] Some work on thin-check and thin-dump

This commit is contained in:
Joe Thornber
2017-09-14 11:47:23 +01:00
parent f27b1e36c6
commit 9bc5d9fbfe
6 changed files with 279 additions and 77 deletions

View File

@@ -1,10 +1,20 @@
(import
(bcache block-manager)
(btree)
(fmt fmt)
(matchable)
(mapping-tree)
(chezscheme))
(library
(thin check)
(export thin-check
thin-check-flags)
(import
(bcache block-manager)
(persistent-data btree)
(fmt fmt)
(list-utils)
(matchable)
(parser-combinators)
(srfi s8 receive)
(thin metadata)
(thin mapping-tree)
(chezscheme))
;;;;---------------------------------------------------
;;;; Constants
@@ -18,74 +28,64 @@
(define $uuid-size 16)
(define $space-map-root-size 128)
(define-ftype Superblock
(packed
(endian little
(struct
(csum unsigned-32)
(flags unsigned-32)
(block-nr unsigned-64)
(uuid (bytes $uuid-size))
(magic unsigned-32)
(version unsigned-32)
(time unsigned-32)
(trans-id unsigned-64)
(metadata-snap unsigned-64)
(data-space-map-root (bytes $space-map-root-size))
(metadata-space-map-root (bytes $space-map-root-size))
(data-mapping-root unsigned-64)
(device-details-root unsigned-64)
(data-block-size unsigned-32)
(metadata-block-size unsigned-32)
(metadata-nr-blocks unsigned-64)
(compat-flags unsigned-32)
(compat-ro-flags unsigned-32)
(incompat-flags unsigned-32)))))
(define-compound-value-type device-details-vt ThinDeviceDetails)
;;;;---------------------------------------------------
;;;; Top level
;;;;---------------------------------------------------
(define (block->superblock b)
(make-ftype-pointer ThinSuperblock (block-data b)))
(define (check-magic sb)
((let ((m (bytevector-u32-ref sb 32 (endianness little))))
(fmt #t (dsp "on disk magic: ") (num m) nl)
)))
;;;------------------------------------------------
;;; Fluid vars for the switches
(define (read-superblock)
(with-metadata (md (current-metadata))
(superblock-unpack (read-block md 0) 0)))
(define quiet #f)
(define clear-needs-check-flag #f)
(define ignore-non-fatal-errors #f)
(define skip-mappings #f)
(define super-block-only #f)
(define (dump-dev-tree)
(with-metadata (md (current-metadata))
(let ((sb (superblock-unpack (read-block md 0) 0)))
(btree-each (btree-open le64-type md (superblock-data-mapping-root sb))
(lambda (k v)
(fmt #t (dsp "dev-id: ") (num k)
(dsp ", mapping root: ") (num v) nl))))))
(define (dump-dev-tree cache root)
(btree-each (btree-open device-details-vt cache root)
(lambda (k v)
(fmt #t
"dev-id: " k "\n"
" mapped blocks: " (ftype-ref ThinDeviceDetails (mapped-blocks) v) "\n"
" transaction id: " (ftype-ref ThinDeviceDetails (transaction-id) v) "\n"
" creation time: " (ftype-ref ThinDeviceDetails (creation-time) v) "\n"
" snapshotted time: " (ftype-ref ThinDeviceDetails (snapshotted-time) v) "\n"))))
(define (dump-mappings root)
(with-metadata (md (current-metadata))
(btree-each (btree-open le64-type md root)
(lambda (k v)
(fmt #t (dsp "vblock: ") (num k)
(dsp ", pblock: ") (num v) nl)))))
(define-enumeration thin-check-element
(quiet
clear-needs-check-flag
ignore-non-fatal-errors
skip-mappings
super-block-only)
thin-check-flags)
(define (dump-all-mappings)
(with-metadata (md (current-metadata))
(let ((sb (superblock-unpack (read-block md 0) 0)))
(let ((mappings (mapping-tree-open md (superblock-data-mapping-root sb))))
(mapping-tree-each mappings
(lambda (dev-id vblock pblock time)
(fmt #t
(dsp "thin dev ") (num dev-id)
(dsp ", vblock ") (num vblock)
(dsp ", pblock ") (num pblock)
(dsp ", time ") (num time)
nl)))))))
(define (thin-check metadata-path flags)
(define (member? s)
(enum-set-member? s flags))
(define (check-superblock)
(with-metadata (md (current-metadata))
(let ((superblock (read-block md 0)))
(fmt #t (dsp "checksum on disk: ") (dsp (bytevector-u32-ref superblock 0 (endianness little))) nl)
;(fmt #t (dsp "calculated checksum: ") (dsp (crc32-region $superblock-salt superblock 4 4092)) nl)
(check-magic superblock))))
(fluid-let ((quiet (member? 'quiet))
(clear-needs-check-flag (member? 'clear-needs-check-flag))
(ignore-non-fatal-errors (member? 'ignore-non-fatal-errors))
(skip-mappings (member? 'skip-mappings))
(super-block-only (member? 'super-block-only)))
(fmt (current-output-port)
"quiet: " quiet "\n"
"clear-needs-check-flag: " clear-needs-check-flag "\n"
"ignore-non-fatal-errors: " ignore-non-fatal-errors "\n"
"skip-mappings: " skip-mappings "\n"
"super-block-only: " super-block-only "\n"
"input-file: " metadata-path "\n")
(with-bcache (cache metadata-path 1024)
(with-block (b cache 0 (get-flags))
(let ((sb (block->superblock b)))
(fmt (current-output-port)
"block-nr: " (ftype-ref ThinSuperblock (block-nr) sb) "\n"
"magic: " (ftype-ref ThinSuperblock (magic) sb) "\n"
"data-mapping-root: " (ftype-ref ThinSuperblock (data-mapping-root) sb) "\n"
"device-details-root: " (ftype-ref ThinSuperblock (device-details-root) sb) "\n")
(dump-dev-tree cache (ftype-ref ThinSuperblock (device-details-root) sb)))))))
)