723 lines
19 KiB
C
723 lines
19 KiB
C
#include <stdlib.h> /* for _MAX_PATH */
|
||
#include <dirapi.h>
|
||
|
||
//------------------------ system parameters ---------------------------
|
||
|
||
extern long lMaxSessions;
|
||
extern long lMaxOpenTables;
|
||
extern long lMaxVerPages;
|
||
extern long lMaxCursors;
|
||
extern long lMaxBuffers;
|
||
extern long lLogBuffers;
|
||
extern long lLogFileSectors;
|
||
extern long lLogFlushThreshold;
|
||
extern long lLGCheckPointPeriod;
|
||
extern long lWaitLogFlush;
|
||
extern long lLogFlushPeriod;
|
||
extern long lLGWaitingUserMax;
|
||
|
||
//------ log.c --------------------------------------------------------------
|
||
|
||
/* flags controlling logging behavior
|
||
/**/
|
||
extern BOOL fLogDisabled; /* to turn off logging by environment variable */
|
||
extern BOOL fFreezeCheckpoint; /* freeze checkpoint when backup occurs. */
|
||
extern BOOL fFreezeNewGeneration; /* freeze log gen when backup occurs. */
|
||
extern BOOL fNewLogRecordAdded;
|
||
extern BOOL fBackupActive;
|
||
extern BOOL fLGNoMoreLogWrite;
|
||
|
||
extern INT cLGUsers;
|
||
extern PIB *ppibLGFlushQHead;
|
||
extern PIB *ppibLGFlushQTail;
|
||
|
||
extern INT csecLGThreshold;
|
||
extern INT csecLGCheckpointCount;
|
||
extern INT csecLGCheckpointPeriod;
|
||
extern INT cmsLGFlushPeriod;
|
||
extern INT cmsLGFlushStep;
|
||
extern BYTE szComputerName[];
|
||
|
||
/* flags controlling recovery behavior
|
||
/**/
|
||
extern BOOL fHardRestore;
|
||
|
||
#ifdef DEBUG
|
||
extern BOOL fDBGTraceLog;
|
||
extern BOOL fDBGTraceLogWrite;
|
||
extern BOOL fDBGFreezeCheckpoint;
|
||
extern BOOL fDBGTraceRedo;
|
||
#endif
|
||
|
||
extern LONG cXactPerFlush;
|
||
|
||
#ifdef PERFCNT
|
||
extern BOOL fPERFEnabled;
|
||
extern ULONG rgcCommitByUser[10];
|
||
extern ULONG rgcCommitByLG[10];
|
||
#endif
|
||
|
||
#pragma pack(1)
|
||
|
||
typedef struct
|
||
{
|
||
BYTE szSysDbPath[_MAX_PATH + 1];
|
||
BYTE szLogFilePath[_MAX_PATH + 1];
|
||
|
||
ULONG ulMaxSessions;
|
||
ULONG ulMaxOpenTables;
|
||
ULONG ulMaxVerPages;
|
||
ULONG ulMaxCursors;
|
||
ULONG ulLogBuffers;
|
||
ULONG ulMaxBuffers; /* not used, for ref only */
|
||
} DBENV;
|
||
|
||
VOID LGStoreDBEnv( DBENV *pdbenv );
|
||
VOID LGSetDBEnv( DBENV *pdbenv );
|
||
VOID LGLogFailEvent( BYTE *szLine );
|
||
|
||
/*
|
||
* NOTE: Whenever a new log record type is added or changed, the following
|
||
* NOTE: should be udpated too: mplrtypsz in logapi.c, new print function for
|
||
* NOTE: the new lrtyp in logapi.c, and mplrtypcb and CbLGSizeOfRec in
|
||
* NOTE: redut.c.
|
||
*/
|
||
typedef BYTE LRTYP;
|
||
|
||
#define lrtypNOP ((LRTYP) 0 ) /* NOP null operation */
|
||
#define lrtypStart ((LRTYP) 1 )
|
||
#define lrtypQuit ((LRTYP) 2 )
|
||
#define lrtypMS ((LRTYP) 3 ) /* mutilsec flush */
|
||
#define lrtypFill ((LRTYP) 4 ) /* no op */
|
||
|
||
#define lrtypBegin ((LRTYP) 5 )
|
||
#define lrtypCommit ((LRTYP) 6 )
|
||
#define lrtypAbort ((LRTYP) 7 )
|
||
|
||
#define lrtypCreateDB ((LRTYP) 8 )
|
||
#define lrtypAttachDB ((LRTYP) 9 )
|
||
#define lrtypDetachDB ((LRTYP) 10 )
|
||
|
||
#define lrtypInitFDPPage ((LRTYP) 11 )
|
||
|
||
#define lrtypSplit ((LRTYP) 12 )
|
||
#define lrtypEmptyPage ((LRTYP) 13 )
|
||
#define lrtypMerge ((LRTYP) 14 )
|
||
|
||
#define lrtypInsertNode ((LRTYP) 15 )
|
||
#define lrtypInsertItemList ((LRTYP) 16 )
|
||
#define lrtypReplace ((LRTYP) 17 )
|
||
#define lrtypReplaceC ((LRTYP) 18 )
|
||
#define lrtypFlagDelete ((LRTYP) 19 )
|
||
#define lrtypLockRec ((LRTYP) 20 )
|
||
|
||
#define lrtypUpdateHeader ((LRTYP) 21 )
|
||
#define lrtypInsertItem ((LRTYP) 22 )
|
||
#define lrtypInsertItems ((LRTYP) 23 )
|
||
#define lrtypFlagDeleteItem ((LRTYP) 24 )
|
||
#define lrtypFlagInsertItem ((LRTYP) 25 )
|
||
#define lrtypDeleteItem ((LRTYP) 26 )
|
||
#define lrtypSplitItemListNode ((LRTYP) 27 )
|
||
|
||
#define lrtypDelta ((LRTYP) 28 )
|
||
|
||
#define lrtypDelete ((LRTYP) 29 )
|
||
#define lrtypELC ((LRTYP) 30 )
|
||
|
||
#define lrtypFreeSpace ((LRTYP) 31 )
|
||
#define lrtypUndo ((LRTYP) 32 )
|
||
|
||
#define lrtypRecoveryUndo1 ((LRTYP) 33 )
|
||
#define lrtypRecoveryQuit1 ((LRTYP) 34 )
|
||
|
||
#define lrtypRecoveryUndo2 ((LRTYP) 35 )
|
||
#define lrtypRecoveryQuit2 ((LRTYP) 36 )
|
||
|
||
#define lrtypFullBackup ((LRTYP) 37 )
|
||
#define lrtypIncBackup ((LRTYP) 38 )
|
||
|
||
/* debug only
|
||
/**/
|
||
#define lrtypCheckPage ((LRTYP) 39 )
|
||
|
||
#define lrtypMax ((LRTYP) 40 )
|
||
|
||
|
||
/* log record structure ( fixed size portion of log entry )
|
||
/**/
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
} LR;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of DB operations */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn; /* dbid + pgno */
|
||
|
||
BYTE itagSon; /* itag of node, used only for verification */
|
||
// UNDONE: review with Cheen Liao
|
||
// SHORT itagFather; /* itag of father node */
|
||
BYTE itagFather; /* itag of father node */
|
||
BYTE ibSon; /* position to insert in father son table */
|
||
BYTE bHeader; /* node header */
|
||
ULONG fDIRFlags; /* fDIRVersion for insert item list */
|
||
// UNDONE: review with Cheen Liao
|
||
// USHORT cbKey; /* key size */
|
||
BYTE cbKey; /* key size */
|
||
USHORT cbData; /* data size */
|
||
CHAR szKey[0]; /* key and data follow */
|
||
} LRINSERTNODE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
BYTE itag; /* wherereplace occurs */
|
||
SRID bm; /* bookmark of this replace node */
|
||
ULONG fDIRFlags; /* flags used in original DIR call */
|
||
USHORT cb; /* data size/diff info */
|
||
BYTE fOld:1; /* fTrue if before image is in szData */
|
||
USHORT cbOldData:15; /* before image data size, may be 0 */
|
||
USHORT cbNewData; /* after image data size, == cb if not replaceC */
|
||
CHAR szData[0]; /* made line data for new (and old) record follow */
|
||
} LRREPLACE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
BYTE itag;
|
||
SRID bm;
|
||
USHORT cbOldData;
|
||
CHAR szData[0]; /* for before image */
|
||
} LRLOCKREC;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
BYTE itag;
|
||
SRID bm; /* bookmark of this delete node */
|
||
ULONG fDIRFlags; /* flags used in original DIR call */
|
||
} LRFLAGDELETE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
BYTE itag;
|
||
} LRDELETE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
|
||
PROCID procid; /* user id of this log record */
|
||
DBID dbid;
|
||
SRID bm;
|
||
BYTE level;
|
||
SHORT cbDelta;
|
||
SRID bmTarget; /* page being updated during undo operation */
|
||
} LRFREESPACE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
|
||
PROCID procid; /* user id of this log record */
|
||
DBID dbid;
|
||
SRID bm;
|
||
BYTE level;
|
||
UINT oper;
|
||
SRID item;
|
||
SRID bmTarget; /* the page being updated during undo operation */
|
||
} LRUNDO;
|
||
|
||
/* expunge link commit log record
|
||
/**/
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
BYTE itag;
|
||
SRID sridSrc;
|
||
} LRELC;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
BYTE itag;
|
||
SRID bm; /* bookmark of this udpated node */
|
||
BYTE bHeader;
|
||
} LRUPDATEHEADER;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of DB operations */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn; /* dbid + pgno */
|
||
|
||
#if ISRID
|
||
WORD isrid; /* in case do version only */
|
||
#endif
|
||
BYTE itag; /* of item list node */
|
||
SRID srid; /* item to insert */
|
||
SRID sridItemList; /* bookmark of first item list node */
|
||
ULONG fDIRFlags; /* so far only one bit is used - fDIRVersion */
|
||
} LRINSERTITEM;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of DB operations */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn; /* dbid + pgno */
|
||
|
||
BYTE itag; /* item list */
|
||
WORD citem; /* number of items to append */
|
||
SRID rgitem[0];
|
||
} LRINSERTITEMS;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
BYTE itag; /* of item list node */
|
||
#if ISRID
|
||
SHORT isrid;
|
||
#else
|
||
SRID srid; /* item to insert */
|
||
#endif
|
||
SRID sridItemList; /* bookmark of first item list node */
|
||
} LRFLAGITEM;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of DB operations */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn; /* dbid + pgno */
|
||
|
||
WORD cItem;
|
||
BYTE itagToSplit; /* used only for verification! */
|
||
// UNDONE: review with Cheen Liao
|
||
// SHORT itagFather; /* father's identity */
|
||
BYTE itagFather; /* itag of father */
|
||
BYTE ibSon; /* Position to insert in father's son table */
|
||
ULONG fFlags; /* flag to indicate if it is append item */
|
||
} LRSPLITITEMLISTNODE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of DB operations */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn; /* dbid + pgno */
|
||
|
||
#if ISRID
|
||
SHORT isrid;
|
||
#else
|
||
SRID srid; /* item to insert */
|
||
#endif
|
||
BYTE itag; /* item list */
|
||
SRID sridItemList; /* bookmark of first item list node */
|
||
} LRDELETEITEM;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
BYTE itag; /* wherereplace occurs */
|
||
SRID bm; /* bookmark of this replace node */
|
||
LONG lDelta;
|
||
ULONG fDIRFlags; /* flags used in original DIR call */
|
||
} LRDELTA;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* current flush counter of page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn;
|
||
|
||
SHORT cbFreeTotal;
|
||
SHORT itagNext;
|
||
} LRCHECKPAGE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
|
||
PROCID procid; /* user id of this log record */
|
||
LEVEL levelStart; /* starting transaction levels */
|
||
LEVEL level; /* transaction levels */
|
||
} LRBEGIN;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
|
||
PROCID procid; /* user id of this log record */
|
||
LEVEL level; /* transaction levels */
|
||
} LRCOMMIT;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
|
||
PROCID procid; /* user id of this log record */
|
||
LEVEL levelAborted; /* transaction level */
|
||
} LRABORT;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
|
||
PROCID procid; /* user id of this log record, unused in V15 */
|
||
DBID dbid;
|
||
BOOL fLogOn;
|
||
JET_GRBIT grbit;
|
||
USHORT cb; /* data size */
|
||
CHAR szPath[0]; /* path name follows */
|
||
} LRCREATEDB;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
|
||
PROCID procid; /* user id of this log record, unused in V15 */
|
||
DBID dbid;
|
||
BYTE fLogOn;
|
||
USHORT cb; /* data size */
|
||
CHAR szPath[0]; /* path name follows */
|
||
} LRATTACHDB;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
|
||
PROCID procid; /* user id of this log record, unused in V15 */
|
||
DBID dbid;
|
||
BOOL fLogOn;
|
||
USHORT cb;
|
||
CHAR szPath[0]; /* path name follows */
|
||
} LRDETACHDB;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* flush counter of page being split */
|
||
|
||
PROCID procid; /* user id of this log record */
|
||
BYTE splitt; /* split type */
|
||
BYTE fLeaf; /* split on leaf node */
|
||
PN pn; /* page (focus) being split, includes dbid */
|
||
PGNO pgnoNew; /* newly-allocated page no */
|
||
PGNO pgnoNew2; /* newly-allocated page no */
|
||
PGNO pgnoNew3; /* newly-allocated page no */
|
||
PGNO pgnoSibling; /* newly-allocated page no */
|
||
BYTE itagSplit; /* node at which page is being split */
|
||
SHORT ibSonSplit; /* ibSon at which node is being split */
|
||
BYTE pgtyp; /* page type of new page */
|
||
|
||
PGNO pgnoFather; /* pgno of father node */
|
||
SHORT itagFather; /* itag of father node, could be itagNil (3 bytes) */
|
||
SHORT itagGrandFather;/* itag of Grand father node, could be itagNil (3 bytes) */
|
||
BYTE ibSonFather;
|
||
BYTE cbklnk; /* number of back links */
|
||
// UNDONE: review with Cheen Liao
|
||
// SHORT cbKey;
|
||
// SHORT cbKeyMac;
|
||
BYTE cbKey;
|
||
BYTE cbKeyMac;
|
||
BYTE rgb[0];
|
||
} LRSPLIT;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* flush counter of page being split */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn; /* page pointer of empty page */
|
||
|
||
PGNO pgnoFather;
|
||
SHORT itag; /* itag of page pointer */
|
||
// UNDONE: review with Cheen Liao
|
||
// SHORT itagFather; /* father of page pointer */
|
||
BYTE itagFather; /* itag of father of page pointer */
|
||
SHORT ibSon;
|
||
|
||
PGNO pgnoLeft;
|
||
PGNO pgnoRight;
|
||
} LREMPTYPAGE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
|
||
PROCID procid;
|
||
|
||
PN pn; /* page pointer of merged page */
|
||
PGNO pgnoRight; /* page appended to */
|
||
|
||
ULONG ulDBTime;
|
||
|
||
BYTE cbklnk;
|
||
BYTE rgb[0];
|
||
} LRMERGE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
ULONG ulDBTime; /* flush counter of father FDP page */
|
||
PROCID procid; /* user id of this log record */
|
||
PN pn; /* FDP page */
|
||
|
||
PGNO pgnoFDPParent; /* parent FDP */
|
||
USHORT cpgGot; /* returned number of pages */
|
||
USHORT cpgWish; /* request pages */
|
||
} LRINITFDPPAGE;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
|
||
USHORT ibForwardLink;
|
||
USHORT isecForwardLink;
|
||
|
||
USHORT ibBackLink;
|
||
USHORT isecBackLink;
|
||
|
||
ULONG ulCheckSum;
|
||
} LRMS;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
DBENV dbenv;
|
||
} LRSTART;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
LGPOS lgpos; /* point back to last beginning of undo */
|
||
LGPOS lgposRedoFrom;
|
||
BYTE fHard;
|
||
} LRQUITREC;
|
||
|
||
typedef struct
|
||
{
|
||
LRTYP lrtyp;
|
||
USHORT cbPath; /* backup path/restore path */
|
||
BYTE szData[0];
|
||
} LRLOGRESTORE;
|
||
|
||
|
||
#ifdef HILEVEL_LOGGING
|
||
|
||
typedef struct
|
||
{
|
||
PROCID procid; /* user id of this log record */
|
||
PGNO pn; /* Parent FDP, includes dbid */
|
||
ULONG flags; /* flags for index */
|
||
ULONG density; /* initial load density for index */
|
||
ULONG timepage; /* flush counter of father FDP page */
|
||
USHORT cbname; /* index name length */
|
||
USHORT cbkey; /* index info length */
|
||
/* Index name and index info follow */
|
||
} LRCREATEIDX;
|
||
|
||
//typedef struct
|
||
// {
|
||
// PROCID procid; /* user id of this log record */
|
||
// PGNO pgno; /* first page of new extent */
|
||
// ULONG cpages; /* number of pages in the extent */
|
||
// PGNO pgnoFDP; /* FDP being extended */
|
||
// PN pnparent; /* Parent FDP controlling the space, includes dbid */
|
||
// ULONG timepage; /* flush counter of FDP page */
|
||
// } EXTENDFDP;
|
||
|
||
//typedef struct
|
||
// {
|
||
// PROCID procid; /* user id of this log record */
|
||
// PGNO pgno; /* first page of freed extent */
|
||
// ULONG cpages; /* number of pages in the extent */
|
||
// PGNO pgnoFDP; /* FDP being shrunk */
|
||
// ULONG timepage; /* flush counter of parent FDP page */
|
||
// PN pnparent; /* Parent FDP regaining the space, includes dbid*/
|
||
// } LRSHRINKFDP;
|
||
|
||
#endif
|
||
|
||
#pragma pack()
|
||
|
||
|
||
#ifdef NOLOG
|
||
|
||
#define LGDepend( pbf, lgpos )
|
||
|
||
#define ErrLGInsert( pfucb, fHeader, pkey, plineData ) 0
|
||
#define ErrLGInsertItemList( pfucb, fHeader, pkey, plineData ) 0
|
||
#define ErrLGReplace( pfucb, pline, fFlags, cbData ) 0
|
||
#define ErrLGFlagDelete( pfucb, fFlags ) 0
|
||
#deinfe ErrLGUpdateHeader( pfucb, bHeader ) 0
|
||
#define ErrLGInsertItem( pfucb, fDIRFlags ) 0
|
||
#define ErrLGInsertItems( pfucb, rgitem, citem ) 0
|
||
#define ErrLGFlagDeleteItem( pfucb ) 0
|
||
#define ErrLGSplitItemListNode( pfucb, cItem, itagFather, ibSon, itagToSplit, fFlags) 0
|
||
#define ErrLGDeleteItem( pfucb ) 0
|
||
#define ErrLGDelta( pfucb, lDelta, fDIRFlags ) 0
|
||
#define ErrLGLockRecord( pfucb, cbData ) 0
|
||
|
||
#define ErrLGBeginTransaction( ppib, levelBeginFrom ) 0
|
||
#define ErrLGCommitTransaction( ppib, levelCommitTo ) 0
|
||
#define ErrLGAbort( ppib,levelsAborted ) 0
|
||
#define ErrLGUndo( prce ) 0
|
||
#define ErrLGFreeSpace( prce, cbDelta ) 0
|
||
|
||
#define ErrLGCreateDB( ppib, dbid, fLogOn, grbit, sz, cch ) 0
|
||
#define ErrLGAttachDB( ppib, dbid, fLogOn, sz, cch ) 0
|
||
#define ErrLGDetachDB( ppib, dbid, fLogOn, sz, cch ) 0
|
||
|
||
#define ErrLGMerge( pfucb, psplit ) 0
|
||
#define ErrLGSplit( splitt, pfucb, pcsrPagePointer, psplit, pgtypNew ) 0
|
||
#define ErrLGEmptyPage( pfucbFather, prmpage ) 0
|
||
#define ErrLGInitFDPPage( pfucb, pgnoFDPParent, pnFDP, cpgGot, cpgWish) 0
|
||
#define ErrLGFlagInsertItem(pfucb) 0
|
||
|
||
#define ErrLGStart() 0
|
||
#define ErrLGQuit( plgposRecoveryUndo ) 0
|
||
#define ErrLGRecoveryQuit1( plgposRecoveryUndo ) 0
|
||
#define ErrLGRecoveryUndo1( szRestorePath ) 0
|
||
#define ErrLGRecoveryQuit2( plgposRecoveryUndo ) 0
|
||
#define ErrLGRecoveryUndo2( szRestorePath ) 0
|
||
#define ErrLGFullBackup(szRestorePath ) 0
|
||
#define ErrLGIncBackup(szRestorePath ) 0
|
||
|
||
#define ErrLGCheckPage( pfucb, cbFreeTotal, itagNext ) 0
|
||
|
||
#else /* !NOLOG */
|
||
|
||
#define ErrLGInsert( pfucb, fHeader, pkey, plineData) \
|
||
ErrLGInsertNode( lrtypInsertNode, pfucb, fHeader, pkey, plineData, 0)
|
||
#define ErrLGInsertItemList( pfucb, fHeader, pkey, plineData, fFlags) \
|
||
ErrLGInsertNode( lrtypInsertItemList, pfucb, fHeader, pkey, plineData, fFlags)
|
||
ERR ErrLGInsertNode( LRTYP lrtyp,
|
||
FUCB *pfucb, INT fHeader, KEY *pkey, LINE *plineData, INT fFlags);
|
||
ERR ErrLGReplace( FUCB *pfucb, LINE *pline, int fl, int cbData );
|
||
ERR ErrLGFlagDelete( FUCB *pfucb, INT fFlags);
|
||
ERR ErrLGUpdateHeader( FUCB *pfucb, INT bHeader );
|
||
ERR ErrLGInsertItem( FUCB *pfucb, INT fDIRFlags );
|
||
ERR ErrLGInsertItems( FUCB *pfucb, SRID *rgitem, INT citem );
|
||
ERR ErrLGFlagDeleteItem( FUCB *pfucb );
|
||
ERR ErrLGSplitItemListNode( FUCB *pfucb, INT cItem, INT itagFather,
|
||
INT ibSon, INT itagToSplit, INT fFlags );
|
||
ERR ErrLGDelta( FUCB *pfucb, LONG lDelta, INT fDIRFlags );
|
||
ERR ErrLGLockRecord( FUCB *pfucb, INT cbData );
|
||
|
||
|
||
ERR ErrLGBeginTransaction( PIB *ppib, INT levelBeginFrom );
|
||
ERR ErrLGCommitTransaction( PIB *ppib, INT levelCommitTo );
|
||
ERR ErrLGAbort( PIB *ppib, INT levelsAborted );
|
||
ERR ErrLGUndo( RCE *prce );
|
||
ERR ErrLGFreeSpace( RCE *prce, INT cbDelta );
|
||
|
||
ERR ErrLGCreateDB( PIB *ppib, DBID dbid, BOOL fLogOn, JET_GRBIT grbit, CHAR *sz, INT cch );
|
||
ERR ErrLGAttachDB( PIB *ppib, DBID dbid, BOOL fLogOn, CHAR *sz, INT cch );
|
||
ERR ErrLGDetachDB( PIB *ppib, DBID dbid, BOOL fLogOn, CHAR *sz, INT cch );
|
||
|
||
ERR ErrLGMerge( FUCB *pfucb, struct _split *psplit );
|
||
ERR ErrLGSplit( SPLITT splitt, FUCB *pfucb, CSR *pcsrPagePointer,
|
||
struct _split *psplit, PGTYP pgtypNew );
|
||
|
||
ERR ErrLGEmptyPage( FUCB *pfucbFather, RMPAGE *prmpage );
|
||
ERR ErrLGInitFDPPage( FUCB *pfucb, PGNO pgnoFDPParent,
|
||
PN pnFDP, INT cpgGot, INT cpgWish);
|
||
|
||
#define ErrLGFlagDeleteItem(pfucb) ErrLGFlagItem(pfucb, lrtypFlagDeleteItem)
|
||
#define ErrLGFlagInsertItem(pfucb) ErrLGFlagItem(pfucb, lrtypFlagInsertItem)
|
||
ERR ErrLGFlagItem(FUCB *pfucb, LRTYP lrtyp);
|
||
ERR ErrLGDeleteItem( FUCB *pfucb );
|
||
|
||
ERR ErrLGDelete( FUCB *pfucb );
|
||
ERR ErrLGExpungeLinkCommit( FUCB *pfucb, SSIB *pssibSrc, SRID sridSrc );
|
||
|
||
ERR ErrLGStart();
|
||
#define ErrLGRecoveryQuit1( plgposRecoveryUndo, plgposRedoFrom, fHard ) \
|
||
ErrLGQuitRec( lrtypRecoveryQuit1, plgposRecoveryUndo, \
|
||
plgposRedoFrom, fHard )
|
||
#define ErrLGRecoveryQuit2( plgposRecoveryUndo, plgposRedoFrom, fHard ) \
|
||
ErrLGQuitRec( lrtypRecoveryQuit2, plgposRecoveryUndo, \
|
||
plgposRedoFrom, fHard )
|
||
#define ErrLGQuit( plgposStart ) \
|
||
ErrLGQuitRec( lrtypQuit, plgposStart, pNil, 0 )
|
||
ERR ErrLGQuitRec( LRTYP lrtyp, LGPOS *plgposQuit, LGPOS *plgposRedoFrom, BOOL fHard);
|
||
|
||
#define ErrLGRecoveryUndo1(szRestorePath) \
|
||
ErrLGLogRestore(lrtypRecoveryUndo1, szRestorePath )
|
||
#define ErrLGRecoveryUndo2(szRestorePath) \
|
||
ErrLGLogRestore(lrtypRecoveryUndo2, szRestorePath )
|
||
#define ErrLGFullBackup(szRestorePath) \
|
||
ErrLGLogRestore(lrtypFullBackup, szRestorePath )
|
||
#define ErrLGIncBackup(szRestorePath) \
|
||
ErrLGLogRestore(lrtypIncBackup, szRestorePath )
|
||
ERR ErrLGLogRestore( LRTYP lrtyp, CHAR * szLogRestorePath );
|
||
|
||
ERR ErrLGCheckPage( FUCB *pfucb, SHORT cbFreeTotal, SHORT itagNext );
|
||
|
||
#endif /* logging enabled */
|
||
|
||
ERR ISAMAPI ErrIsamRestore( CHAR *szRestoreFromPath,
|
||
INT crstmap, JET_RSTMAP *rgrstmap, JET_PFNSTATUS pfn );
|
||
|
||
ERR ErrLGSoftStart( BOOL fAllowNoJetLog );
|
||
|
||
ERR ErrLGInit( VOID );
|
||
ERR ErrLGTerm( VOID );
|
||
ERR ErrLGLogRec( LINE *rgline, INT cline, PIB *ppib );
|
||
ERR ErrLGEndAllSessions( BOOL fSysDbOnly, BOOL fEndOfLog, LGPOS *plgposRedoFrom );
|
||
ERR ErrLGInitLogBuffers( LONG lIntendLogBuffers );
|
||
INT CmpLgpos(LGPOS *plgpos1, LGPOS *plgpos2);
|
||
ULONG UlLGMSCheckSum( CHAR *pbLrmsNew );
|
||
|
||
#define FLGOn() (!fLogDisabled)
|
||
#define FLGOff() (fLogDisabled)
|
||
|
||
BOOL FIsNullLgpos( LGPOS *plgpos );
|
||
VOID LGMakeLogName( CHAR *szLogName, CHAR *szFName );
|
||
|
||
|
||
|