Quadcap Embeddable Database

com/quadcap/sql/file/Log1.java

Go to the documentation of this file.

package com.quadcap.sql.file;

/* Copyright 1999 - 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.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import javax.concurrent.BoundedBuffer;
import javax.concurrent.Channel;
import javax.concurrent.Latch;

import com.quadcap.sql.lock.Transaction;
import com.quadcap.sql.lock.TransactionObserver;

import com.quadcap.util.collections.LongMap;

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

/**
 * Rolling write-ahead log implementation.  Checkpoints plus physical logging
 * of block writes is coupled with logical logging to support transactions
 * rollback and recovery.
 *
 * @author Stan Bailes
 */
public class Log1 implements Log {
    /** the database we're logging for */
    private Datafile            db;

    /** the database file we're logging for */
    private BlockFile           dbFile;

    /** Log writer/reader */
    Logger                      logger;

    /** log file directory */
    private File                dbRootDir;

    /** log sync thread */
    LogSync                     logSync;

    /** log sync thread done, close interlock */
    Latch                       closeLatch = new Latch();

    /** producer/consumer conduit */

    /** our datatbase's file lock */
    Object                      fileLock;

    /** Map rows during recovery, null otherwise. */
    LongMap                     rowIdMap        = new LongMap(256);

    /** "before-images" file */
    FileOutputStream            bfo;
    boolean                     bfoActive       = false;

    boolean                     recovering      = false;

    int                         blockSize;

    /*{com.quadcap.util.Config-vars.xml-1020}
     * <config-var>
     *   <config-name>qed.minSyncInterval</config-name>
     *   <config-dflt>15000 (15 seconds)</config-dflt>
     *   <config-desc>The minimum interval (in ms) between database
     *    sync operations.</config-desc>
     * </config-var>
     */
    long                        minSyncInterval
    =                   ConfigNumber.find("qed.minSyncInterval", "15000").longValue();

    /*{com.quadcap.util.Config-vars.xml-1021}
     * <config-var>
     *   <config-name>qed.maxSyncInterval</config-name>
     *   <config-dflt>60000 (60 seconds)</config-dflt>
     *   <config-desc>The maximum interval (in ms) between database
     *     sync operations. Use this to help
     *     limit the logfile, scratch, and before-images files.
     *  </config-desc>
     * </config-var>
     */
    long                        maxSyncInterval
    =                   ConfigNumber.find("qed.maxSyncInterval", "60000").longValue();

    int syncMap = 0 +
    (1 << 1) +                  // flush -> before.sync
    (1 << 2) +                  // flush -> logger.sync
//    (1 << 3) +                  // flush -> db.tempFile.flush()
    (1 << 4) +                  // checkpoint -> dbfile.flush(fastSync)
    (1 << 5) +                  // checkpoint -> logger.sync
    (1 << 6) +                  // checkpoint -> db.checkpoint(fastSync)
    (1 << 7) +                  // save block -> store.sync
    0;
    
    //#ifdef DEBUG
    String[] syncStrs = {
        "Log1.reallyFlush from Log2.flushLog",
        "Log1.reallyFlush: bfo.sync()",
        "Log1.reallyFlush: logger.sync()",
        "Log1.reallyFlush: db.tempFile.flush(!)",
        "Log1.reallyCheckpoint: dbfile.flush(!)",
        "Log1.reallyCheckpoint: logger.sync()",
        "Log1.reallyCheckpoint: dbfile.checkpoint(!)",
        "Log1.saveBlock: bfo.sync"
    };

    int[] syncCnts = new int[syncStrs.length];
    //#endif
    protected boolean checksync(int x) {
        //#ifdef DEBUG
        syncCnts[x]++;
        //Debug.println("checkSync[" + ret + ": " + syncCnts[x] + " - " + syncStrs[x]);
        //#endif
        boolean ret = (syncMap & (1 << x)) != 0;
        return ret;
    }

    /**
      * Constructor for transaction log
      *
      */
    public Log1() {}

    /**
     * Initialize the log
     *
     * @param db the underlying database that we're logging for.
     * @param create true if we're creating this database from scratch,
     *               in which case we can skip any recovery-related activity
     */
    public void init(Datafile db, boolean create, Properties props)
        throws IOException
    {
        this.db = db;
        this.dbFile = db.file;
        this.blockSize = dbFile.getBlockSize();
        this.dbRootDir = db.dbRootDir;
        this.fileLock = db.getFileLock();
        /*{com.quadcap.sql.Datafile-conn.xml-23}
         * <config-var>
         *   <config-name>fastSync</config-name>
         *   <config-dflt>true</config-dflt>
         *   <config-desc>If <code>true</code>, omit time-consuming
         *    sync operations to permit greater throughput.
         *   </config-desc>
         * </config-var>
         */
//          this.fastSync =
//              props.getProperty("fastSync",
//                                String.valueOf(fastSync)).equalsIgnoreCase("true");

        /*{com.quadcap.sql.Datafile-conn.xml-25}
         * <config-var>
         *   <config-name>minSyncInterval</config-name>
         *   <config-dflt>from config:qed.minSyncInterval</config-dflt>
         *   <config-desc>Minimum interval between syncs.  Set to zero to
         *     ensure a sync after every transaction.</config-desc>
         * </config-var>
         */
        this.minSyncInterval =
            Long.parseLong(props.getProperty("minSyncInterval",
                                             String.valueOf(minSyncInterval)));

        /*{com.quadcap.sql.Datafile-conn.xml-26}
         * <config-var>
         *   <config-name>maxSyncInterval</config-name>
         *   <config-dflt>from config:qed.maxSyncInterval</config-dflt>
         *   <config-desc>Maximum interval between syncs.  Use this to help
         *     limit the logfile, scratch, and before-images files.
         *   </config-desc>
         * </config-var>
         */
        this.maxSyncInterval =
            Long.parseLong(props.getProperty("maxSyncInterval",
                                             String.valueOf(maxSyncInterval)));

        // Gonna leave this undocumented for now since there's only
        // one instance of this class....  Too many knobs.
        String loggerClass = props.getProperty("loggerClass");
        try {
            this.logger = (Logger)(Class.forName(loggerClass).newInstance());
        } catch (Throwable t) {
            this.logger = new Logger1();
        }
        logger.init(this, create, props);

    }

    public void start() {
        logSync = new LogSync(this);
        logSync.setDaemon(true);
        logSync.start();
    }

    public void remove() throws IOException {
        new File(dbRootDir, "logfile").delete();
    }

    /**
     * Return the database that we're logging for
     */
    public Datafile getDatafile() { return db; }

    /**
     * Return the database root directory
     */
    public File getDbRootDir() { return dbRootDir; }

    /**
     * Add a transaction's log record to the end of the open log file
     */
    int pendingBegins = 0;
    public void addEntry(LogEntry entry)
        throws IOException
    {
        if (entry.getCode() == LogEntry.BEGIN_TRANSACTION) {
            pendingBegins++;
        }
        put(entry);
    }
    
    /**
     * Flush and close the log file.
     */
    public void close() throws IOException {
        put(opClose);
        try {
            closeLatch.acquire();
        } catch (InterruptedException ex) {
        }
    }
    
    /**
     * Flush all log records to disk.  Action not performed on this
     * thread, we're in a hurry....
     */
    public void flushLog() throws IOException {
        put(opFlush);
    }

    /**
     * Perform a checkpoint operation.
     */
    public void checkpoint() throws IOException {
        put(opCheckpoint);
    }

    /**
     * Wait for all queued ops to be processed by the log sync thread
     */
    public void sync() throws IOException {
        Latch latch = new Latch();
        put(new Sync(latch));
        try {
            latch.acquire();
        } catch (InterruptedException ex) {
        }
    }

    /**
     * Transaction rollback.
     */
    public void rollbackTransaction(Transaction trans)
        throws IOException
    {
        put(new Rollback(trans));
        sync();
    }
        
    /**
     * Statement rollback.
     */
    public void rollbackStatement(Transaction trans, int stmtId)
        throws IOException
    {
        put(new Rollback(trans, stmtId));
        sync();
    }

    /**
     * Restart from a previous state
     */
    public void restart() throws Exception {
        reallyRestart();
    }

    //------------------------------------------------------------------

    /**
     * Retrieve a row mapping.
     */
    public final long getRowMap(long rowId) {
        long ret = rowId;
        if (rowIdMap != null) {
            Long mapped = (Long)rowIdMap.get(rowId);
            if (mapped != null) ret = mapped.longValue();
        }
        return ret;
    }

    /**
     * Remember a row mapping {old,new}  The old row (logRow) is now stored
     * in a new place (fileRow), so any stored log entries that refer to
     * the old row need to be translated to use the new row.
     *
     * @param logRow the "old" row
     * @param fileRow the "new" row
     */
    public final void putRowMap(long logRow, long fileRow) {
        if (rowIdMap == null) rowIdMap = new LongMap(256);
        rowIdMap.put(logRow, new Long(fileRow));
    }

    public final void removeRowMap(long row) {
        if (rowIdMap != null) rowIdMap.remove(row);
    }

    void reallyFlush() throws IOException {
        //#ifdef DEBUG
        if (Trace.bit(18)) {
            Debug.println(this + ".reallyFlush()");
        }
        //#endif
        if (checksync(2)) logger.sync();
        if (db.tempFile != null) {
            db.tempFile.flush(!checksync(3));
        }
    }
    
    void reallyClose() throws IOException {
        try {
            if (logSync != null) {
                logSync.close();
            }
        } finally {
            logSync = null;
            if (bfo != null) {
                try {
                    bfo.close();
                } finally {
                    bfo = null;
                }
            }
        }
    }

    void reallyRollbackTransaction(Transaction tr) throws Exception {
        //#ifdef DEBUG
        if (Trace.bit(18)) {
            Debug.println("reallyRollbackTransaction(" + tr + ")");
        }
        //#endif
        long t = tr.getTransactionId();
        LogEntry e = logger.getLastOp(t);
        try {
            while (e != null) {
                //Debug.println("    e = " + e);
                if (e.getTransactionId() == t) {
                    switch (e.getCode()) {
                    case LogEntry.STEP:
                        if (e.getRedoState() == LogEntry.DONE) {
                            try {
                                e.undo(tr, db);
                            } catch (Throwable th) {
                                //#ifdef DEBUG
                                Debug.println("Exception in rollback transaction");
                                Debug.print(th);
                                //#endif
                            }
                            logger.setRedoState(e, LogEntry.UNDONE);
                        }
                        break;
                    case LogEntry.BEGIN_TRANSACTION:
                        e = null;
                        break;
                    default:
                        break;
                    }
                }
                e = (e == null || e.getPrev() < 0) ? null : logger.getPrevOp(e);
            }
        } finally {
            rowIdMap = null;
        }
    }
    
    void reallyRollbackStatement(Transaction tr, int s) throws Exception {
        long t = tr.getTransactionId();
        LogEntry e = logger.getLastOp(t);
        rowIdMap = null;
        try {
            while (e != null) {
                if (e.getStatementId() == s) {
                    switch (e.getCode()) {
                    case LogEntry.STEP:
                        if (e.getRedoState() == LogEntry.DONE) {
                            try {
                                e.undo(tr, db);
                            } catch (Throwable th) {
                                //#ifdef DEBUG
                                Debug.println("Exception in statement rollback");
                                Debug.print(th);
                                //#endif
                            }
                            logger.setRedoState(e, LogEntry.UNDONE);
                        }
                        break;
                    case LogEntry.BEGIN_STATEMENT:
                        //Debug.println("--- end rollbackStatement(" + tr + "," +
                        //              s + ")");
                        return;
                    default:
                        break;
                    }
                }
                e = logger.getPrevOp(e);
            }
        } finally {
            rowIdMap = null;
        }
    }
    
    LogEntry scanLog(LongMap t) throws IOException {
        LogEntry op = logger.getFirstOp();
        LogEntry last = op;
        for (; op != null; last = op, op = logger.getNextOp()) {
            LogEntry e = op;
            if (e != null && e.getCode() == LogEntry.COMMIT) {
                //Debug.println("  [T:" + e.getTransactionId() + " committed]");
                t.put(e.getTransactionId(), "");
            }
        }
        return last;
    }
    
    void reallyRestart() throws Exception {
        //#ifdef DEBUG
        if (Trace.bit(18)) {
            Debug.println(toString() + ".reallyRestart()");
        }
        //#endif
        db.getTempFile(false);          // recover the scratch file.
        Transaction t = db.makeTransaction(false); 
        LongMap map = new LongMap(32);
        LogEntry last = scanLog(map);
        int q = 0;
        int checkpointPosition = logger.getCheckpoint();
        int endPosition = logger.getEnd();
        LogEntry op = last;
        recovering = true;
        try {
            for (; op != null; op = logger.getPrevOp(op)) {
                LogEntry e = op;
                if (e != null && e.getCode() == LogEntry.STEP &&
                    e.getPosition() < checkpointPosition &&
                    map.get(e.getTransactionId()) == null) {
                    if (e.getRedoState() == LogEntry.DONE) {
                        //#ifdef DEBUG
                        if (Trace.bit(18)) {
                            Debug.println("UNDO[" + e + "]");
                        }
                        //#endif
                        if (q++ == 0) {
                            Debug.println("Undoing in-progress transactions...");
                        }
                        e.undo(t, db);
                    }       
                }
            }
            rowIdMap = null;

            int p = 0;
            for (op = logger.getFirstOp(); op != null; op = logger.getNextOp()) {
                LogEntry e = op;
                if (e.getPosition() >= endPosition) break;
                if (e != null && map.get(e.getTransactionId()) != null) {
                    if (e.getCode() == LogEntry.STEP) {
                        if (e.getRedoState() == LogEntry.DONE) {
                            if (p++ == 0) {
                                Debug.println("Restoring committed transactions: " + map);
                            }
                            //#ifdef DEBUG
                            if (Trace.bit(18)) {
                                Debug.println("REDO[" + e + "]");
                            }
                            //#endif
                            e.redo(t, db);
                        }
                    }
                }
            }
            rowIdMap = null;
        
            if (p > 0 || q > 0) {
                Debug.println("Recovery complete: " +
                              p + " redos, " +
                              q + " undos");
            }
            logger.reset();
            logger.sync();
            if (p > 0 || q > 0) {
                checkpoint();
            }
        } finally {
            recovering = false;
        }
    }

    long lastCheckpoint = System.currentTimeMillis();
    
    void maybeCheckpoint() throws IOException {
        long now = System.currentTimeMillis();
        boolean idle = logger.getActiveTransactionCount() == 0;
        if (idle) rowIdMap = null;
        long interval = idle ? minSyncInterval : maxSyncInterval;
        if (now - lastCheckpoint >= interval) {
            //#ifdef DEBUG
            if (Trace.bit(25)) {
                Debug.println("[" + entryCount + BlockStore.rw() +
                              "] interval " + (now - lastCheckpoint) +
                              " ms," + (idle ? " IDLE" : "") +
                              " checkpoint now");
            }
            //#endif

            reallyCheckpoint();

            //#ifdef DEBUG
            if (Trace.bit(25)) {
                Debug.println("checkpoint done");
            }
            //#endif
        }
    }

    void reallyCheckpoint() throws IOException {
        try {
            db.flushRoot();
            dbFile.flush(!checksync(4));
            logger.checkpoint();

            int numTrans = logger.getActiveTransactionCount();
            boolean truncate = pendingBegins == 0 && numTrans == 0;
            if (truncate) {
                logger.reset();
            }
            logger.sync();
            db.checkpoint(truncate, !checksync(6));
            db.checkpointHandler(logger.getActiveTransactions());
            dbFile.clearModified();
        } finally {
            lastCheckpoint = System.currentTimeMillis();
            rowIdMap = null;
        }
        //#ifdef DEBUG
        if (Trace.bit(21)) {
            Debug.println("AFTER Log1.reallyCheckpoint: [" +
                          logger.getActiveTransactionCount() + "]");
        }
        if (false) {
            long sum = 0;
            long blk = dbFile.getBlockSize();
            for (long x = 0; x < dbFile.getSize(); x += blk) {
                Block b = dbFile.getBlock(x / blk);
                for (int ix = 0; ix < blk; ix += 8) {
                    sum += b.readLong(ix);
                }
                b.decrRefCount();
            }
            Debug.println("CHECKPOINT: CHECKSUM(" + dbFile.getSize() + ") bytes = " +
                          sum);
        }
        //#endif
    }

    //#ifdef DEBUG
    int entryCount = 0;
    //#endif
    
    public void reallyAddEntry(LogEntry entry) throws IOException {
        //#ifdef DEBUG
        entryCount++;
        if (Trace.bit(16)) {
            Debug.println(toString() + ".reallyAddEntry(" + entry + ")");
        }
        //#endif
        try {
            logger.put(entry);
            if (entry.getCode() == LogEntry.BEGIN_TRANSACTION) {
                pendingBegins--;
            }
        } catch (IOException ex) {
            if (ex.toString().indexOf("full") > 0) {    // XXX need better way
                abortOldestTransaction(entry);
                logger.put(entry);
            } else {
                throw ex;
            }
        }
    }

    private void sortEntry(long tId, List save, List discard, LogEntry e) {
        if (e.getTransactionId() == tId) {
            discard.add(e);
        } else {
            save.add(e);
        }
    }

    private final void abortOldestTransaction(LogEntry entry)
        throws IOException
    {
        long tId = logger.getOldestTransaction();
        Transaction t = db.findTransaction(tId);
        if (t == null) {
            Debug.println("Log full, will reset log");
            logger.reset();
            // XXX should this ever happen, we might
            // XXX be better off if we aborted all the active transactions
        } else {
            ArrayList save = new ArrayList();
            Debug.println("Log full, will abort " + t);
            try {
                // First retrieve all of the pending log entries.  There
                // may be some for the doomed transaction -- we'll undo
                // those first.
                ArrayList discard = new ArrayList();
                LogEntry e;
                while ((e = (LogEntry)channel.poll(0)) != null) {
                    sortEntry(tId, save, discard, e);
                }
                sortEntry(tId, save, discard, entry);
                Debug.println("discarding " + discard.size() +
                              " completed log entries");
                for (int i = discard.size() - 1; i >= 0; i--) {
                    e = (LogEntry)discard.get(i);
                    try {
                        e.undo(t, db);
                    } catch (Throwable th) {
                        //#ifdef DEBUG
                        Debug.println("Error during abort oldest");
                        Debug.print(th);
                        //#endif
                    }
                }
                reallyRollbackTransaction(t);
            } catch (IOException ex1) {
                throw ex1;
            } catch (Exception ex2) {
                //#ifdef DEBUG
                Debug.print(ex2);
                //#endif
                throw new DatafileException(ex2);
            }
            TransactionObserver obs = t.getObserver();
            if (obs != null) {
                obs.abort(t);
            }
            reallyCheckpoint();
            // After we've cleaned up the mess from the aborted transaction,
            // we need to handle all of the queued log entries that we
            // consumed.
            Debug.println("handling " + save.size() + " saved log entries");
            for (int i = 0; i < save.size(); i++) {
                LogEntry e = (LogEntry)save.get(i);
                try {
                    e.handle(this);
                } catch (Throwable th) {
                    Debug.print(th);
                }
            }
        }
    }

    /**
     * XXXX Problem: If you have "the lock" and you call this when the channel
     * is full, you may block.  This would be bad, because it might block
     * the log thread trying to get the lock, leading to deadlock
     */
    public void put(LogEntry h) throws IOException {
        while (true) {
            try {
                channel.put(h);
            } catch (InterruptedException ex) {
                continue;
            }
            return;
        }
    }

    /**
     * Inner class to bind Flush op to 'log.reallyFlush()' method.
     */
    public static class Flush extends LogEntry {
        public Flush() { super(FLUSH); }
        public void handle(Log log) throws IOException {
            ((Log1)log).reallyFlush();
        }
    }

    /**
     * A single static instance of this op is all we need.
     */
    static Flush opFlush = new Flush();

    /**
     * Inner class to bind Checkpoint op to 'log.reallyCheckpoint' method
     */
    public static class Checkpoint extends LogEntry {
        public Checkpoint() { super(CHECKPOINT); }
        public void handle(Log log) throws IOException {
            ((Log1)log).reallyCheckpoint();
        }
    }
    static Checkpoint opCheckpoint = new Checkpoint();

    /**
     * Inner class to bind Close op to 'log.reallyClose()' method
     */
    public static class Close extends LogEntry {
        public Close() { super(CLOSE); }
        public void handle(Log log) throws IOException {
            ((Log1)log).reallyClose();
        }
    }

    /**
     * A single static instance of this op is all we need.
     */
    static Close opClose = new Close();

    /**
     * Inner class for transaction/statement rollback
     */
    public class Rollback extends LogEntry {
        Transaction                     t;
        public Rollback(Transaction t) {
            super(t.getTransactionId(), ROLLBACK);
            this.t = t;
        }
        public Rollback(Transaction t0, int s) {
            super(t0.getTransactionId(), s, ROLLBACK);
            this.t = t0;
        }
        public void handle(Log log) throws Exception {
            if (stmtId == -1) {
                reallyRollbackTransaction(t);
            } else {
                reallyRollbackStatement(t, stmtId);
            }
        }
    }
    
    /**
     * Inner class for log thread syncing
     */
    public class Sync extends LogEntry {
        Latch           latch;
        public Sync(Latch latch) {
            super(SYNC);
            this.latch = latch;
        }
        public void handle(Log log) throws Exception {
            latch.release();
        }
    }
    
    /**
     * Private inner class which implements single-threaded log file
     * writer, using a Channel.
     */
    class LogSync extends Thread {
        boolean closeMe = false;
        Log1     log     = null;
        LogSync(Log1 log) { super("Log Sync"); this.log = log; }

        public void close() {
            closeMe = true;
        }
        
        public void run() {
            try {
                while (!closeMe) {
                    Object obj = channel.poll(500);
                    if (obj != null) {
                        // once we've got something to do, keep the lock
                        // until we're finished.
                        synchronized (fileLock) {
                            while (obj != null) {
                                try {
                                    //#ifdef DEBUG
                                    if (Trace.bit(17)) {
                                        Debug.println("PRE [" + obj + "].handle()");
                                    }
                                    //#endif
                                    ((LogEntry)obj).handle(log);
                                    //#ifdef DEBUG
                                    if (Trace.bit(15)) {
                                        Debug.println("POST [" + obj + "].handle()");
                                    }
                                    //#endif
                                } catch (IOException ex) {
                                    Debug.println("LogSync: Got exception in [" + obj + "].handle()");
                                    Debug.print(ex);
                                } catch (Throwable t) {
                                    Debug.println("LogSync: Got exception in [" + obj + "].handle()");
                                    Debug.print(t);
                                }
                                obj = channel.poll(0);
                            }
                            if (!closeMe) {
                                log.maybeCheckpoint();
                            }
                        }
                    }
                }
                log = null;
                if (logger != null) logger.close();
            } catch (InterruptedException ex) {
                Debug.print(ex);
            } catch (Throwable t) {
                Debug.print(t);
            } finally {
                //#ifdef DEBUG
                //Debug.println("Log Sync thread exiting **** ");
                //#endif
                closeLatch.release();
            }
        }

    }

    /**
     * Are you logging?
     *
     * Oh yes.
     */
    public boolean isLogging() { return true; }

    /**
     * Are we currently performing recovery?
     */
    public boolean inRecovery() {
        return recovering;
    }

    //#ifdef DEBUG
    int filepos = 0;
    //#endif

    /**
     * Save a "before" image
     */
    byte[] sav = null;
    public void saveBlock(long b) throws IOException {
        if (sav == null) {
            sav = new byte[blockSize + 8];
        }
        ByteUtil.putLong(sav, 0, b);
        dbFile.store.read(b, sav, 8);
        if (bfo == null) resetBlocks();
        bfo.write(sav, 0, sav.length);
        bfoActive = true;
        //#ifdef DEBUG
        if (Trace.bit(19)) Debug.println("saveBlock(" + b + ", " + Block.signature(sav, 8, blockSize) + " @ " + filepos + ")");
        filepos += sav.length;
        //#endif
        if (checksync(7)) {
            try {
                bfo.getFD().sync();
            } catch (Throwable t) {
            } finally {
                bfoActive = false;
            }
        }
    }

    /**
     * Restore all the "before" images
     */
    public void restoreBlocks() throws IOException {
        //#ifdef DEBUG
        if (Trace.bit(19)) {
            Debug.println(db.toString() +
                          ".restoreBlocks(): size = " + dbFile.getSize());
        }
        //#endif
        File f = new File(db.getScratchDir(), "before-images");
        int siz = blockSize + 8;
        if (f.exists() && f.length() >= siz) {
            RandomAccessFile bf = new RandomAccessFile(f, "r");
            try {
                byte[] buf = new byte[siz];
                long pos = bf.length() - siz;
                while (pos >= 0) {
                    bf.seek(pos);
                    bf.read(buf);
                    long blk = ByteUtil.getLong(buf, 0);
                    //#ifdef DEBUG
                    if (Trace.bit(19)) {
                        Debug.println(db.toString() + " [RESTORE " + blk + " @ " + pos + "]");
                    }
                    //#endif
                    dbFile.restoreBlock(blk, buf, 8);
                    pos -= siz;
                }
            } finally {
                bf.close();
            }
        }
        //#ifdef DEBUG
        if (Trace.bit(19)) {
            Debug.println(db.toString() +
                          ".restoreBlocks(): size = " + dbFile.getSize());
        }
        if (false) {
            long sum = 0;
            long blk = dbFile.getBlockSize();
            for (long x = 0; x < dbFile.getSize(); x += blk) {
                Block b = dbFile.getBlock(x / blk);
                for (int ix = 0; ix < blk; ix += 8) {
                    sum += b.readLong(ix);
                }
                b.decrRefCount();
            }
            Debug.println("RECOVER: CHECKSUM(" + dbFile.getSize() + ") bytes = " +
                          sum);
        }
        //#endif
    }

    /**
     * Reset the "before" list to be empty
     */
    public void resetBlocks() throws IOException {
        if (bfo != null) {
            try {
                bfo.close();
            } catch (Throwable t) {
            } finally {
                bfo = null;
            }
        }
        File b = new File(db.getScratchDir(), "before-images");
        bfo = new FileOutputStream(b);
        bfoActive = false;
        //#ifdef DEBUG
        if (Trace.bit(19)) Debug.println(db.toString() + ".Log1.resetBlocks() @ " + filepos + ", dbFile.size = " + dbFile.getSize());
        filepos = 0;
        //#endif
    }

    //#ifdef DEBUG
    public String toString() {
        String s = getClass().getName();
        int x = s.lastIndexOf('.');
        if (x >= 0) s = s.substring(x+1);
        return s;
    }
    //#endif
}