/*- * 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); }
