anchor.diff:              (t (error "Unsupported element-type ~S." element-type))))))
   
   (defmethod probe-using-host ((host ext4-host) pathname)
  -  (multiple-value-bind (inode-n) (find-file host pathname)
  -    (if inode-n t nil)))
  +  (multiple-value-bind (inode) (find-file host pathname)
  +    (if inode t nil)))
   
   (defmethod directory-using-host ((host ext4-host) pathname &key)
  -  (let ((inode-n (find-file host pathname))
  +  (let ((inode (find-file host pathname))
           (disk (file-host-mount-device host))
           (superblock (superblock host))
           (bgdt (bgdt host))
           (stack '())
           (path (directory-namestring pathname)))
  -    (do-files (block offset) disk superblock bgdt inode-n t
  +    (do-files (block offset) disk superblock bgdt inode t
         (let* ((file (read-linked-directory-entry block offset))
                (file-name (linked-directory-entry-name file))
                (type (linked-directory-entry-file-type file)))
  
positive.code:   `(mezzano.supervisor:with-mutex ((ext4-host-lock ,host))
       ,@body))
  
  ;; WIP
  (defmethod open-using-host ((host ext4-host) pathname
                              &key direction element-type if-exists if-does-not-exist external-format)
    (with-ext4-host-locked (host)
      (let ((file-inode nil)
            (buffer nil)
            (file-position 0)
            (file-length 0)
            (created-file nil)
            (abort-action nil))
        (let ((inode-n (find-file host pathname))
              (block-device (file-host-mount-device host)))
          (if inode-n
              (let ((file-inode (read-inode block-device (superblock host) (bgdt host) inode-n)))
                (setf file-inode file-inode
                      buffer (read-file block-device (superblock host) (bgdt host) inode-n)
                      file-length (inode-size file-inode)))
              (ecase if-does-not-exist
                (:error (error 'simple-file-error
                               :pathname pathname
                               :format-control "File ~A does not exist. ~S"
                               :format-arguments (list pathname (file-name pathname))))
                (:create (setf created-file t
                               abort-action :delete)
                 (error ":create not implemented")))))
        (when (and (not created-file) (member direction '(:output :io)))
          (error ":output :io not implemented"))
        (cond ((or (eql element-type :default)
  
negative.code:                  (never (zerop block-n))
                   (follow-pointer disk superblock block-n fn indirection))))))
  
  (defun read-file (disk superblock bgdt inode)
    (let ((blocks))
      (do-file #'(lambda (block)
                   (push block blocks))
        disk superblock bgdt inode)
      (iter (with block-size := (block-size-in-bytes disk superblock))
            (with result := (make-array (list (* block-size (length blocks))) :element-type '(unsigned-byte 8)))
            (for block :in (nreverse blocks))
  