/* $NetBSD: rcache.c,v 1.25 2015/08/24 17:34:03 bouyer Exp $ */ /*- * Copyright (c) 1999 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Martin J. Laubach and * Manuel Bouyer . * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include #ifndef lint __RCSID("$NetBSD: rcache.c,v 1.25 2015/08/24 17:34:03 bouyer Exp $"); #endif /* not lint */ #include #include #include #include #include #include #include #include #include #include #include #include "dump.h" /*-----------------------------------------------------------------------*/ #define MAXCACHEBUFS 512 /* max 512 buffers */ #define MAXMEMPART 6 /* max 15% of the user mem */ /*-----------------------------------------------------------------------*/ union cdesc { volatile size_t cd_count; struct { volatile daddr_t blkstart; volatile daddr_t blkend; /* start + nblksread */ volatile daddr_t blocksRead; volatile size_t time; #ifdef DIAGNOSTICS volatile pid_t owner; #endif } desc; #define cd_blkstart desc.blkstart #define cd_blkend desc.blkend #define cd_blocksRead desc.blocksRead #define cd_time desc.time #define cd_owner desc.owner }; static int findlru(void); static void *shareBuffer = NULL; static union cdesc *cheader; static union cdesc *cdesc; static char *cdata; static int cachebufs; static int nblksread; #ifdef STATS static int nreads; static int nphysread; static int64_t readsize; static int64_t physreadsize; #endif #define CSIZE (nblksread << dev_bshift) /* cache buf size */ #define CDATA(desc) (cdata + ((desc) - cdesc) * CSIZE) void initcache(int cachesize, int readblksize) { size_t len; size_t sharedSize; if (readblksize == -1) { /* use kern.maxphys */ int kern_maxphys; int mib[2] = { CTL_KERN, KERN_MAXPHYS }; len = sizeof(kern_maxphys); if (sysctl(mib, 2, &kern_maxphys, &len, NULL, 0) < 0) { msg("sysctl(kern.maxphys) failed: %s\n", strerror(errno)); return; } readblksize = kern_maxphys; } /* Convert read block size in terms of filesystem block size */ nblksread = howmany(readblksize, ufsib->ufs_bsize); /* Then, convert it in terms of device block size */ nblksread <<= ufsib->ufs_bshift - dev_bshift; if (cachesize == -1) { /* Compute from memory available */ uint64_t usermem, cachetmp; int mib[2] = { CTL_HW, HW_USERMEM64 }; len = sizeof(usermem); if (sysctl(mib, 2, &usermem, &len, NULL, 0) < 0) { msg("sysctl(hw.usermem) failed: %s\n", strerror(errno)); return; } cachetmp = (usermem / MAXMEMPART) / CSIZE; /* for those with TB of RAM */ cachebufs = (cachetmp > INT_MAX) ? INT_MAX : cachetmp; } else { /* User specified */ cachebufs = cachesize; } if (cachebufs) { /* Don't allocate if zero --> no caching */ if (cachebufs > MAXCACHEBUFS) cachebufs = MAXCACHEBUFS; sharedSize = sizeof(union cdesc) + sizeof(union cdesc) * cachebufs + cachebufs * CSIZE; #ifdef STATS fprintf(stderr, "Using %d buffers (%d bytes)\n", cachebufs, sharedSize); #endif shareBuffer = mmap(NULL, sharedSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0); if (shareBuffer == MAP_FAILED) { msg("can't mmap shared memory for buffer: %s\n", strerror(errno)); return; } cheader = shareBuffer; cdesc = (union cdesc *) (((char *) shareBuffer) + sizeof(union cdesc)); cdata = ((char *) shareBuffer) + sizeof(union cdesc) + sizeof(union cdesc) * cachebufs; memset(shareBuffer, '\0', sharedSize); } } /* * Find the cache buffer descriptor that shows the minimal access time */ static int findlru(void) { int i; size_t minTime = cdesc[0].cd_time; int minIdx = 0; for (i = 0; i < cachebufs; i++) { if (cdesc[i].cd_time < minTime) { minIdx = i; minTime = cdesc[i].cd_time; } } return minIdx; } /* * Read data directly from disk, with smart error handling. * Try to recover from hard errors by reading in sector sized pieces. * Error recovery is attempted at most BREADEMAX times before seeking * consent from the operator to continue. */ static int breaderrors = 0; #define BREADEMAX 32 void rawread(daddr_t blkno, char *buf, int size) { int cnt, i; #ifdef STATS nphysread++; physreadsize += size; #endif loop: if (lseek(diskfd, ((off_t) blkno << dev_bshift), SEEK_SET) == -1) { msg("rawread: lseek fails\n"); goto err; } if ((cnt = read(diskfd, buf, size)) == size) return; if (blkno + (size >> dev_bshift) > ufsib->ufs_dsize) { /* * Trying to read the final fragment. * * NB - dump only works in TP_BSIZE blocks, hence * rounds `dev_bsize' fragments up to TP_BSIZE pieces. * It should be smarter about not actually trying to * read more than it can get, but for the time being * we punt and scale back the read only when it gets * us into trouble. (mkm 9/25/83) */ size -= dev_bsize; goto loop; } if (cnt == -1) msg("read error from %s: %s: [block %lld]: count=%d\n", disk, strerror(errno), (long long)blkno, size); else msg("short read error from %s: [block %lld]: " "count=%d, got=%d\n", disk, (long long)blkno, size, cnt); err: if (++breaderrors > BREADEMAX) { msg("More than %d block read errors from %s\n", BREADEMAX, disk); broadcast("DUMP IS AILING!\n"); msg("This is an unrecoverable error.\n"); if (!query("Do you want to attempt to continue?")) { dumpabort(0); /*NOTREACHED*/ } else breaderrors = 0; } /* * Zero buffer, then try to read each sector of buffer separately. */ memset(buf, 0, size); for (i = 0; i < size; i += dev_bsize, buf += dev_bsize, blkno++) { if (lseek(diskfd, ((off_t)blkno << dev_bshift), SEEK_SET) == -1) { msg("rawread: lseek2 fails: %s!\n", strerror(errno)); continue; } if ((cnt = read(diskfd, buf, (int)dev_bsize)) == dev_bsize) continue; if (cnt == -1) { msg("read error from %s: %s: [sector %lld]: " "count=%ld\n", disk, strerror(errno), (long long)blkno, dev_bsize); continue; } msg("short read error from %s: [sector %lld]: " "count=%ld, got=%d\n", disk, (long long)blkno, dev_bsize, cnt); } } void bread(daddr_t blkno, char *buf, int size) { int osize = size, idx; daddr_t oblkno = blkno; char *obuf = buf; daddr_t numBlocks = howmany(size, dev_bsize); #ifdef STATS nreads++; readsize += size; #endif if (!shareBuffer) { rawread(blkno, buf, size); return; } if (flock(diskfd, LOCK_EX)) { msg("flock(LOCK_EX) failed: %s\n", strerror(errno)); rawread(blkno, buf, size); return; } retry: idx = 0; while (size > 0) { int i; for (i = 0; i < cachebufs; i++) { union cdesc *curr = &cdesc[(i + idx) % cachebufs]; #ifdef DIAGNOSTICS if (curr->cd_owner) { fprintf(stderr, "Owner is set (%d, me=%d), can" "not happen.\n", curr->cd_owner, getpid()); } #endif if (curr->cd_blkend == 0) continue; /* * If we find a bit of the read in the buffers, * now compute how many blocks we can copy, * copy them out, adjust blkno, buf and size, * and restart */ if (curr->cd_blkstart <= blkno && blkno < curr->cd_blkend) { /* Number of data blocks to be copied */ int toCopy = MIN(size, (curr->cd_blkend - blkno) << dev_bshift); #ifdef DIAGNOSTICS if (toCopy <= 0 || toCopy > CSIZE) { fprintf(stderr, "toCopy %d !\n", toCopy); dumpabort(0); } if (CDATA(curr) + ((blkno - curr->cd_blkstart) << dev_bshift) < CDATA(curr) || CDATA(curr) + ((blkno - curr->cd_blkstart) << dev_bshift) > CDATA(curr) + CSIZE) { fprintf(stderr, "%p < %p !!!\n", CDATA(curr) + ((blkno - curr->cd_blkstart) << dev_bshift), CDATA(curr)); fprintf(stderr, "cdesc[i].cd_blkstart %lld " "blkno %lld dev_bsize %ld\n", (long long)curr->cd_blkstart, (long long)blkno, dev_bsize); dumpabort(0); } #endif memcpy(buf, CDATA(curr) + ((blkno - curr->cd_blkstart) << dev_bshift), toCopy); buf += toCopy; size -= toCopy; blkno += howmany(toCopy, dev_bsize); numBlocks -= howmany(toCopy, dev_bsize); curr->cd_time = cheader->cd_count++; /* * If all data of a cache block have been * read, chances are good no more reads * will occur, so expire the cache immediately */ curr->cd_blocksRead += howmany(toCopy, dev_bsize); if (curr->cd_blocksRead >= nblksread) curr->cd_time = 0; goto retry; } } /* No more to do? */ if (size == 0) break; /* * This does actually not happen if fs blocks are not greater * than nblksread. */ if (numBlocks > nblksread || blkno >= ufsib->ufs_dsize) { rawread(oblkno, obuf, osize); break; } else { ssize_t rsize; daddr_t blockBlkNo; blockBlkNo = (blkno / nblksread) * nblksread; idx = findlru(); rsize = MIN(nblksread, ufsib->ufs_dsize - blockBlkNo) << dev_bshift; #ifdef DIAGNOSTICS if (cdesc[idx].cd_owner) fprintf(stderr, "Owner is set (%d, me=%d), can" "not happen(2).\n", cdesc[idx].cd_owner, getpid()); cdesc[idx].cd_owner = getpid(); #endif cdesc[idx].cd_time = cheader->cd_count++; cdesc[idx].cd_blkstart = blockBlkNo; cdesc[idx].cd_blkend = 0; cdesc[idx].cd_blocksRead = 0; if (lseek(diskfd, ((off_t) blockBlkNo << dev_bshift), SEEK_SET) == -1) { msg("readBlocks: lseek fails: %s\n", strerror(errno)); rsize = -1; } else { rsize = read(diskfd, CDATA(&cdesc[idx]), rsize); if (rsize < 0) { msg("readBlocks: read fails: %s\n", strerror(errno)); } } /* On errors, panic, punt, try to read without * cache and let raw read routine do the rest. */ if (rsize <= 0) { rawread(oblkno, obuf, osize); #ifdef DIAGNOSTICS if (cdesc[idx].cd_owner != getpid()) fprintf(stderr, "Owner changed from " "%d to %d, can't happen\n", getpid(), cdesc[idx].cd_owner); cdesc[idx].cd_owner = 0; #endif break; } /* On short read, just note the fact and go on */ cdesc[idx].cd_blkend = blockBlkNo + rsize / dev_bsize; #ifdef STATS nphysread++; physreadsize += rsize; #endif #ifdef DIAGNOSTICS if (cdesc[idx].cd_owner != getpid()) fprintf(stderr, "Owner changed from " "%d to %d, can't happen\n", getpid(), cdesc[idx].cd_owner); cdesc[idx].cd_owner = 0; #endif /* * We swapped some of data in, let the loop fetch * them from cache */ } } if (flock(diskfd, LOCK_UN)) msg("flock(LOCK_UN) failed: %s\n", strerror(errno)); } void printcachestats(void) { #ifdef STATS fprintf(stderr, "Pid %d: %d reads (%u bytes) " "%d physical reads (%u bytes) %d%% hits, %d%% overhead\n", getpid(), nreads, (u_int) readsize, nphysread, (u_int) physreadsize, (nreads - nphysread) * 100 / nreads, (int) (((physreadsize - readsize) * 100) / readsize)); #endif }