mp_sync.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*-
* 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 <stdlib.h>
#endif
#include "db_int.h"
#include "shqueue.h"
#include "db_shash.h"
#include "mp.h"
#include "common_ext.h"
/*
* memp_sync --
* Mpool sync function.
*/
int
{
return (EINVAL);
}
/*
* We try and write the buffers in page order: it should reduce seeks
* by the underlying filesystem and possibly reduce the actual number
* of writes. We don't want to hold the region lock while we write
* the buffers, so only hold it lock while we create a list. Get a
* good-size block of memory to hold buffer pointers, we don't want
* to run out.
*/
return (ret);
/*
* If the application is asking about a previous call to memp_sync(),
* and we haven't found any buffers that the application holding the
* pin couldn't write, return yes or no based on the current count.
* Note, if the application is asking about a LSN *smaller* than one
* we've already handled or are currently handling, then we return a
* result based on the count for the larger LSN.
*/
ret = 0;
} else
ret = DB_INCOMPLETE;
goto done;
}
/* Else, it's a new checkpoint. */
/*
* Save the LSN. We know that it's a new LSN or larger than the one
* for which we were already doing a checkpoint. (BTW, I don't expect
* to see multiple LSN's from the same or multiple processes, but You
* Just Never Know. Responding as if they all called with the largest
* of the LSNs specified makes everything work.)
*
* We don't currently use the LSN we save. We could potentially save
* the last-written LSN in each buffer header and use it to determine
* what buffers need to be written. The problem with this is that it's
* sizeof(LSN) more bytes of buffer header. We currently write all the
* dirty buffers instead.
*
* Walk the list of shared memory segments clearing the count of
* buffers waiting to be written.
*/
/*
* Walk the list of buffers and mark all dirty buffers to be written
* and all pinned buffers to be potentially written (we can't know if
* we'll need to write them until the holding process returns them to
* the cache). We do this in one pass while holding the region locked
* so that processes can't make new buffers dirty, causing us to never
* finish. Since the application may have restarted the sync, clear
* any BH_WRITE flags that appear to be left over from previous calls.
*
* We don't want to pin down the entire buffer cache, otherwise we'll
* starve threads needing new pages. Don't pin down more than 80% of
* the cache.
*
* Keep a count of the total number of buffers we need to write in
* MPOOL->lsn_cnt, and for each file, in MPOOLFILE->lsn_count.
*/
ar_cnt = 0;
/*
* If the buffer isn't in use, we should be able to
* write it immediately, so increment the reference
* count to lock it and its contents down, and then
* save a reference to it.
*
* If we've run out space to store buffer references,
* we're screwed. We don't want to realloc the array
* while holding a region lock, so we set the flag to
* force the checkpoint to be done again, from scratch,
* later.
*
* If we've pinned down too much of the cache stop, and
* set a flag to force the checkpoint to be tried again
* later.
*/
break;
}
}
} else
/* If there no buffers we can write immediately, we're done. */
if (ar_cnt == 0) {
goto done;
}
/* Sort the buffers we're going to write. */
/* Walk the array, writing buffers. */
/*
* It's possible for a thread to have gotten the buffer since
* we listed it for writing. If the reference count is still
* 1, we're the only ones using the buffer, go ahead and write.
* If it's >1, then skip the buffer and assume that it will be
* written when it's returned to the cache.
*/
continue;
}
/* Write the buffer. */
/* Release the buffer. */
/* If there's an error, release the rest of the buffers. */
/*
* Any process syncing the shared memory buffer pool
* had better be able to write to any underlying file.
* Be understanding, but firm, on this point.
*/
if (ret == 0) {
}
goto err;
}
}
done:
if (0) {
err: /*
* On error, clear:
* MPOOL->lsn_cnt (the total sync count)
* MPOOLFILE->lsn_cnt (the per-file sync count)
* BH_WRITE flag (the scheduled for writing flag)
*/
}
return (ret);
}
/*
* memp_fsync --
* Mpool file sync function.
*/
int
{
int is_tmp;
/*
* If this handle doesn't have a file descriptor that's open for
* writing, or if the file is a temporary, there's no reason to
* proceed further.
*/
return (0);
if (is_tmp)
return (0);
return (__memp_fsync(dbmfp));
}
/*
* __mp_xxx_fd --
* Return a file descriptor for DB 1.85 compatibility locking.
*
* PUBLIC: int __mp_xxx_fd __P((DB_MPOOLFILE *, int *));
*/
int
int *fdp;
{
int ret;
/*
* This is a truly spectacular layering violation, intended ONLY to
* support compatibility for the DB 1.85 DB->fd call.
*
* Sync the database file to disk, creating the file as necessary.
*
* We skip the MP_READONLY and MP_TEMP tests done by memp_fsync(3).
* The MP_READONLY test isn't interesting because we will either
* already have a file descriptor (we opened the database file for
* reading) or we aren't readonly (we created the database which
* requires write privileges). The MP_TEMP test isn't interesting
* because we want to write to the backing file regardless so that
* we get a file descriptor to return.
*/
}
/*
* __memp_fsync --
* Mpool file internal sync function.
*/
static int
{
ret = 0;
/*
* We try and write the buffers in page order: it should reduce seeks
* by the underlying filesystem and possibly reduce the actual number
* of writes. We don't want to hold the region lock while we write
* the buffers, so only hold it lock while we create a list. Get a
* good-size block of memory to hold buffer pointers, we don't want
* to run out.
*/
return (ret);
/*
* Walk the LRU list of buffer headers, and get a list of buffers to
* write for this MPOOLFILE.
*/
ar_cnt = incomplete = 0;
continue;
incomplete = 1;
continue;
}
/*
* If we've run out space to store buffer references, we're
* screwed, as we don't want to realloc the array holding a
* region lock. Set the incomplete flag -- the only way we
* can get here is if the file is active in the buffer cache,
* which is the same thing as finding pinned buffers.
*/
incomplete = 1;
break;
}
}
/* Sort the buffers we're going to write. */
if (ar_cnt != 0)
/* Walk the array, writing buffers. */
/*
* It's possible for a thread to have gotten the buffer since
* we listed it for writing. If the reference count is still
* 1, we're the only ones using the buffer, go ahead and write.
* If it's >1, then skip the buffer.
*/
incomplete = 1;
continue;
}
/* Write the buffer. */
/* Release the buffer. */
/* If there's an error, release the rest of the buffers. */
if (ret != 0) {
goto err;
}
/*
* If we didn't write the buffer for some reason, don't return
* success.
*/
if (!wrote)
incomplete = 1;
}
/*
* Sync the underlying file as the last thing we do, so that the OS
* has maximal opportunity to flush buffers before we request it.
*
* XXX:
* Don't lock the region around the sync, fsync(2) has no atomicity
* issues.
*/
if (ret == 0)
return (ret);
}
/*
* memp_trickle --
* Keep a specified percentage of the buffers clean.
*/
int
{
*nwrotep = 0;
return (EINVAL);
/*
* If there are sufficient clean buffers, or no buffers or no dirty
* buffers, we're done.
*
* XXX
* Using st_page_clean and st_page_dirty is our only choice at the
* moment, but it's not as correct as we might like in the presence
* of pools with more than one buffer size, as a free 512-byte buffer
* isn't the same as a free 8K buffer.
*/
return (0);
}
/* Loop until we write a buffer. */
continue;
/*
* We can't write to temporary files -- see the comment in
* mp_bh.c:__memp_bhwrite().
*/
continue;
goto err;
/*
* Any process syncing the shared memory buffer pool had better
* be able to write to any underlying file. Be understanding,
* but firm, on this point.
*/
if (!wrote) {
goto err;
}
++*nwrotep;
goto loop;
}
/* No more buffers to write. */
ret = 0;
return (ret);
}
static int
{
/* Sort by file (shared memory pool offset). */
return (-1);
return (1);
/*
* !!!
* Defend against badly written quicksort code calling the comparison
* function with two identical pointers (e.g., WATCOM C++ (Power++)).
*/
return (-1);
return (1);
return (0);
}