You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
722 lines
20 KiB
722 lines
20 KiB
#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 );
|
|
|
|
|
|
|