text: /*-
   * See the file LICENSE for redistribution information.
   *
   * Copyright (c) 1996, 1997, 1998
   *	Sleepycat Software.  All rights reserved.
   */
  #include "config.h"
  
  #ifndef lint
  static const char sccsid[] = "@(#)mp_sync.c	10.31 (Sleepycat) 12/11/98";
  #endif /* not lint */
  
  #ifndef NO_SYSTEM_INCLUDES
  #include <sys/types.h>
  
  #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"
  
  static int __bhcmp __P((const void *, const void *));
  static int __memp_fsync __P((DB_MPOOLFILE *));
  
  /*
   * memp_sync --
   *	Mpool sync function.
   */
  int
  memp_sync(dbmp, lsnp)
  	DB_MPOOL *dbmp;
  	DB_LSN *lsnp;
  {
  	BH *bhp, **bharray;
  	DB_ENV *dbenv;
  	MPOOL *mp;
  	MPOOLFILE *mfp;
  	int ar_cnt, nalloc, next, maxpin, ret, wrote;
  
  	MP_PANIC_CHECK(dbmp);
  
  	dbenv = dbmp->dbenv;
  	mp = dbmp->mp;
  
  	if (dbenv->lg_info == NULL) {
  		__db_err(dbenv, "memp_sync: requires logging");
  		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.
  	 */
  	LOCKREGION(dbmp);
  	nalloc = mp->stat.st_page_dirty + mp->stat.st_page_dirty / 2 + 10;
  	UNLOCKREGION(dbmp);
  
  	if ((ret = __os_malloc(nalloc * sizeof(BH *), NULL, &bharray)) != 0)
  		return (ret);
  
  	LOCKREGION(dbmp);
  
  	/*
  	 * 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.
  	 */
  	if (!F_ISSET(mp, MP_LSN_RETRY) && log_compare(lsnp, &mp->lsn) <= 0) {
  		if (mp->lsn_cnt == 0) {
  			*lsnp = mp->lsn;
  			ret = 0;
  		} else
  			ret = DB_INCOMPLETE;
  		goto done;
  	}
  
  	/* Else, it's a new checkpoint. */
  	F_CLR(mp, MP_LSN_RETRY);
  
  	/*
  	 * 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.
  	 */
  	mp->lsn = *lsnp;
  	mp->lsn_cnt = 0;
  	for (mfp = SH_TAILQ_FIRST(&dbmp->mp->mpfq, __mpoolfile);
  	    mfp != NULL; mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile))
  		mfp->lsn_cnt = 0;
  
  	/*
  	 * 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;
  	maxpin = ((mp->stat.st_page_dirty + mp->stat.st_page_clean) * 8) / 10;
  	for (bhp = SH_TAILQ_FIRST(&mp->bhq, __bh);
  	    bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, q, __bh))
  		if (F_ISSET(bhp, BH_DIRTY) || bhp->ref != 0) {
  			F_SET(bhp, BH_WRITE);
  
  			++mp->lsn_cnt;
  
  			mfp = R_ADDR(dbmp, bhp->mf_offset);
  			++mfp->lsn_cnt;
  
  			/*
  			 * 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.
  			 */
  			if (bhp->ref == 0) {
  				++bhp->ref;
  				bharray[ar_cnt] = bhp;
  				if (++ar_cnt >= nalloc || ar_cnt >= maxpin) {
  					F_SET(mp, MP_LSN_RETRY);
  					break;
  				}
  			}
  		} else
  			if (F_ISSET(bhp, BH_WRITE))
  				F_CLR(bhp, BH_WRITE);
  
  	/* If there no buffers we can write immediately, we're done. */
  	if (ar_cnt == 0) {
  		ret = mp->lsn_cnt ? DB_INCOMPLETE : 0;
  		goto done;
  	}
  
  	UNLOCKREGION(dbmp);
  
  	/* Sort the buffers we're going to write. */
  	qsort(bharray, ar_cnt, sizeof(BH *), __bhcmp);
  
  	LOCKREGION(dbmp);
  
  	/* Walk the array, writing buffers. */
  	for (next = 0; next < ar_cnt; ++next) {
  		/*
  		 * 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.
  		 */
  		if (bharray[next]->ref > 1) {
  			--bharray[next]->ref;
  			continue;
  		}
  
  		/* Write the buffer. */
  		mfp = R_ADDR(dbmp, bharray[next]->mf_offset);
  		ret = __memp_bhwrite(dbmp, mfp, bharray[next], NULL, &wrote);
  
  		/* Release the buffer. */
  		--bharray[next]->ref;
  
  		/* If there's an error, release the rest of the buffers. */
  		if (ret != 0 || !wrote) {
  			/*
  			 * 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) {
  				__db_err(dbenv, "%s: unable to flush page: %lu",
  				    __memp_fns(dbmp, mfp),
  				    (u_long)bharray[next]->pgno);
  				ret = EPERM;
  			}
  
  			while (++next < ar_cnt)
  				--bharray[next]->ref;
  			goto err;
  		}
  	}
  	ret = mp->lsn_cnt != 0 ||
  	    F_ISSET(mp, MP_LSN_RETRY) ? DB_INCOMPLETE : 0;
  
  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)
  		 */
  		mp->lsn_cnt = 0;
  		for (mfp = SH_TAILQ_FIRST(&dbmp->mp->mpfq, __mpoolfile);
  		    mfp != NULL; mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile))
  			mfp->lsn_cnt = 0;
  		for (bhp = SH_TAILQ_FIRST(&mp->bhq, __bh);
  		    bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, q, __bh))
  			F_CLR(bhp, BH_WRITE);
  	}
  	UNLOCKREGION(dbmp);
  	__os_free(bharray, nalloc * sizeof(BH *));
  	return (ret);
  }
  
  /*
   * memp_fsync --
   *	Mpool file sync function.
   */
  int
  memp_fsync(dbmfp)
  	DB_MPOOLFILE *dbmfp;
  {
  	DB_MPOOL *dbmp;
  	int is_tmp;
  
  	dbmp = dbmfp->dbmp;
  
  	MP_PANIC_CHECK(dbmp);
  
  	/*
  	 * 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.
  	 */
  	if (F_ISSET(dbmfp, MP_READONLY))
  		return (0);
  
  	LOCKREGION(dbmp);
  	is_tmp = F_ISSET(dbmfp->mfp, MP_TEMP);
  	UNLOCKREGION(dbmp);
  	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
  __mp_xxx_fd(dbmfp, fdp)
  	DB_MPOOLFILE *dbmfp;
  	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.
  	 */
  	ret = dbmfp->fd == -1 ? __memp_fsync(dbmfp) : 0;
  
  	return ((*fdp = dbmfp->fd) == -1 ? ENOENT : ret);
  }
  
  /*
   * __memp_fsync --
   *	Mpool file internal sync function.
   */
  static int
  __memp_fsync(dbmfp)
  	DB_MPOOLFILE *dbmfp;
  {
  	BH *bhp, **bharray;
  	DB_MPOOL *dbmp;
  	MPOOL *mp;
  	size_t mf_offset;
  	int ar_cnt, incomplete, nalloc, next, ret, wrote;
  
  	ret = 0;
  	dbmp = dbmfp->dbmp;
  	mp = dbmp->mp;
  	mf_offset = R_OFFSET(dbmp, dbmfp->mfp);
  
  	/*
  	 * 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.
  	 */
  	LOCKREGION(dbmp);
  	nalloc = mp->stat.st_page_dirty + mp->stat.st_page_dirty / 2 + 10;
  	UNLOCKREGION(dbmp);
  
  	if ((ret = __os_malloc(nalloc * sizeof(BH *), NULL, &bharray)) != 0)
  		return (ret);
  
  	LOCKREGION(dbmp);
  
  	/*
  	 * Walk the LRU list of buffer headers, and get a list of buffers to
  	 * write for this MPOOLFILE.
  	 */
  	ar_cnt = incomplete = 0;
  	for (bhp = SH_TAILQ_FIRST(&mp->bhq, __bh);
  	    bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, q, __bh)) {
  		if (!F_ISSET(bhp, BH_DIRTY) || bhp->mf_offset != mf_offset)
  			continue;
  		if (bhp->ref != 0 || F_ISSET(bhp, BH_LOCKED)) {
  			incomplete = 1;
  			continue;
  		}
  
  		++bhp->ref;
  		bharray[ar_cnt] = bhp;
  
  		/*
  		 * 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.
  		 */
  		if (++ar_cnt >= nalloc) {
  			incomplete = 1;
  			break;
  		}
  	}
  
  	UNLOCKREGION(dbmp);
  
  	/* Sort the buffers we're going to write. */
  	if (ar_cnt != 0)
  		qsort(bharray, ar_cnt, sizeof(BH *), __bhcmp);
  
  	LOCKREGION(dbmp);
  
  	/* Walk the array, writing buffers. */
  	for (next = 0; next < ar_cnt; ++next) {
  		/*
  		 * 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.
  		 */
  		if (bharray[next]->ref > 1) {
  			incomplete = 1;
  
  			--bharray[next]->ref;
  			continue;
  		}
  
  		/* Write the buffer. */
  		ret = __memp_pgwrite(dbmfp, bharray[next], NULL, &wrote);
  
  		/* Release the buffer. */
  		--bharray[next]->ref;
  
  		/* If there's an error, release the rest of the buffers. */
  		if (ret != 0) {
  			while (++next < ar_cnt)
  				--bharray[next]->ref;
  			goto err;
  		}
  
  		/*
  		 * If we didn't write the buffer for some reason, don't return
  		 * success.
  		 */
  		if (!wrote)
  			incomplete = 1;
  	}
  
  err:	UNLOCKREGION(dbmp);
  
  	__os_free(bharray, nalloc * sizeof(BH *));
  
  	/*
  	 * 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 (incomplete ? DB_INCOMPLETE : __os_fsync(dbmfp->fd));
  	return (ret);
  }
  
  /*
   * memp_trickle --
   *	Keep a specified percentage of the buffers clean.
   */
  int
  memp_trickle(dbmp, pct, nwrotep)
  	DB_MPOOL *dbmp;
  	int pct, *nwrotep;
  {
  	BH *bhp;
  	MPOOL *mp;
  	MPOOLFILE *mfp;
  	db_pgno_t pgno;
  	u_long total;
  	int ret, wrote;
  
  	MP_PANIC_CHECK(dbmp);
  
  	mp = dbmp->mp;
  	if (nwrotep != NULL)
  		*nwrotep = 0;
  
  	if (pct < 1 || pct > 100)
  		return (EINVAL);
  
  	LOCKREGION(dbmp);
  
  	/*
  	 * 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.
  	 */
  loop:	total = mp->stat.st_page_clean + mp->stat.st_page_dirty;
  	if (total == 0 || mp->stat.st_page_dirty == 0 ||
  	    (mp->stat.st_page_clean * 100) / total >= (u_long)pct) {
  		UNLOCKREGION(dbmp);
  		return (0);
  	}
  
  	/* Loop until we write a buffer. */
  	for (bhp = SH_TAILQ_FIRST(&mp->bhq, __bh);
  	    bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, q, __bh)) {
  		if (bhp->ref != 0 ||
  		    !F_ISSET(bhp, BH_DIRTY) || F_ISSET(bhp, BH_LOCKED))
  			continue;
  
  		mfp = R_ADDR(dbmp, bhp->mf_offset);
  
  		/*
  		 * We can't write to temporary files -- see the comment in
  		 * mp_bh.c:__memp_bhwrite().
  		 */
  		if (F_ISSET(mfp, MP_TEMP))
  			continue;
  
  		pgno = bhp->pgno;
  		if ((ret = __memp_bhwrite(dbmp, mfp, bhp, NULL, &wrote)) != 0)
  			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) {
  			__db_err(dbmp->dbenv, "%s: unable to flush page: %lu",
  			    __memp_fns(dbmp, mfp), (u_long)pgno);
  			ret = EPERM;
  			goto err;
  		}
  
  		++mp->stat.st_page_trickle;
  		if (nwrotep != NULL)
  			++*nwrotep;
  		goto loop;
  	}
  
  	/* No more buffers to write. */
  	ret = 0;
  
  err:	UNLOCKREGION(dbmp);
  	return (ret);
  }
  
  static int
  __bhcmp(p1, p2)
  	const void *p1, *p2;
  {
  	BH *bhp1, *bhp2;
  
  	bhp1 = *(BH * const *)p1;
  	bhp2 = *(BH * const *)p2;
  
  	/* Sort by file (shared memory pool offset). */
  	if (bhp1->mf_offset < bhp2->mf_offset)
  		return (-1);
  	if (bhp1->mf_offset > bhp2->mf_offset)
  		return (1);
  
  	/*
  	 * !!!
  	 * Defend against badly written quicksort code calling the comparison
  	 * function with two identical pointers (e.g., WATCOM C++ (Power++)).
  	 */
  	if (bhp1->pgno < bhp2->pgno)
  		return (-1);
  	if (bhp1->pgno > bhp2->pgno)
  		return (1);
  	return (0);
  }
  