contrib/sqlite3/sqlite3.c

14915 typedef struct PgHdr DbPage;
16179 typedef struct PgHdr PgHdr;
16186 struct PgHdr {
16191   PgHdr *pDirty;                 /* Transient list of dirty sorted by pgno */
16205   PgHdr *pDirtyNext;             /* Next element in list of dirty pages */
16206   PgHdr *pDirtyPrev;             /* Previous element in list of dirty pages */
16208                           ** PgHdr object is not dirty */
16211 /* Bit values for PgHdr.flags */
16239   int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */
16257 SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish(PCache*, Pgno, sqlite3_pcache_page *pPage);
16258 SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*);
16260 SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*);         /* Remove page from cache */
16261 SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*);    /* Make sure page is marked dirty */
16262 SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*);    /* Mark a single page as clean */
16267 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
16273 SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*);
16288 SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*);
16290 SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr*);
16300 SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *));
16304 /* Check invariants on a PgHdr object */
16305 SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr*);
49344 **   PgHdr.pDirtyNext and pDirtyPrev. The list is maintained in LRU order
49359   PgHdr *pDirty, *pDirtyTail;         /* List of dirty pages in LRU order */
49360   PgHdr *pSynced;                     /* Last synced page in dirty page list */
49368   int (*xStress)(void*,PgHdr*);       /* Call to try make a page clean */
49390     PgHdr *pPg;
49400        pPg = (PgHdr*)pLower->pExtra;
49416 ** Check invariants on a PgHdr entry.  Return true if everything is OK.
49425 SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr *pPg){
49475 static void pcacheManageDirtyList(PgHdr *pPage, u8 addRemove){
49545 static void pcacheUnpin(PgHdr *p){
49614   int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */
49641                 szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)),
49674 ** PgHdr object.  The sqlite3PcacheFetch() and sqlite3PcacheFetchFinish()
49726   PgHdr *pPg;
49777 static SQLITE_NOINLINE PgHdr *pcacheFetchFinishWithInit(
49782   PgHdr *pPgHdr;
49784   pPgHdr = (PgHdr*)pPage->pExtra;
49786   memset(&pPgHdr->pDirty, 0, sizeof(PgHdr) - offsetof(PgHdr,pDirty));
49799 ** sqlite3PcacheFetch() into an initialized PgHdr object.  This routine
49803 SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish(
49808   PgHdr *pPgHdr;
49811   pPgHdr = (PgHdr *)pPage->pExtra;
49826 SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3PcacheRelease(PgHdr *p){
49841 SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr *p){
49853 SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){
49867 SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){
49886 SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){
49904   PgHdr *p;
49915   PgHdr *p;
49927   PgHdr *p;
49937 SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
49961     PgHdr *p;
49962     PgHdr *pNext;
50009 static PgHdr *pcacheMergeDirtyList(PgHdr *pA, PgHdr *pB){
50010   PgHdr result, *pTail;
50046 static PgHdr *pcacheSortDirtyList(PgHdr *pIn){
50047   PgHdr *a[N_SORT_BUCKET], *p;
50081 SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache *pCache){
50082   PgHdr *p;
50102 SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr *p){
50164 SQLITE_PRIVATE int sqlite3HeaderSizePcache(void){ return ROUND8(sizeof(PgHdr)); }
50171   PgHdr *pDirty;
50193 SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)){
50194   PgHdr *pDirty;
50224 **  |  database page content   |  PgHdr1  |  MemPage  |  PgHdr  |
50228 ** flow harmlessly into the PgHdr1, MemPage, and PgHdr extensions).   MemPage
50230 ** as the database page number and how that database page is used.  PgHdr
50236 ** database page content and sqlite3_pcache_page.pExtra points to PgHdr.
50238 ** The size of the extension (MemPage+PgHdr+PgHdr1) can be determined at
50254 ** The pcache.c and pager.c modules deal pointers to PgHdr objects.
50376   int szExtra;                        /* sizeof(MemPage)+sizeof(PgHdr) */
52109 SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
52820   PgHdr *pMmapFreelist;       /* List of free mmap page headers (pDirty) */
53213 static int subjRequiresPage(PgHdr *pPg){
53234 static int pageInJournal(Pager *pPager, PgHdr *pPg){
53395 static u32 pager_pagehash(PgHdr *pPage){
53398 static void pager_set_pagehash(PgHdr *pPage){
53403 ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
53408 static void checkPage(PgHdr *pPg){
54232     PgHdr *p = sqlite3PagerLookup(pPager, 1);
54392   PgHdr *pPg;                   /* An existing page in the cache */
55109 static int readDbPage(PgHdr *pPg){
55172 static void pager_write_changecounter(PgHdr *pPg){
55202   PgHdr *pPg;
55236   PgHdr *pList;                   /* List of dirty pages to revert */
55249     PgHdr *pNext = pList->pDirty;
55268   PgHdr *pList,                   /* List of frames to log */
55274   PgHdr *p;                       /* For looping over pages */
55291     PgHdr **ppNext = &pList;
56063 static void assertTruncateConstraintCb(PgHdr *pPg){
56142   PgHdr **ppPage                  /* OUT: Acquired page object */
56144   PgHdr *p;                       /* Memory mapped page to return */
56153     *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
56182 static void pagerReleaseMapPage(PgHdr *pPg){
56193 ** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
56196   PgHdr *p;
56197   PgHdr *pNext;
56464 ** by the PgHdr.pDirty pointer. This function writes each one of the
56494 static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
56611 static int subjournalPage(PgHdr *pPg){
56647 static int subjournalPageIfRequired(PgHdr *pPg){
56674 static int pagerStress(void *p, PgHdr *pPg){
56754     PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
56757       PgHdr *pNext = pList->pDirty;
57620   PgHdr *pPg;
57722   PgHdr *pPg = 0;
58048 static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
58105 static int pager_write(PgHdr *pPg){
58197 static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){
58235     PgHdr *pPage;
58264       PgHdr *pPage = sqlite3PagerLookup(pPager, pg1+ii);
58291 SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){
58340 SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){
58401     PgHdr *pPgHdr;                /* Reference to page 1 */
58556     PgHdr *pList;
58558       PgHdr *pPageOne = 0;
58615         PgHdr *pPg;
58886   int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
59205   PgHdr *pPgOld;               /* The page being overwritten. */
59318     PgHdr *pPgHdr;
59339 ** page number to iNew and sets the value of the PgHdr.flags field to
63284   PgHdr *pPage,               /* The page of the frame to be written */
63360   PgHdr *pList,                   /* List of dirty pages to write */
63367   PgHdr *p;                       /* Iterator to run through pList with. */
63368   PgHdr *pLast = 0;               /* Last frame in list */
76211             PgHdr *pSrcPg = 0;