Quadcap Embeddable Database

com/quadcap/sql/file/BlockFile.java

Go to the documentation of this file.

package com.quadcap.sql.file;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;

import java.util.Properties;

import com.quadcap.util.ConfigNumber;
import com.quadcap.util.Debug;
import com.quadcap.util.Util;

import com.quadcap.util.collections.LongMap;

import com.quadcap.crypto.KeyFactory;
import com.quadcap.crypto.SymmetricKey;

import com.quadcap.io.MutableByteArrayInputStream;

import com.quadcap.sql.io.ObjectInputStream;
import com.quadcap.sql.io.ObjectOutputStream;

import com.quadcap.sql.Version;

/**
 * This class is used to create, modify, or read a blocked file.  The blocked
 * file is accessed as a number of fixed size blocks, which are accessed
 * through a cache of a size specified by the class user.
 *
 * @author Stan Bailes
 */

public class BlockFile implements PageManager, SegmentManager {
    /** The underlying store used by the cache to access the file.  */
    BlockStore                  store;

    /** The cache of file blocks. */
    BlockCache                  cache;

    /** For main-memory mode, our objects */
    LongMap                     memoryObjects   = null;
    long                        memObjectCount  = 100000;
    boolean                     inMemory;
    
    static final int            REF_SIZE        = 8;

    static final int            MIN_SUBPAGE     = 64;

    static final int            MAX_PAGESHIFT   = 16;
    
    int                         maxPageShift    = 0;   // default
    
    // Block                    root;
    // root block format:
    // 0: uint16                   magic (4c)
    // 2: uint8                    major version
    // 3: uint8                    minor version
    // 4: uint32                   blockSize
    static final int            oBLOCKSIZE      = 4;

    // 8: uint64 freelist
    static final int            oFREELIST       = 8;

    // 16: uint64 lastBlock
    static final int            oLASTBLOCK      = 16;

    // 24: uint64 streams[4]
    static final int            oSTREAM_START   = 24;
    static final int            MAX_STREAM      = 4;

    // 56: byte[20] hash password
    static final int            oHASH_PASSWD_start
    =                                  oSTREAM_START + (REF_SIZE * MAX_STREAM);
    static final int            oHASH_PASSWD_len = 20;
    // 76: uint64 subroots[16]
    static final int            oSUBPAGE_ROOT
    =                                  oHASH_PASSWD_start + oHASH_PASSWD_len;
    static final int            oHEADER_SIZE    = (oSUBPAGE_ROOT +
                                                   (MAX_PAGESHIFT * REF_SIZE));
    
    int                         blockSize;

    /** Cached copy of largest allocated block number. */    
    long                        lastBlock       = 0;

    boolean                     readOnly;

    PageManager[]               pageManagers    = new PageManager[MAX_PAGESHIFT];
    Object                      fileLock = new Object();

    MutableByteArrayInputStream mbis = new MutableByteArrayInputStream();
    ObjectInputStream ois = new ObjectInputStream(mbis);
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    ObjectOutputStream oos;

    /**
     * Create a new BlockFile, attached to the specified file.  For
     * an existing BlockFile, use the blocksize with which the file was
     * created -- for a new file, use the specified blocksize.
     *
     * @param filename the file to operate on.
     * @param blockSize the block size to use if we're creating a new file.
     * @param mode "r" (read only) or "rw" (read-write) access.
     */
    public BlockFile(String filename, String mode,
                     Properties props,
                     int blocksize,
                     int cacheSize)
        throws IOException
    {
        //#ifndef RELEASE
        if (Trace.bit(4)) {
            Debug.println("BlockFile(" + filename + ", " + mode +
                          ", blockSize = " + blocksize +
                          ", cacheSize = " + cacheSize + ")");
        }
        //#endif
        this.inMemory =
            props.getProperty("memoryOnly", "").equalsIgnoreCase("true");
        pageManagers[0] = this;
        int psize = blocksize;
        maxPageShift = 0;
        while (psize > MIN_SUBPAGE) {
            maxPageShift++;
            psize >>= 1;
        }
        this.readOnly = mode.equalsIgnoreCase("r");
        this.store = makeStore(props, filename, blocksize, mode);
        this.blockSize = store.blockSize();
        this.cache = new BlockCache();
        this.oos = new ObjectOutputStream(bos);
        if (inMemory) {
            this.memoryObjects = new LongMap(8888);
        }
        cache.setLock(fileLock);
        cache.setReadOnly(readOnly);
        cache.init(store, cacheSize);
        Block root = getBlock(0);
        try {
            this.lastBlock = root.readLong(oLASTBLOCK);
        } finally {
            root.decrRefCount();
        }
    }

    //#ifdef DEBUG
    public String signature() throws IOException {
        StringBuffer sb = new StringBuffer("{");
        for (long blk = 0; blk <= lastBlock; blk++) {
            if (blk > 0) sb.append(",");
            Block b = getBlock(blk);
            try {
                sb.append(b.signature());
            } finally {
                b.decrRefCount();
            }
        }
        sb.append("}");
        return sb.toString();
    }
    //#endif

    protected BlockStore makeStore(Properties props, String filename,
                                   int blockSize, String mode)
        throws IOException
    {
        BlockStore s;
        File f = null;
        boolean enc = false;
        boolean nullStore =
            props.getProperty("cacheOnly", "").equalsIgnoreCase("true");
        if (inMemory || nullStore) {
            if (inMemory) {
                s = new MemoryBlockStore();
            } else {
                s = new NullStore();
            }
        } else {
            filename = new File(filename).getAbsolutePath();
            f = new File(filename);
            boolean exists = f.exists();
            if (!exists && readOnly) {
                throw new IOException("Not found: " + filename);
            }
            String u = props.getProperty("user",
                                         props.getProperty("jdbc.user", ""));
            String p = props.getProperty("passwd",
                                         props.getProperty("jdbc.passwd", ""));
            /*{com.quadcap.sql.Datafile-conn.xml-70}
             * <config-var>
             *   <config-name>encrypt</config-name>
             *   <config-dflt>false</config-dflt>
             *   <config-desc>On database creation (i.e., datafile doesn't yet
             *      exist and 'create=true'), if
             *      <code>encrypt == <b>true</b></code>, then a low-level
             *      block encryption algorithm (the default is Rijndael)
             *      will be selected, seeded with the values of the
             *      <code>user</code> and <code>passwd</code> properties for
             *      this, connecting, user.  The database magic code will
             *      be changed from <code> 04 0c </code> to <code> 0e 0c </code>
             *      to signal the encrypted content.
             *      </config-desc>
             * </config-var>
             */
            boolean encrypt =
                props.getProperty("encrypt", "").equalsIgnoreCase("true");
            enc = (exists && isEncrypted(f)) || (!exists && encrypt);
            if (enc) {
                s = new EncryptedBlockStore();
            } else {
                s = new BlockStore();
            }
        }
        s.init(f, mode, blockSize, fileLock);
        if (enc) {
            String u = props.getProperty("user",
                                         props.getProperty("jdbc.user", ""));
            String p = props.getProperty("passwd",
                                         props.getProperty("jdbc.passwd", ""));
            SymmetricKey key = KeyFactory.createSymmetricKey(u + "/" + p);
            s.setKey(key);
        }
        return s;
    }

    private boolean isEncrypted(File f) throws IOException {
        FileInputStream fi = new FileInputStream(f);
        try {
            return fi.read() == 0x0e;
        } finally {
            fi.close();
        }
    }

    public long getUserBlock(int stream) throws IOException {
       synchronized (fileLock) {
           if (stream > MAX_STREAM) {
               throw new IOException("Invalid stream: " + stream);
           }
           Block root = getBlock(0);
           long blockNum;
           int offset = oSTREAM_START + (stream * REF_SIZE);
           try {
               blockNum = root.readLong(offset);
               if (blockNum == 0) {
                   blockNum = newPage();
                   root.writeLong(offset, blockNum);
               }
           } finally {
               root.decrRefCount();
           }
           return blockNum;
       }
    }

    /**
     * Flush the cache and close the underlying file.
     */
    public void close() throws IOException {
        synchronized (fileLock) {
            flush(false);
            store.close();
        }
    }

    public final void flush(boolean fastSync) throws IOException {
        synchronized (fileLock) {
            //#ifdef DEBUG
            if (Trace.bit(24)) {
                Debug.println(toString() + ".flush(" + fastSync + ")");
            }
            //#endif
            if (!readOnly) {
                cache.flush();
                if (!fastSync) {
                    store.flush();
                }
            }
        }
    }

    public String getName() {
        return store.getName();
    }

    public void setLog(Log log) {
        store.setLog(log);
    }

    Log getLog() {
        return store.getLog();
    }

    /**
     * Locate the specified block and return the cache entry associated
     * with that block.  It needs to be the case that the cache entry is
     * "locked" while this returned object is active, so maybe the
     * <b>Block</b> class needs a <b>finalize()</b> routine.
     * @param i the block number
     * @return the cache-handle of the block.
     */
    public Page getPage(long i) throws IOException {
        synchronized (fileLock) {
            if (i > lastBlock) {
                //#ifdef DEBUG
                Debug.println(toString() + ".getPage(" + i + "): Bad Block " +
                              " vs lastBlock = " + lastBlock);
                //#endif
                throw new IOException("BlockFile(" + store + 
                                      "), Bad block: " + i + " (" +
                                      SubPageManager.toString(i) + ")");
            }
            return (Page)cache.getCacheable(i);
        }
    }

    public Block getBlock(long i) throws IOException {
        return (Block)getPage(i);
    }

    public void restoreBlock(long b, byte[] buf, int off) throws IOException {
        ensureLastBlock(b);
        store.restore(b, buf, off);
    }

    final void ensureLastBlock(long i) throws IOException {
        if (i > lastBlock) {
            lastBlock = i;
            Block root = getBlock(0);
            try {
                root.writeLong(oLASTBLOCK, i);
            } finally {
                root.decrRefCount();
            }
        }
    }
    

    /**
     * Return the block size used in this file.
     */
    public final int getPageSize() {
        return this.blockSize;
    }

    /**
     * Return a RandomAccess object which references the specified block
     */
    public RandomAccess getStream(long blockRef) throws IOException {
        PageManager p = getPageManagerForPage(blockRef);
        return new BlockAccess(p, blockRef);
    }

    /**
     * Return the head of the free list, or grow the tail of the file.
     * @return the number of an available block.
     */
    public long newPage() throws IOException {
        synchronized (fileLock) {
            Block root = getBlock(0);
            long ref;
            try {
                ref = root.readLong(oFREELIST);
                if (ref < 0 || ref > lastBlock) {
                    throw new IOException(this + "newPage(), bad ref: " +
                                          ref + ", lastBlock = " +
                                          lastBlock);
                }
                if (ref != 0) {
                    Block newPage = getBlock(ref);
                    try {
                        root.writeLong(oFREELIST, newPage.readLong(0));
                        //newPage.writeLong(0, 0);
                        newPage.clear();
                    } finally {
                        newPage.decrRefCount();
                    }
                } else {
                    ref = root.readLong(oLASTBLOCK);
                    Block newPage = getBlock(ref);
                    try {
                        newPage.clear();
                    } finally {
                        newPage.decrRefCount();
                    }
                    lastBlock = ref + 1;
                    root.writeLong(oLASTBLOCK, lastBlock);
                }
            } finally {
                root.decrRefCount();
            }
            //#ifdef DEBUG
            if (Trace.bit(5)) {
                Debug.println(toString() + ".newPage() = " + ref + "");
            }
            //#endif
            return ref;
        }
    }

    /**
     * Add this block to the free list.
     *
     * @param ref the number of the now free block.
     */
    public void freePage(long ref) throws IOException {
        PageManager p = getPageManagerForPage(ref);
        if (p != this) {
            p.freePage(ref);
        } else synchronized (fileLock) {
            //#ifdef DEBUG
            if (Trace.bit(5)) {
                Debug.println(toString() + ".freePage(" + ref + ")");
            }
            //#endif
            if (ref <= 0 || ref > lastBlock) {
                throw new IOException("bad ref");
            }
            Block blk = getBlock(ref);
            try {
                blk.getDataAndReset();
        
                Block root = getBlock(0);
                try {
                    long freeList = root.readLong(oFREELIST);
                    blk.writeLong(0, freeList);
                    root.writeLong(oFREELIST, ref);
                } finally {
                    root.decrRefCount();
                }
            } finally {
                blk.decrRefCount();
            }
        }
    }

    static int getPageOffset(PageManager pm, long ref) {
        int psize = pm.getPageSize();
        int pnum = (int)(SubPageManager.fExt(ref, SubPageManager.PAGE_NUM));
        return pnum * psize;
    }

    static long getPageBlock(long ref) {
        return SubPageManager.pageBlock(ref);
    }

    static final boolean quick = true;
    
    /**
     * Create a new segment with the specified bytes value and return
     * its reference
     *
     * @param buf the value to write to the new segment
     * @return the segment id
     */
    public long putBytes(byte[] buf) throws IOException {
        PageManager pm = getPageManagerForLen(buf.length);
        long seg = pm.newPage();
        if (quick && (buf.length + 8) < pm.getPageSize()) {
            int off =  getPageOffset(pm, seg);
            long blk = getPageBlock(seg);
            synchronized (fileLock) {
                Block b = getBlock(blk);
                try {
                    b.writeLong(off, buf.length);
                    b.write(off+8, buf, 0, buf.length);
                } finally {
                    b.decrRefCount();
                }
            }
        } else {
            synchronized (fileLock) {
                ba.init(pm, seg);
                ba.resize(buf.length);
                ba.write(0, buf, 0, buf.length);
            }
        }
//         Debug.println("BlockFile.putBytes(" + SubPageManager.toString(seg) + "): " +
//                       Util.strBytes(buf, 0, 16));
//         Debug.println(Util.stackTrace());
        return seg;
    }

    BlockAccess ba = new BlockAccess();
    
    /**
     * Return the segment as a byte array
     *
     * @param seg the segment id
     * @return the value of the segment's bytes
     */
    public byte[] getBytes(long seg) throws IOException {
        PageManager pm = getPageManagerForPage(seg);
        byte[] buf = null;
        int off = getPageOffset(pm, seg);
        long blk = getPageBlock(seg);
        synchronized (fileLock) {
            if (quick) {
                Block b = getBlock(blk);
                try {
                    int len = (int)b.readLong(off);
                    if (len + 8 < pm.getPageSize()) {
                        buf = new byte[len];
                        b.read(off+8, buf, 0, len);
                    }
                } finally {
                    b.decrRefCount();
                }
            }
            if (buf == null) {
                ba.init(pm, seg);
                buf = new byte[(int)(ba.size())];
                ba.read(0, buf, 0, buf.length);
            }
        }
//         Debug.println("BlockFile.getBytes(" +
//                       SubPageManager.toString(seg) + "): " +
//                       Util.strBytes(buf, 0, 16) + " @ " + Util.stackTrace());
        return buf;
    }
        

    /**
     * Update a segment with new value bytes.
     *
     * @param buf the value to write to the segment
     * @param seg the segment id
     */
    public void updateBytes(long seg, byte[] buf) throws IOException {
//         Debug.println("BlockFile.updateBytes(" + SubPageManager.toString(seg) +
//                       "): " + Util.strBytes(buf, 0, 16));
//         Debug.println(Util.stackTrace());
        PageManager pm = getPageManagerForPage(seg);
        synchronized (fileLock) {
            if (quick && (buf.length + 8) < pm.getPageSize()) {
                Block b = getBlock(getPageBlock(seg));
                try {
                    int off = getPageOffset(pm, seg);
                    long oldLen = b.readLong(off);
                    if ((oldLen + 8) < pm.getPageSize()) {
                        b.writeLong(off, buf.length);
                        b.write(off+8, buf, 0, buf.length);
                        return;
                    }
                } finally {
                    b.decrRefCount();
                }
            }
            
            ba.init(pm, seg);
            if (ba.size() != buf.length) {
                ba.resize(buf.length);
            }
            ba.write(0, buf, 0, buf.length);
        }
    }

    /**
     * Destroy the stream with the specified root page and free up the
     * storage it was using.
     *
     * @param page the root page of the region
     *
     * @exception IOException if the page number isn't valid, or if another
     *          error is detected trying to access the region.
     */
    public void freeStream(long page) throws IOException {
        synchronized (fileLock) {
            getStream(page).resize(0);
            freePage(page);
        }
    }
    public void freeSegment(long seg) throws IOException {
        freeStream(seg);
    }
    
    /**
     * Return a new input stream, reading from the region with the specified
     * root block.
     *
     * @param block the root block of the region
     * @return an InputStream bound to the region.
     * @exception IOException if the block number isn't valid, or if another
     *          error is detected trying to access the region.
     */
    public RandomAccessInputStream getInputStream(long block) 
        throws IOException 
    {
        return new RandomAccessInputStream(getStream(block));
    }

    /**
     * Return a new output stream, writing to the region with the specified
     * root block.
     *
     * @param block the root block of the region
     * @return an OutputStream bound to the region.
     * @exception IOException if the block number isn't valid, or if another
     *          error is detected trying to access the region.
     */
    public RandomAccessOutputStream getOutputStream(long block) 
        throws IOException 
    {
        return new RandomAccessOutputStream(getStream(block));
    }   

    /**
     * Return the specified sub-page manager
     */
    public PageManager getPageManager(int i) throws IOException {
        if (i < 0 || i > maxPageShift) {
            throw new IOException("Bad page shift: " + i);
        }
        PageManager pm = pageManagers[i];
        if (pm == null) {
            pageManagers[i] = pm = new SubPageManager(this, i, 0);
        }
        return pm;
    }

    public PageManager getPageManagerForPage(long page) throws IOException {
        return getPageManager(SubPageManager.pageShift(page));
    }

    public PageManager getPageManagerForLen(long len) throws IOException {
        int pageShift = 0;
        int siz = blockSize >> 1;
        while (len < siz && pageShift < maxPageShift-1) {
            siz >>= 1;
            pageShift++;
        }
        if (pageShift > 0) {
            pageShift--;
        }
        return getPageManager(pageShift);
    }

    public void revert() throws IOException {
        cache.revert();
        Block root = getBlock(0);
        try {
            this.lastBlock = root.readLong(oLASTBLOCK);
        } finally {
            root.decrRefCount();
        }
        store.setLength(this.lastBlock * blockSize);
    }
    
    public void showCache(PrintWriter os) {
        cache.show(os);
    }

    public String toString() {
        return "BlockFile(" + store + ")";
    }

    public void clearModified() throws IOException {
        store.clearModified();
    }

    public long getSize() {
        return lastBlock * blockSize;
    }

    public Object getLock() {
        return fileLock;
    }

    public int getBlockSize() {
        return blockSize;
    }


    
    /**
     * Return the specified persistent object from the store
     * @param ref the block number of the object's root
     * @return the object
     * @exception IOException may be thrown
     */
    public Object getObject(long ref) throws IOException {
        Object ret = null;
        synchronized (fileLock) {
            if (inMemory) {
                ret = memoryObjects.get(ref);
            } else {
                try {
                    byte[] buf = getBytes(ref);
                    mbis.reset(buf);
                    ret = ois.readObject();
                } catch (ClassNotFoundException e) {
                    throw new DatafileException(e);
                }
            }
        }
        //Debug.println(this + ".getObject(" + ref + "): " + ret);
        return ret;
    }


    /**
     * Write a new object to the store and return its reference
     * @param obj the object
     * @return the block number of the object's root
     * @exception IOException may be thrown
     */
    public long putObject(Object obj) throws IOException {
        synchronized (fileLock) {
            if (inMemory) {
                memoryObjects.put(++memObjectCount, obj);
                //Debug.println(this + ".put(" + obj + ") = " + memObjectCount);
                return memObjectCount;
            }
            bos.reset();
            oos.writeObject(obj);
            oos.flush();
            byte[] buf = bos.toByteArray();
            long ret = putBytes(buf);
            return ret;
        }
    }

    /**
     * Write a new version of a persistent object to the store.
     * @param blockNum the address of the object's root page in the store
     * @param obj the new object value
     *
     * @exception IOException may be thrown
     */
    public void updateObject(long seg, Object obj) throws IOException {
        //Debug.println(this + ".updateObject(" + seg + "): " + obj);
        synchronized (fileLock) {
            if (inMemory) {
                memoryObjects.put(seg, obj);
            } else {
                bos.reset();
                oos.writeObject(obj);
                oos.flush();
                byte[] buf = bos.toByteArray();
                updateBytes(seg, buf);
            }
        }
    }

    /**
     * Remove an object from the store
     * @param ref the block number of the object's root
     *
     * @exception IOException may be thrown
     */
    public void removeObject(long ref) throws IOException {
        //Debug.println(toString() + ".removeObject(" + ref + ")");
        synchronized (fileLock) {
            if (inMemory) {
                memoryObjects.remove(ref);
            } else {
                freeSegment(ref);
            }
        }
    }



//#ifdef DEBUG
    public void dump() throws IOException {
        Block root = getBlock(0);
        try {
            Debug.println("Magic:         " +
                          Integer.toHexString(root.readShort(0)));
            Debug.println("Major version: " + root.readByte(2));
            Debug.println("Minor version: " + root.readByte(3));
            Debug.println("Block Size:    " + root.readInt(oBLOCKSIZE));
            Debug.println("FreeList:      " + root.readLong(oFREELIST));
            java.util.BitSet free = new java.util.BitSet();
            for (long ref = root.readLong(oFREELIST); ref != 0; ) {
                free.set((int)ref);
                Block newPage = getBlock(ref);
                try {
                    ref = newPage.readLong(0);
                } finally {
                    newPage.decrRefCount();
                }
            }
            int first = -2;
            int last = -2;
            for (int i = free.nextSetBit(0); i >= 0; i = free.nextSetBit(i+1)) {
                if (i != last+1) {
                    if (first >= 0) {
                        if (first == last) {
                            Debug.println("Free: " + first);
                        } else {
                            Debug.println("Free: " + first + " - " + last);
                        }
                    }
                    first = i;
                    last = i;
                }
            }
            if (first >= 0) {
                if (first == last) {
                    Debug.println("Free: " + first);
                } else {
                    Debug.println("Free: " + first + " - " + last);
                }
            }
            long lastBlock_ = root.readLong(oLASTBLOCK);
            Debug.println("Last Block:    " + root.readLong(oLASTBLOCK));
            long waste = free.cardinality() * blockSize;
            long total = lastBlock_ * blockSize;
            double pct = 100 * ((double)waste) / ((double)total);
            String pcts = java.text.NumberFormat.getInstance().format(pct);
            Debug.println("Fragmentation: " + free.cardinality() + " of " +
                          lastBlock_ + " blocks =  " + pcts + "% waste");
            Debug.println("Last Block:    " + root.readLong(oLASTBLOCK));
            for (int i = 0; i < MAX_STREAM; i++) {
                Debug.println("Stream " + i + ":      " +
                              root.readLong(oSTREAM_START + i*REF_SIZE));
            }
            byte[] hp = new byte[oHASH_PASSWD_len];
            root.read(oHASH_PASSWD_start, hp, 0, oHASH_PASSWD_len);
            Debug.println("Hash Passwd:   " + Util.hexBytes(hp));
            for (int i = 0; i < 16; i++) {
                Debug.println("PM " + i + " root:    " +
                              SubPageManager.toString(root.readLong(oSUBPAGE_ROOT + i * REF_SIZE)));
            }
        } finally {
            root.decrRefCount();
        }
    }
    public static void main(String[] args) {
        try {
            BlockFile f = new BlockFile(args[0], "r",
                                        new Properties(),
                                        8192, 256);
            f.dump();
        } catch (Throwable t) {
            Debug.print(t);
        }
    }

    //#endif
}