VestaLogPrivate.H

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//
// VestaLogPrivate.H
//
// Log changes to the repository state
// Portion of VestaLog that is private to the implementation but is
//  needed by the compiler to build clients.
//

#ifndef _VLOGP
#define _VLOGP 1

#include "Basics.H"
#include <netinet/in.h>

static const int DiskBlockSize = 512;

struct VLogBlock {
    VLogBlock *next;
    int phy;       // "physical" block number (address in file)
    int pocketPhy; // reading: phy # of block left in pocket after
                   //  this one was sequenced.
                   // writing: phy # of unused block in pocket
    bool tailCommitted;  // during reading, true if the bytes beyond
                            //  len are known to be committed
    struct data_block {
        // Both seq and len are always in big-endian order.
        Bit32 seq_;  // hashed sequence number of this logical block
        Bit16 len_;  // (offset to end of last record in this block, or
                     //  0 if no record ends in this block) +
                     // (2 bit block version number in high-order bits)
        char bytes[DiskBlockSize - 6];

        inline Bit32 getSeq() throw()
          { return ntohl(seq_); };
        inline Bit16 getLen() throw()
          { return ntohs(len_) & 0x3FFF; };
        inline Bit16 getVer() throw()
          { return (ntohs(len_) >> 14) & 0x0003; };
        inline void setSeq(Bit32 seq) throw()
          { seq_ = htonl(seq); };
        inline void setLen(Bit16 len) throw()
          { len_ = htons(len | (getVer() << 14)); };
        inline void setVer(Bit16 ver) throw()
          { len_ = htons(getLen() | ((ver & 0x0003) << 14)); };
    } *data;

  VLogBlock()
  {
    data = NEW_PTRFREE(data_block);
#if defined(VALGRIND_SUPPORT)
    memset((void *) data, 0, sizeof(data_block));
#endif
  }
  ~VLogBlock()
  {
    delete data;
    data = NULL;  // Help out the garbage collecotr
  }
};


struct VestaLogPrivate {
    enum State { initial=0, recovering, recovered, ready, logging, bad };
    bool checkpointing;
    bool readonly;
    bool bakckp;     // true if backing up checkpoints
    bool hitEOF;     // reading: true if we got an end-of-file
    bool usePocket;  // writing: true if we should write to pocket next
    bool commUsePocket;  // writing: usePocket after last commit
    int nesting;     // if state==logging, how deeply starts are nested.
    State state;
    char* directory;  // directory containing log and checkpoint files
    char* directory2; // dir containing backup of log (and ckp), or NULL
    int version;     // log version currently open
    int ccVersion;   // highest committed checkpoint
    int ccVersion2;  // highest committed checkpoint in backup (if any)
    int fd;      // log file descriptor
    int fd2;     // log file descriptor for backup, -1 if none
    int lockfd;  // lock file descriptor
    int lockfd2; // lock file descriptor for backup
    int curSeq;  // seq number of first block in cur chain
    int curLen;  // offset of next byte in buf->bytes to read or write
    int nextSeq; // reading: seq number of next block not yet sequenced
    int nextPhy; // reading: phy address of next block not yet read
    int commSeq;        // writing: curSeq of last block written to commit
    int commPhy;        // writing: cur->phy after last commit
    int commPocketPhy;  // writing: cur->pocketPhy after last commit
    VLogBlock* cur;  // reading: chain of blocks already read and sequenced
                    // writing: buffer for block being assembled
    VLogBlock* last; // reading: last block in cur chain, NULL if none
    VLogBlock* pocket;   // reading: holds saved out-of-order block
    VLogBlock* free;     // free list

    inline VLogBlock* balloc() throw() {
        if (free) {
            VLogBlock* b = free;
            free = free->next;
            b->next = NULL;  // just to be cautious
            return b;
        } else {
          return NEW(VLogBlock);
        }
    };
    inline void bfree(VLogBlock *b) throw() {
        b->next = free;
        free = b;
    };
    void extendCur()         // extend the cur chain by one block
      throw(VestaLog::Eof, VestaLog::Error);
    void makeBytesAvail()    // ensure bytes to read in cur
      throw(VestaLog::Eof, VestaLog::Error);
    void writeCur()          // write out cur block
      throw(VestaLog::Error);
    void makeSpaceAvail()    // write full cur block and empty cur
      throw(VestaLog::Error);
    void eraseUncommitted(int fd)  // write invalid data to unused blocks
      throw(VestaLog::Error);
    VLogBlock* readBlock()   // read next block, return NULL if EOF
      throw(VestaLog::Error);
};

#endif //_VLOGP

---