xref: /netbsd-src/sbin/dump/rcache.c (revision 262ce6cb8d91580a89281aa6446fd3293b43b759)
1*262ce6cbSbouyer /*	$NetBSD: rcache.c,v 1.25 2015/08/24 17:34:03 bouyer Exp $	*/
2491d912fSbouyer 
3491d912fSbouyer /*-
4491d912fSbouyer  * Copyright (c) 1999 The NetBSD Foundation, Inc.
5491d912fSbouyer  * All rights reserved.
6491d912fSbouyer  *
7491d912fSbouyer  * This code is derived from software contributed to The NetBSD Foundation
8491d912fSbouyer  * by Martin J. Laubach <mjl@emsi.priv.at> and
9491d912fSbouyer  *    Manuel Bouyer <Manuel.Bouyer@lip6.fr>.
10491d912fSbouyer  *
11491d912fSbouyer  * Redistribution and use in source and binary forms, with or without
12491d912fSbouyer  * modification, are permitted provided that the following conditions
13491d912fSbouyer  * are met:
14491d912fSbouyer  * 1. Redistributions of source code must retain the above copyright
15491d912fSbouyer  *    notice, this list of conditions and the following disclaimer.
16491d912fSbouyer  * 2. Redistributions in binary form must reproduce the above copyright
17491d912fSbouyer  *    notice, this list of conditions and the following disclaimer in the
18491d912fSbouyer  *    documentation and/or other materials provided with the distribution.
19491d912fSbouyer  *
20491d912fSbouyer  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21491d912fSbouyer  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22491d912fSbouyer  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23491d912fSbouyer  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24491d912fSbouyer  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25491d912fSbouyer  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26491d912fSbouyer  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27491d912fSbouyer  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28491d912fSbouyer  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29491d912fSbouyer  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30491d912fSbouyer  * POSSIBILITY OF SUCH DAMAGE.
31491d912fSbouyer  */
3256705fb8Slukem 
3356705fb8Slukem #include <sys/cdefs.h>
3456705fb8Slukem #ifndef lint
35*262ce6cbSbouyer __RCSID("$NetBSD: rcache.c,v 1.25 2015/08/24 17:34:03 bouyer Exp $");
3656705fb8Slukem #endif /* not lint */
3756705fb8Slukem 
38491d912fSbouyer #include <sys/types.h>
39491d912fSbouyer #include <sys/uio.h>
40491d912fSbouyer #include <sys/mman.h>
41491d912fSbouyer #include <sys/param.h>
42491d912fSbouyer #include <sys/sysctl.h>
43491d912fSbouyer 
44491d912fSbouyer #include <stdio.h>
45491d912fSbouyer #include <stdlib.h>
46491d912fSbouyer #include <unistd.h>
47491d912fSbouyer #include <fcntl.h>
48491d912fSbouyer #include <errno.h>
49491d912fSbouyer #include <string.h>
50491d912fSbouyer 
51491d912fSbouyer #include "dump.h"
52491d912fSbouyer 
53491d912fSbouyer /*-----------------------------------------------------------------------*/
54491d912fSbouyer #define MAXCACHEBUFS	512	/* max 512 buffers */
55491d912fSbouyer #define MAXMEMPART	6	/* max 15% of the user mem */
56491d912fSbouyer 
57491d912fSbouyer /*-----------------------------------------------------------------------*/
58c089bab6Shannken union cdesc {
59c089bab6Shannken 	volatile size_t cd_count;
60c089bab6Shannken 	struct {
61491d912fSbouyer 		volatile daddr_t blkstart;
62491d912fSbouyer 		volatile daddr_t blkend;	/* start + nblksread */
63491d912fSbouyer 		volatile daddr_t blocksRead;
64491d912fSbouyer 		volatile size_t time;
65491d912fSbouyer #ifdef DIAGNOSTICS
66491d912fSbouyer 		volatile pid_t owner;
67491d912fSbouyer #endif
68c089bab6Shannken 	} desc;
69c089bab6Shannken #define cd_blkstart	desc.blkstart
70c089bab6Shannken #define cd_blkend	desc.blkend
71c089bab6Shannken #define cd_blocksRead	desc.blocksRead
72c089bab6Shannken #define cd_time		desc.time
73c089bab6Shannken #define cd_owner	desc.owner
74491d912fSbouyer };
75491d912fSbouyer 
7699feaf5bSlukem static int findlru(void);
77491d912fSbouyer 
78491d912fSbouyer static void *shareBuffer = NULL;
79c089bab6Shannken static union cdesc *cheader;
80c089bab6Shannken static union cdesc *cdesc;
81491d912fSbouyer static char *cdata;
82491d912fSbouyer static int cachebufs;
83491d912fSbouyer static int nblksread;
84491d912fSbouyer 
85491d912fSbouyer #ifdef STATS
86491d912fSbouyer static int nreads;
87491d912fSbouyer static int nphysread;
88491d912fSbouyer static int64_t readsize;
89491d912fSbouyer static int64_t physreadsize;
90491d912fSbouyer #endif
91491d912fSbouyer 
923053f5ecSenami #define	CSIZE		(nblksread << dev_bshift)	/* cache buf size */
933053f5ecSenami #define	CDATA(desc)	(cdata + ((desc) - cdesc) * CSIZE)
94491d912fSbouyer 
95491d912fSbouyer void
initcache(int cachesize,int readblksize)9699feaf5bSlukem initcache(int cachesize, int readblksize)
97491d912fSbouyer {
98491d912fSbouyer 	size_t len;
99491d912fSbouyer 	size_t sharedSize;
100491d912fSbouyer 
101*262ce6cbSbouyer 	if (readblksize == -1) { /* use kern.maxphys */
102*262ce6cbSbouyer 		int kern_maxphys;
103*262ce6cbSbouyer 		int mib[2] = { CTL_KERN, KERN_MAXPHYS };
104*262ce6cbSbouyer 
105*262ce6cbSbouyer 		len = sizeof(kern_maxphys);
106*262ce6cbSbouyer 		if (sysctl(mib, 2, &kern_maxphys, &len, NULL, 0) < 0) {
107*262ce6cbSbouyer 			msg("sysctl(kern.maxphys) failed: %s\n",
108*262ce6cbSbouyer 			    strerror(errno));
109*262ce6cbSbouyer 			return;
110*262ce6cbSbouyer 		}
111*262ce6cbSbouyer 		readblksize = kern_maxphys;
112*262ce6cbSbouyer 	}
113*262ce6cbSbouyer 
114c886a052Senami 	/* Convert read block size in terms of filesystem block size */
115799974edSenami 	nblksread = howmany(readblksize, ufsib->ufs_bsize);
116c886a052Senami 
117c886a052Senami 	/* Then, convert it in terms of device block size */
118c886a052Senami 	nblksread <<= ufsib->ufs_bshift - dev_bshift;
119c886a052Senami 
120491d912fSbouyer 	if (cachesize == -1) {	/* Compute from memory available */
1211cb24f3fSspz 		uint64_t usermem, cachetmp;
122bb850c0cSsimonb 		int mib[2] = { CTL_HW, HW_USERMEM64 };
123491d912fSbouyer 
124491d912fSbouyer 		len = sizeof(usermem);
125491d912fSbouyer 		if (sysctl(mib, 2, &usermem, &len, NULL, 0) < 0) {
126799974edSenami 			msg("sysctl(hw.usermem) failed: %s\n",
127799974edSenami 			    strerror(errno));
128491d912fSbouyer 			return;
129491d912fSbouyer 		}
1301cb24f3fSspz 		cachetmp = (usermem / MAXMEMPART) / CSIZE;
1311cb24f3fSspz 		/* for those with TB of RAM */
1321cb24f3fSspz 		cachebufs = (cachetmp > INT_MAX) ? INT_MAX : cachetmp;
133491d912fSbouyer 	} else {		/* User specified */
134491d912fSbouyer 		cachebufs = cachesize;
135491d912fSbouyer 	}
136491d912fSbouyer 
137491d912fSbouyer 	if (cachebufs) {	/* Don't allocate if zero --> no caching */
138491d912fSbouyer 		if (cachebufs > MAXCACHEBUFS)
139491d912fSbouyer 			cachebufs = MAXCACHEBUFS;
140491d912fSbouyer 
141c089bab6Shannken 		sharedSize = sizeof(union cdesc) +
142c089bab6Shannken 	   	    sizeof(union cdesc) * cachebufs +
1433053f5ecSenami 	   	    cachebufs * CSIZE;
144491d912fSbouyer #ifdef STATS
145491d912fSbouyer 		fprintf(stderr, "Using %d buffers (%d bytes)\n", cachebufs,
146491d912fSbouyer 	   	    sharedSize);
147491d912fSbouyer #endif
148491d912fSbouyer 		shareBuffer = mmap(NULL, sharedSize, PROT_READ | PROT_WRITE,
149491d912fSbouyer 	   	    MAP_ANON | MAP_SHARED, -1, 0);
150799974edSenami 		if (shareBuffer == MAP_FAILED) {
151491d912fSbouyer 			msg("can't mmap shared memory for buffer: %s\n",
152491d912fSbouyer 			    strerror(errno));
153491d912fSbouyer 			return;
154491d912fSbouyer 		}
155491d912fSbouyer 		cheader = shareBuffer;
156c089bab6Shannken 		cdesc = (union cdesc *) (((char *) shareBuffer) +
157c089bab6Shannken 		    sizeof(union cdesc));
158c089bab6Shannken 		cdata = ((char *) shareBuffer) + sizeof(union cdesc) +
159c089bab6Shannken 	   	    sizeof(union cdesc) * cachebufs;
160491d912fSbouyer 
161491d912fSbouyer 		memset(shareBuffer, '\0', sharedSize);
162491d912fSbouyer 	}
163491d912fSbouyer }
164491d912fSbouyer 
16599feaf5bSlukem /*
16699feaf5bSlukem  * Find the cache buffer descriptor that shows the minimal access time
16799feaf5bSlukem  */
168491d912fSbouyer static int
findlru(void)16999feaf5bSlukem findlru(void)
170491d912fSbouyer {
171491d912fSbouyer 	int	i;
172c089bab6Shannken 	size_t	minTime = cdesc[0].cd_time;
173491d912fSbouyer 	int	minIdx = 0;
174491d912fSbouyer 
175491d912fSbouyer 	for (i = 0; i < cachebufs; i++) {
176c089bab6Shannken 		if (cdesc[i].cd_time < minTime) {
177491d912fSbouyer 			minIdx = i;
178c089bab6Shannken 			minTime = cdesc[i].cd_time;
179491d912fSbouyer 		}
180491d912fSbouyer 	}
181491d912fSbouyer 
182491d912fSbouyer 	return minIdx;
183491d912fSbouyer }
18499feaf5bSlukem 
185491d912fSbouyer /*
186491d912fSbouyer  * Read data directly from disk, with smart error handling.
187491d912fSbouyer  * Try to recover from hard errors by reading in sector sized pieces.
188491d912fSbouyer  * Error recovery is attempted at most BREADEMAX times before seeking
189491d912fSbouyer  * consent from the operator to continue.
190491d912fSbouyer  */
191491d912fSbouyer 
192491d912fSbouyer static int breaderrors = 0;
193491d912fSbouyer #define BREADEMAX 32
194491d912fSbouyer 
195491d912fSbouyer void
rawread(daddr_t blkno,char * buf,int size)19699feaf5bSlukem rawread(daddr_t blkno, char *buf, int size)
197491d912fSbouyer {
198491d912fSbouyer 	int cnt, i;
199799974edSenami 
200491d912fSbouyer #ifdef STATS
201491d912fSbouyer 	nphysread++;
202491d912fSbouyer 	physreadsize += size;
203491d912fSbouyer #endif
204491d912fSbouyer 
205750a014cSlukem loop:
2068d849f48Senami 	if (lseek(diskfd, ((off_t) blkno << dev_bshift), SEEK_SET) == -1) {
207491d912fSbouyer 		msg("rawread: lseek fails\n");
208491d912fSbouyer 		goto err;
209491d912fSbouyer 	}
210491d912fSbouyer 	if ((cnt = read(diskfd, buf, size)) == size)
211491d912fSbouyer 		return;
2123053f5ecSenami 	if (blkno + (size >> dev_bshift) > ufsib->ufs_dsize) {
213750a014cSlukem 		/*
214750a014cSlukem 		 * Trying to read the final fragment.
215750a014cSlukem 		 *
216750a014cSlukem 		 * NB - dump only works in TP_BSIZE blocks, hence
217750a014cSlukem 		 * rounds `dev_bsize' fragments up to TP_BSIZE pieces.
218750a014cSlukem 		 * It should be smarter about not actually trying to
219750a014cSlukem 		 * read more than it can get, but for the time being
220750a014cSlukem 		 * we punt and scale back the read only when it gets
221750a014cSlukem 		 * us into trouble. (mkm 9/25/83)
222750a014cSlukem 		 */
223750a014cSlukem 		size -= dev_bsize;
224750a014cSlukem 		goto loop;
225750a014cSlukem 	}
226491d912fSbouyer 	if (cnt == -1)
227a3ff3a30Sfvdl 		msg("read error from %s: %s: [block %lld]: count=%d\n",
228a3ff3a30Sfvdl 		    disk, strerror(errno), (long long)blkno, size);
229491d912fSbouyer 	else
230799974edSenami 		msg("short read error from %s: [block %lld]: "
231799974edSenami 		    "count=%d, got=%d\n",
232a3ff3a30Sfvdl 		    disk, (long long)blkno, size, cnt);
233491d912fSbouyer err:
234491d912fSbouyer 	if (++breaderrors > BREADEMAX) {
2351e8e167aSbriggs 		msg("More than %d block read errors from %s\n",
236491d912fSbouyer 		    BREADEMAX, disk);
237491d912fSbouyer 		broadcast("DUMP IS AILING!\n");
238491d912fSbouyer 		msg("This is an unrecoverable error.\n");
239491d912fSbouyer 		if (!query("Do you want to attempt to continue?")) {
240491d912fSbouyer 			dumpabort(0);
241491d912fSbouyer 			/*NOTREACHED*/
242491d912fSbouyer 		} else
243491d912fSbouyer 			breaderrors = 0;
244491d912fSbouyer 	}
245491d912fSbouyer 	/*
246491d912fSbouyer 	 * Zero buffer, then try to read each sector of buffer separately.
247491d912fSbouyer 	 */
248491d912fSbouyer 	memset(buf, 0, size);
249491d912fSbouyer 	for (i = 0; i < size; i += dev_bsize, buf += dev_bsize, blkno++) {
250799974edSenami 		if (lseek(diskfd, ((off_t)blkno << dev_bshift),
2518d849f48Senami 		    SEEK_SET) == -1) {
252491d912fSbouyer 			msg("rawread: lseek2 fails: %s!\n",
253491d912fSbouyer 			    strerror(errno));
254491d912fSbouyer 			continue;
255491d912fSbouyer 		}
256491d912fSbouyer 		if ((cnt = read(diskfd, buf, (int)dev_bsize)) == dev_bsize)
257491d912fSbouyer 			continue;
258491d912fSbouyer 		if (cnt == -1) {
259799974edSenami 			msg("read error from %s: %s: [sector %lld]: "
260166444b3Senami 			    "count=%ld\n", disk, strerror(errno),
261166444b3Senami 			    (long long)blkno, dev_bsize);
262491d912fSbouyer 			continue;
263491d912fSbouyer 		}
264799974edSenami 		msg("short read error from %s: [sector %lld]: "
265799974edSenami 		    "count=%ld, got=%d\n",
266a3ff3a30Sfvdl 		    disk, (long long)blkno, dev_bsize, cnt);
267491d912fSbouyer 	}
268491d912fSbouyer }
269491d912fSbouyer 
270491d912fSbouyer void
bread(daddr_t blkno,char * buf,int size)27199feaf5bSlukem bread(daddr_t blkno, char *buf, int size)
272491d912fSbouyer {
2733053f5ecSenami 	int	osize = size, idx;
274491d912fSbouyer 	daddr_t oblkno = blkno;
275491d912fSbouyer 	char   *obuf = buf;
276799974edSenami 	daddr_t numBlocks = howmany(size, dev_bsize);
277491d912fSbouyer 
278491d912fSbouyer #ifdef STATS
279491d912fSbouyer 	nreads++;
280491d912fSbouyer 	readsize += size;
281491d912fSbouyer #endif
282491d912fSbouyer 
283491d912fSbouyer 	if (!shareBuffer) {
284491d912fSbouyer 		rawread(blkno, buf, size);
285491d912fSbouyer 		return;
286491d912fSbouyer 	}
287491d912fSbouyer 
288491d912fSbouyer 	if (flock(diskfd, LOCK_EX)) {
289491d912fSbouyer 		msg("flock(LOCK_EX) failed: %s\n",
290491d912fSbouyer 		    strerror(errno));
291491d912fSbouyer 		rawread(blkno, buf, size);
292491d912fSbouyer 		return;
293491d912fSbouyer 	}
294491d912fSbouyer 
295491d912fSbouyer retry:
2963053f5ecSenami 	idx = 0;
297491d912fSbouyer 	while (size > 0) {
298491d912fSbouyer 		int	i;
299491d912fSbouyer 
300491d912fSbouyer 		for (i = 0; i < cachebufs; i++) {
3013053f5ecSenami 			union cdesc *curr = &cdesc[(i + idx) % cachebufs];
302491d912fSbouyer 
303491d912fSbouyer #ifdef DIAGNOSTICS
304c089bab6Shannken 			if (curr->cd_owner) {
305491d912fSbouyer 				fprintf(stderr, "Owner is set (%d, me=%d), can"
306c089bab6Shannken 				    "not happen.\n", curr->cd_owner, getpid());
307491d912fSbouyer 			}
308491d912fSbouyer #endif
309491d912fSbouyer 
310c089bab6Shannken 			if (curr->cd_blkend == 0)
311491d912fSbouyer 				continue;
312491d912fSbouyer 			/*
313491d912fSbouyer 			 * If we find a bit of the read in the buffers,
314491d912fSbouyer 			 * now compute how many blocks we can copy,
315491d912fSbouyer 			 * copy them out, adjust blkno, buf and size,
316491d912fSbouyer 			 * and restart
317491d912fSbouyer 			 */
318c089bab6Shannken 			if (curr->cd_blkstart <= blkno &&
319c089bab6Shannken 			    blkno < curr->cd_blkend) {
320491d912fSbouyer 				/* Number of data blocks to be copied */
32199feaf5bSlukem 				int toCopy = MIN(size,
3223053f5ecSenami 				    (curr->cd_blkend - blkno) << dev_bshift);
323491d912fSbouyer #ifdef DIAGNOSTICS
3243053f5ecSenami 				if (toCopy <= 0 || toCopy > CSIZE) {
325491d912fSbouyer 					fprintf(stderr, "toCopy %d !\n",
326491d912fSbouyer 					    toCopy);
327491d912fSbouyer 					dumpabort(0);
328491d912fSbouyer 				}
3293053f5ecSenami 				if (CDATA(curr) +
3303053f5ecSenami 				    ((blkno - curr->cd_blkstart) <<
331c27806c8Senami 				    dev_bshift) < CDATA(curr) ||
3323053f5ecSenami 			   	    CDATA(curr) +
3333053f5ecSenami 				    ((blkno - curr->cd_blkstart) <<
334c27806c8Senami 			   	    dev_bshift) > CDATA(curr) + CSIZE) {
335491d912fSbouyer 					fprintf(stderr, "%p < %p !!!\n",
3363053f5ecSenami 				   	   CDATA(curr) + ((blkno -
3373053f5ecSenami 					   curr->cd_blkstart) << dev_bshift),
3383053f5ecSenami 					   CDATA(curr));
3393053f5ecSenami 					fprintf(stderr,
3403053f5ecSenami 					    "cdesc[i].cd_blkstart %lld "
3413053f5ecSenami 					    "blkno %lld dev_bsize %ld\n",
3423053f5ecSenami 				   	    (long long)curr->cd_blkstart,
3433053f5ecSenami 					    (long long)blkno,
3443053f5ecSenami 					    dev_bsize);
345491d912fSbouyer 					dumpabort(0);
346491d912fSbouyer 				}
347491d912fSbouyer #endif
3483053f5ecSenami 				memcpy(buf, CDATA(curr) +
349c27806c8Senami 				    ((blkno - curr->cd_blkstart) <<
350c27806c8Senami 				    dev_bshift),
351491d912fSbouyer 			   	    toCopy);
352491d912fSbouyer 
353491d912fSbouyer 				buf 	+= toCopy;
354491d912fSbouyer 				size 	-= toCopy;
355799974edSenami 				blkno 	+= howmany(toCopy, dev_bsize);
356799974edSenami 				numBlocks -= howmany(toCopy, dev_bsize);
357491d912fSbouyer 
358c089bab6Shannken 				curr->cd_time = cheader->cd_count++;
359491d912fSbouyer 
360491d912fSbouyer 				/*
361491d912fSbouyer 				 * If all data of a cache block have been
362491d912fSbouyer 				 * read, chances are good no more reads
363491d912fSbouyer 				 * will occur, so expire the cache immediately
364491d912fSbouyer 				 */
365491d912fSbouyer 
366c089bab6Shannken 				curr->cd_blocksRead +=
367799974edSenami 				    howmany(toCopy, dev_bsize);
368c089bab6Shannken 				if (curr->cd_blocksRead >= nblksread)
369c089bab6Shannken 					curr->cd_time = 0;
370491d912fSbouyer 
371491d912fSbouyer 				goto retry;
372491d912fSbouyer 			}
373491d912fSbouyer 		}
374491d912fSbouyer 
375491d912fSbouyer 		/* No more to do? */
376491d912fSbouyer 		if (size == 0)
377491d912fSbouyer 			break;
378491d912fSbouyer 
379491d912fSbouyer 		/*
380491d912fSbouyer 		 * This does actually not happen if fs blocks are not greater
381491d912fSbouyer 		 * than nblksread.
382491d912fSbouyer 		 */
383e9164a95Slukem 		if (numBlocks > nblksread || blkno >= ufsib->ufs_dsize) {
384491d912fSbouyer 			rawread(oblkno, obuf, osize);
385491d912fSbouyer 			break;
386491d912fSbouyer 		} else {
387491d912fSbouyer 			ssize_t	rsize;
388491d912fSbouyer 			daddr_t	blockBlkNo;
389491d912fSbouyer 
390491d912fSbouyer 			blockBlkNo = (blkno / nblksread) * nblksread;
391491d912fSbouyer 			idx = findlru();
39299feaf5bSlukem 			rsize = MIN(nblksread,
3933053f5ecSenami 			    ufsib->ufs_dsize - blockBlkNo) << dev_bshift;
394e8247b40Sperseant 
395491d912fSbouyer #ifdef DIAGNOSTICS
396c089bab6Shannken 			if (cdesc[idx].cd_owner)
397491d912fSbouyer 				fprintf(stderr, "Owner is set (%d, me=%d), can"
398c089bab6Shannken 				    "not happen(2).\n", cdesc[idx].cd_owner,
399491d912fSbouyer 				    getpid());
400c089bab6Shannken 			cdesc[idx].cd_owner = getpid();
401491d912fSbouyer #endif
402c089bab6Shannken 			cdesc[idx].cd_time = cheader->cd_count++;
403c089bab6Shannken 			cdesc[idx].cd_blkstart = blockBlkNo;
4043053f5ecSenami 			cdesc[idx].cd_blkend = 0;
405c089bab6Shannken 			cdesc[idx].cd_blocksRead = 0;
406491d912fSbouyer 
407799974edSenami 			if (lseek(diskfd, ((off_t) blockBlkNo << dev_bshift),
4088d849f48Senami 			    SEEK_SET) == -1) {
409491d912fSbouyer 				msg("readBlocks: lseek fails: %s\n",
410491d912fSbouyer 				    strerror(errno));
411491d912fSbouyer 				rsize = -1;
412491d912fSbouyer 			} else {
4133053f5ecSenami 				rsize = read(diskfd,
4143053f5ecSenami 				    CDATA(&cdesc[idx]), rsize);
415491d912fSbouyer 				if (rsize < 0) {
416491d912fSbouyer 					msg("readBlocks: read fails: %s\n",
417491d912fSbouyer 					    strerror(errno));
418491d912fSbouyer 				}
419491d912fSbouyer 			}
420491d912fSbouyer 
421491d912fSbouyer 			/* On errors, panic, punt, try to read without
422491d912fSbouyer 			 * cache and let raw read routine do the rest.
423491d912fSbouyer 			 */
424491d912fSbouyer 
425491d912fSbouyer 			if (rsize <= 0) {
426491d912fSbouyer 				rawread(oblkno, obuf, osize);
427491d912fSbouyer #ifdef DIAGNOSTICS
428c089bab6Shannken 				if (cdesc[idx].cd_owner != getpid())
429491d912fSbouyer 					fprintf(stderr, "Owner changed from "
430491d912fSbouyer 					    "%d to %d, can't happen\n",
431c089bab6Shannken 					    getpid(), cdesc[idx].cd_owner);
432c089bab6Shannken 				cdesc[idx].cd_owner = 0;
433491d912fSbouyer #endif
434491d912fSbouyer 				break;
435491d912fSbouyer 			}
436491d912fSbouyer 
437491d912fSbouyer 			/* On short read, just note the fact and go on */
438c089bab6Shannken 			cdesc[idx].cd_blkend = blockBlkNo + rsize / dev_bsize;
439491d912fSbouyer 
440491d912fSbouyer #ifdef STATS
441491d912fSbouyer 			nphysread++;
442491d912fSbouyer 			physreadsize += rsize;
443491d912fSbouyer #endif
444491d912fSbouyer #ifdef DIAGNOSTICS
445c089bab6Shannken 			if (cdesc[idx].cd_owner != getpid())
446491d912fSbouyer 				fprintf(stderr, "Owner changed from "
447491d912fSbouyer 				    "%d to %d, can't happen\n",
448c089bab6Shannken 				    getpid(), cdesc[idx].cd_owner);
449c089bab6Shannken 			cdesc[idx].cd_owner = 0;
450491d912fSbouyer #endif
451491d912fSbouyer 			/*
452491d912fSbouyer 			 * We swapped some of data in, let the loop fetch
453491d912fSbouyer 			 * them from cache
454491d912fSbouyer 			 */
455491d912fSbouyer 		}
456491d912fSbouyer 	}
457491d912fSbouyer 
458491d912fSbouyer 	if (flock(diskfd, LOCK_UN))
459491d912fSbouyer 		msg("flock(LOCK_UN) failed: %s\n",
460491d912fSbouyer 		    strerror(errno));
461491d912fSbouyer }
462491d912fSbouyer 
463491d912fSbouyer void
printcachestats(void)46499feaf5bSlukem printcachestats(void)
465491d912fSbouyer {
466799974edSenami 
467491d912fSbouyer #ifdef STATS
468491d912fSbouyer 	fprintf(stderr, "Pid %d: %d reads (%u bytes) "
469491d912fSbouyer 	    "%d physical reads (%u bytes) %d%% hits, %d%% overhead\n",
470491d912fSbouyer 	    getpid(), nreads, (u_int) readsize, nphysread,
471491d912fSbouyer 	    (u_int) physreadsize, (nreads - nphysread) * 100 / nreads,
472491d912fSbouyer 	    (int) (((physreadsize - readsize) * 100) / readsize));
473491d912fSbouyer #endif
474491d912fSbouyer }
475