/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1996, 1997, 1998
* Sleepycat Software. All rights reserved.
*/
#include "config.h"
#ifndef lint
#endif /* not lint */
#ifndef NO_SYSTEM_INCLUDES
#include <errno.h>
#include <string.h>
#endif
#include "db_int.h"
#include "shqueue.h"
#include "db_shash.h"
#include "mp.h"
#include "common_ext.h"
/*
* memp_fget --
* Get a page from the file.
*/
int
void *addrp;
{
/*
* Validate arguments.
*
* !!!
* Don't test for DB_MPOOL_CREATE and DB_MPOOL_NEW flags for readonly
* files here, and create non-existent pages in readonly files if the
* flags are set, later. The reason is that the hash access method
* wants to get empty pages that don't really exist in readonly files.
* The only alternative is for hash to write the last "bucket" all the
* time, which we don't want to do because one of our big goals in life
* is to keep database files small. It's sleazy as hell, but we catch
* any attempt to actually write the file in memp_fput().
*/
if (flags != 0) {
if ((ret =
return (ret);
switch (flags) {
case DB_MPOOL_CREATE:
case DB_MPOOL_LAST:
case DB_MPOOL_NEW:
case 0:
break;
default:
}
}
#ifdef DIAGNOSTIC
/*
* XXX
* We want to switch threads as often as possible. Yield every time
* we get a new page to ensure contention.
*/
if (DB_GLOBAL(db_pageyield))
__os_yield(1);
#endif
/* Initialize remaining local variables. */
st_hsearch = 0;
/* Determine the hash bucket where this page will live. */
/*
* Check for the last or last + 1 page requests.
*
* Examine and update the file's last_pgno value. We don't care if
* the last_pgno value immediately changes due to another thread --
* at this instant in time, the value is correct. We do increment the
* current last_pgno value if the thread is asking for a new page,
* however, to ensure that two threads creating pages don't get the
* same one.
*/
if (LF_ISSET(DB_MPOOL_NEW))
if (LF_ISSET(DB_MPOOL_NEW))
goto alloc;
}
/*
* If mmap'ing the file and the page is not past the end of the file,
* just return a pointer.
*
* The page may be past the end of the file, so check the page number
* argument against the original length of the file. If we previously
* returned pages past the original end of the file, last_pgno will
* have been updated to match the "new" end of the file, and checking
* against it would return pointers past the end of the mmap'd region.
*
* If another process has opened the file for writing since we mmap'd
* it, we will start playing the game by their rules, i.e. everything
* goes through the cache. All pages previously returned will be safe,
* as long as the correct locking protocol was observed.
*
* XXX
* We don't discard the map because we don't know when all of the
* pages will have been discarded from the process' address space.
* It would be possible to do so by reference counting the open
* pages from the mmap, but it's unclear to me that it's worth it.
*/
/*
* !!!
* See the comment above about non-existent pages and
* the hash access method.
*/
if (!LF_ISSET(DB_MPOOL_CREATE)) {
"%s: page %lu doesn't exist",
goto err;
}
} else {
*(void **)addrp =
goto done;
}
/* Search the hash chain for the page. */
++st_hsearch;
continue;
/* Increment the reference count. */
"%s: page %lu: reference count overflow",
goto err;
}
/*
* Increment the reference count. We may discard the region
* ensure that it doesn't move and that its contents remain
* unchanged.
*/
b_incr = 1;
/*
* Any buffer we find might be trouble.
*
* BH_LOCKED --
* I/O is in progress. Because we've incremented the buffer
* reference count, we know the buffer can't move. Unlock
* the region lock, wait for the I/O to complete, and reacquire
* the region.
*/
/*
* Explicitly yield the processor if it's not the first
* pass through this loop -- if we don't, we might end
* up running to the end of our CPU quantum as we will
* simply be swapping between the two locks.
*/
if (!first)
__os_yield(1);
/* Wait for I/O to finish... */
}
/*
* BH_TRASH --
* The contents of the buffer are garbage. Shouldn't happen,
* and this read is likely to fail, but might as well try.
*/
goto reread;
/*
* BH_CALLPGIN --
* The buffer was converted so it could be written, and the
* contents need to be converted again.
*/
goto err;
}
goto done;
}
alloc: /* Allocate new buffer header and data space. */
goto err;
#ifdef DIAGNOSTIC
"Internal error: BH data NOT size_t aligned.");
goto err;
}
#endif
/* Initialize the BH fields. */
/*
* Prepend the bucket header to the head of the appropriate MPOOL
* bucket hash list. Append the bucket header to the tail of the
* MPOOL LRU chain.
*/
/*
* If we created the page, zero it out and continue.
*
* !!!
* Note: DB_MPOOL_NEW specifically doesn't call the pgin function.
* If DB_MPOOL_CREATE is used, then the application's pgin function
* has to be able to handle pages of 0's -- if it uses DB_MPOOL_NEW,
* it can detect all of its page creates, and not bother.
*
* Otherwise, read the page into memory, optionally creating it if
* DB_MPOOL_CREATE is set.
*/
if (LF_ISSET(DB_MPOOL_NEW)) {
else {
#ifdef DIAGNOSTIC
#endif
}
} else {
/*
* It's possible for the read function to fail, which means
* that we fail as well. Note, the __memp_pgread() function
* discards the region lock, so the buffer must be pinned
* down so that it cannot move and its contents are unchanged.
*/
/*
* !!!
* Discard the buffer unless another thread is waiting
* on our I/O to complete. Regardless, the header has
* the BH_TRASH flag set.
*/
goto err;
}
}
/*
* If we're returning a page after our current notion of the last-page,
* update our information. Note, there's no way to un-instantiate this
* page, it's going to exist whether it's returned to us dirty or not.
*/
done: /* Update the chain search statistics. */
if (st_hsearch) {
}
return (0);
err: /* Discard our reference. */
if (b_incr)
return (ret);
}