xref: /titanic_41/usr/src/cmd/fs.d/cachefs/common/stats_log.c (revision cde2885fdf538266ee2a3b08dee2d5075ce8fa2b)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * Routines for cachefs logging.
31  */
32 
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <stddef.h>
36 #include <sys/types.h>
37 #include <sys/param.h>
38 #include <errno.h>
39 #include <sys/stat.h>
40 #include <fcntl.h>
41 #include <unistd.h>
42 #include <libintl.h>
43 #include <time.h>
44 #include <string.h>
45 #include <sys/fs/cachefs_fs.h>
46 #include <sys/fs/cachefs_log.h>
47 #include <malloc.h>
48 #include <limits.h>
49 #include "stats.h"
50 #include <assert.h>
51 
52 /* forward declarations of statics */
53 static kstat_t *stats_log_kstat_read(stats_cookie_t *);
54 static char *stats_log_fmtfid(cfs_fid_t *);
55 static bool_t stats_xdr_loghead(XDR *, struct cachefs_log_logfile_header *);
56 static int stats_log_fi_comp(const void *a, const void *b);
57 
58 int
59 stats_log_kernel_setname(stats_cookie_t *st, char *path)
60 {
61 	int error = 0;
62 	kstat_t *log;
63 	cachefs_log_control_t *lc;
64 	int exists = 0;
65 
66 	assert(stats_good(st));
67 
68 	if ((log = stats_log_kstat_read(st)) == NULL) {
69 		error = stats_errno(st);
70 		goto out;
71 	}
72 
73 	lc = (cachefs_log_control_t *)log->ks_data;
74 
75 	/*
76 	 * the stats_ API allows a NULL or an empty path to turn off
77 	 * logging, but the kstat interface has the string buffered,
78 	 * so we need to make an empty string.
79 	 */
80 
81 	if (path == NULL)
82 		path = "";
83 	if ((lc->lc_path[0] == 0) && (path[0] == 0))
84 		goto out;
85 
86 	(void) strlcpy(lc->lc_path, path, sizeof (lc->lc_path));
87 
88 	if (path[0] != '\0') {
89 		struct stat64 s;
90 		int f;
91 
92 		exists = access(path, F_OK);
93 		/* logfile will be <2GB */
94 		f = open(path, O_WRONLY | O_CREAT, 0666);
95 		if (f < 0) {
96 			stats_perror(st, error = SE_FILE,
97 			    gettext("Cannot open/create logfile: %s"),
98 			    strerror(errno));
99 			goto out;
100 		}
101 
102 		if (fstat64(f, &s) < 0) {
103 			stats_perror(st, error = SE_FILE,
104 			    gettext("Cannot stat logfile: %s"),
105 			    strerror(errno));
106 			(void) close(f);
107 			goto out;
108 		}
109 
110 		/*
111 		 * the kernel will accept an empty file as a logfile.  we must
112 		 * make sure that we created this empty file, i.e. that it's
113 		 * not an already existing file that happened to be empty.
114 		 *
115 		 * if we hand the kernel a nonempty file, it will check the
116 		 * magic number.  thus, if they hand it something like
117 		 * /etc/passwd, the kernel should reject it.  we just have to
118 		 * catch the cases of empty files we don't want to be
119 		 * logfiles.
120 		 */
121 
122 		if ((exists == 0) && (s.st_size == 0LL)) {
123 			stats_perror(st, error = SE_INVAL,
124 			    gettext(
125 			    "Cannot use existing empty file as a logfile"));
126 			(void) close(f);
127 			goto out;
128 		}
129 
130 		(void) close(f);
131 	}
132 
133 	if (kstat_write(st->st_kstat_cookie, log, NULL) < 0) {
134 		stats_perror(st, error = SE_KERNEL,
135 		    gettext("Cannot set logfile path for this filesystem"));
136 		goto out;
137 	}
138 
139 out:
140 	if ((error != 0) && (path[0] != '\0') && (exists != 0))
141 		(void) unlink(path);
142 
143 	return (error);
144 }
145 
146 int
147 stats_log_which(stats_cookie_t *st, int which, int onoff)
148 {
149 	int error = 0;
150 	kstat_t *log;
151 	cachefs_log_control_t *lc;
152 
153 	assert(stats_good(st));
154 
155 	if ((log = stats_log_kstat_read(st)) == NULL) {
156 		error = stats_errno(st);
157 		goto out;
158 	}
159 
160 	lc = (cachefs_log_control_t *)log->ks_data;
161 
162 	if (onoff)
163 		CACHEFS_LOG_SET(lc, which);
164 	else
165 		CACHEFS_LOG_CLEAR(lc, which);
166 
167 	if (kstat_write(st->st_kstat_cookie, log, NULL) < 0) {
168 		stats_perror(st, error = SE_KERNEL,
169 		    gettext("Cannot set log bitmap for this filesystem"));
170 		goto out;
171 	}
172 
173 out:
174 	return (error);
175 }
176 
177 char *
178 stats_log_kernel_getname(stats_cookie_t *st)
179 {
180 	char *rc = NULL;
181 	kstat_t *log;
182 	cachefs_log_control_t *lc;
183 
184 	assert(stats_good(st));
185 
186 	if ((log = stats_log_kstat_read(st)) == NULL)
187 		goto out;
188 
189 	lc = (cachefs_log_control_t *)log->ks_data;
190 
191 	rc = lc->lc_path; /* rc[0] will be '\0' if we're not logging */
192 
193 out:
194 	return (rc);
195 }
196 
197 static kstat_t *
198 stats_log_kstat_read(stats_cookie_t *st)
199 {
200 	kstat_t *rc;
201 
202 	assert(stats_good(st));
203 	assert(st->st_flags & ST_BOUND);
204 
205 	if ((rc = kstat_lookup(st->st_kstat_cookie,
206 	    "cachefs", st->st_fsid, "log")) == NULL) {
207 		/*
208 		 * XXX if st was created for a particular cachedir, we
209 		 * should scan for another st->st_fsid that'll get us
210 		 * the same cache.
211 		 */
212 		stats_perror(st, SE_KERNEL,
213 		    gettext("Cannot lookup kstats for this filesystem"));
214 		goto out;
215 	}
216 	if (kstat_read(st->st_kstat_cookie, rc, NULL) < 0) {
217 		stats_perror(st, SE_KERNEL,
218 		    gettext("Cannot read kstats for this filesystem"));
219 		rc = NULL;
220 		goto out;
221 	}
222 
223 out:
224 	return (rc);
225 }
226 
227 int
228 stats_log_logfile_open(stats_cookie_t *st, char *fname)
229 {
230 	int rc = 0;
231 
232 	assert(stats_good(st));
233 
234 	if ((fname == NULL) || (fname[0] == '\0')) {
235 		kstat_t *log;
236 		cachefs_log_control_t *lc;
237 
238 		if ((log = stats_log_kstat_read(st)) == NULL) {
239 			rc = -1;
240 			goto out;
241 		}
242 		lc = (cachefs_log_control_t *)log->ks_data;
243 		fname = lc->lc_path;
244 	}
245 
246 	/* logfile will be <2GB */
247 	if ((st->st_logstream = fopen(fname, "r")) == NULL) {
248 		stats_perror(st, SE_FILE,
249 		    gettext("Cannot open logfile %s"), fname);
250 		rc = -1;
251 		goto out;
252 	}
253 	xdrstdio_create(&st->st_logxdr, st->st_logstream, XDR_DECODE);
254 
255 	if (! stats_xdr_loghead(&st->st_logxdr, &st->st_loghead)) {
256 		stats_perror(st, SE_CORRUPT,
257 		    gettext("Cannot read header from logfile %s"), fname);
258 		rc = -1;
259 		goto out;
260 	}
261 	if (st->st_loghead.lh_magic != CACHEFS_LOG_MAGIC) {
262 		stats_perror(st, SE_CORRUPT,
263 		    gettext("%s: Invalid log file header"), fname);
264 		rc = -1;
265 		goto out;
266 	}
267 	if (st->st_loghead.lh_revision > CACHEFS_LOG_FILE_REV) {
268 		stats_perror(st, SE_CORRUPT,
269 		    gettext("%s: Revision too high"), fname);
270 		rc = -1;
271 		goto out;
272 	}
273 
274 	st->st_flags |= ST_LFOPEN;
275 
276 out:
277 	if (rc != 0) {
278 		if (st->st_logstream != NULL) {
279 			(void) fclose(st->st_logstream);
280 			st->st_logstream = NULL;
281 		}
282 		if (st->st_logxdr.x_ops != NULL) {
283 			xdr_destroy(&st->st_logxdr);
284 			st->st_logxdr.x_ops = NULL;
285 		}
286 	}
287 	return (rc);
288 }
289 
290 static bool_t
291 stats_xdr_loghead(XDR *xdrs, struct cachefs_log_logfile_header *lh)
292 {
293 	if ((! xdr_u_int(xdrs, &lh->lh_magic)) ||
294 	    (! xdr_u_int(xdrs, &lh->lh_revision)) ||
295 	    (! xdr_int(xdrs, &lh->lh_errno)) ||
296 	    (! xdr_u_int(xdrs, &lh->lh_blocks)) ||
297 	    (! xdr_u_int(xdrs, &lh->lh_files)) ||
298 	    (! xdr_u_int(xdrs, &lh->lh_maxbsize)) ||
299 	    (! xdr_u_int(xdrs, &lh->lh_pagesize)))
300 		return (FALSE);
301 
302 	return (TRUE);
303 }
304 
305 void *
306 stats_log_logfile_read(stats_cookie_t *st, int *type)
307 {
308 	void *rc = NULL;
309 	size_t size;
310 	int ttype;
311 	XDR *xdrs;
312 	char *string1, *string2;
313 
314 	assert(stats_good(st));
315 
316 	xdrs = &st->st_logxdr;
317 
318 	if (! (st->st_flags & ST_LFOPEN)) {
319 		stats_perror(st, SE_INVAL,
320 		    gettext("Logfile was not open"));
321 		goto out;
322 	}
323 
324 	if (type == NULL)
325 		type = &ttype;
326 
327 	if (! xdr_int(xdrs, type))
328 		goto out;
329 
330 	switch (*type) {
331 		struct cachefs_log_mount_record mount, *mountp;
332 		struct cachefs_log_umount_record umount;
333 		struct cachefs_log_getpage_record getpage;
334 		struct cachefs_log_readdir_record readdir;
335 		struct cachefs_log_readlink_record readlink;
336 		struct cachefs_log_remove_record remove;
337 		struct cachefs_log_rmdir_record rmdir;
338 		struct cachefs_log_truncate_record truncate;
339 		struct cachefs_log_putpage_record putpage;
340 		struct cachefs_log_create_record create;
341 		struct cachefs_log_mkdir_record mkdir;
342 		struct cachefs_log_rename_record rename;
343 		struct cachefs_log_symlink_record symlink;
344 		struct cachefs_log_populate_record populate;
345 		struct cachefs_log_csymlink_record csymlink;
346 		struct cachefs_log_filldir_record filldir;
347 		struct cachefs_log_mdcreate_record mdcreate;
348 		struct cachefs_log_gpfront_record gpfront;
349 		struct cachefs_log_rfdir_record rfdir;
350 		struct cachefs_log_ualloc_record ualloc;
351 		struct cachefs_log_calloc_record challoc;
352 		struct cachefs_log_nocache_record nocache;
353 
354 	case CACHEFS_LOG_MOUNT:
355 		if ((! xdr_int(xdrs, &mount.error)) ||
356 		    (! xdr_int(xdrs, (int *)&mount.time)) ||
357 		    (! xdr_opaque(xdrs, (caddr_t)&mount.vfsp,
358 		    sizeof (mount.vfsp))) ||
359 		    (! xdr_u_int(xdrs, &mount.flags)) ||
360 		    (! xdr_u_int(xdrs, &mount.popsize)) ||
361 		    (! xdr_u_int(xdrs, &mount.fgsize)) ||
362 		    (! xdr_u_short(xdrs, &mount.pathlen)) ||
363 		    (! xdr_u_short(xdrs, &mount.cacheidlen))) {
364 			stats_perror(st, SE_CORRUPT,
365 			    gettext("Truncated mount record"));
366 			goto out;
367 		}
368 		mount.type = *type;
369 		size = sizeof (mount) + mount.pathlen + mount.cacheidlen -
370 			CLPAD(cachefs_log_mount_record, path);
371 		if ((rc = mountp =
372 		    (struct cachefs_log_mount_record *)
373 		    calloc(1, size)) == NULL) {
374 			stats_perror(st, SE_NOMEM,
375 			    gettext("Cannot malloc record"));
376 			goto out;
377 		}
378 		memcpy(rc, &mount, size);
379 		string1 = mountp->path;
380 		string2 = mountp->path + mount.pathlen + 1;
381 		(void) xdr_wrapstring(xdrs, &string1);
382 		(void) xdr_wrapstring(xdrs, &string2);
383 		break;
384 
385 	case CACHEFS_LOG_UMOUNT:
386 		if ((! xdr_int(xdrs, &umount.error)) ||
387 		    (! xdr_int(xdrs, (int *)&umount.time)) ||
388 		    (! xdr_opaque(xdrs, (caddr_t)&umount.vfsp,
389 		    sizeof (umount.vfsp)))) {
390 			stats_perror(st, SE_CORRUPT,
391 			    gettext("Truncated umount record"));
392 			goto out;
393 		}
394 		umount.type = *type;
395 		size = sizeof (umount);
396 		if ((rc = (caddr_t)calloc(1, size)) == NULL) {
397 			stats_perror(st, SE_NOMEM,
398 			    gettext("Cannot malloc record"));
399 			goto out;
400 		}
401 		memcpy(rc, &umount, size);
402 		break;
403 
404 	case CACHEFS_LOG_GETPAGE:
405 		if ((! xdr_int(xdrs, &getpage.error)) ||
406 		    (! xdr_int(xdrs, (int *)&getpage.time)) ||
407 		    (! xdr_opaque(xdrs, (caddr_t)&getpage.vfsp,
408 		    sizeof (getpage.vfsp))) ||
409 		    (! xdr_opaque(xdrs, (caddr_t)&getpage.fid,
410 		    sizeof (getpage.fid))) ||
411 		    (! xdr_u_longlong_t(xdrs,
412 		    (u_longlong_t *)&getpage.fileno)) ||
413 		    (! xdr_int(xdrs, (int *)&getpage.uid)) ||
414 		    (! xdr_u_longlong_t(xdrs,
415 		    (u_longlong_t *)&getpage.offset)) ||
416 		    (! xdr_u_int(xdrs, &getpage.len))) {
417 			stats_perror(st, SE_CORRUPT,
418 			    gettext("Truncated getpage record"));
419 			goto out;
420 		}
421 		getpage.type = *type;
422 		size = sizeof (getpage);
423 		if ((rc = (caddr_t)calloc(1, size)) == NULL) {
424 			stats_perror(st, SE_NOMEM,
425 			    gettext("Cannot malloc record"));
426 			goto out;
427 		}
428 		memcpy(rc, &getpage, size);
429 		break;
430 
431 	case CACHEFS_LOG_READDIR:
432 		if ((! xdr_int(xdrs, &readdir.error)) ||
433 		    (! xdr_int(xdrs, (int *)&readdir.time)) ||
434 		    (! xdr_opaque(xdrs, (caddr_t)&readdir.vfsp,
435 		    sizeof (readdir.vfsp))) ||
436 		    (! xdr_opaque(xdrs, (caddr_t)&readdir.fid,
437 		    sizeof (readdir.fid))) ||
438 		    (! xdr_u_longlong_t(xdrs,
439 		    (u_longlong_t *)&readdir.fileno)) ||
440 		    (! xdr_int(xdrs, (int *)&readdir.uid)) ||
441 		    (! xdr_u_longlong_t(xdrs,
442 		    (u_longlong_t *)&readdir.offset)) ||
443 		    (! xdr_int(xdrs, &readdir.eof))) {
444 			stats_perror(st, SE_CORRUPT,
445 			    gettext("Truncated readdir record"));
446 			goto out;
447 		}
448 		readdir.type = *type;
449 		size = sizeof (readdir);
450 		if ((rc = (caddr_t)calloc(1, size)) == NULL) {
451 			stats_perror(st, SE_NOMEM,
452 			    gettext("Cannot malloc record"));
453 			goto out;
454 		}
455 		memcpy(rc, &readdir, size);
456 		break;
457 
458 	case CACHEFS_LOG_READLINK:
459 		if ((! xdr_int(xdrs, &readlink.error)) ||
460 		    (! xdr_int(xdrs, (int *)&readlink.time)) ||
461 		    (! xdr_opaque(xdrs, (caddr_t)&readlink.vfsp,
462 		    sizeof (readlink.vfsp))) ||
463 		    (! xdr_opaque(xdrs, (caddr_t)&readlink.fid,
464 		    sizeof (readlink.fid))) ||
465 		    (! xdr_u_longlong_t(xdrs,
466 		    (u_longlong_t *)&readlink.fileno)) ||
467 		    (! xdr_int(xdrs, (int *)&readlink.uid)) ||
468 		    (! xdr_u_int(xdrs,
469 		    &readlink.length))) {
470 			stats_perror(st, SE_CORRUPT,
471 			    gettext("Truncated readlink record"));
472 			goto out;
473 		}
474 		readlink.type = *type;
475 		size = sizeof (readlink);
476 		if ((rc = (caddr_t)calloc(1, size)) == NULL) {
477 			stats_perror(st, SE_NOMEM,
478 			    gettext("Cannot malloc record"));
479 			goto out;
480 		}
481 		memcpy(rc, &readlink, size);
482 		break;
483 
484 	case CACHEFS_LOG_REMOVE:
485 		if ((! xdr_int(xdrs, &remove.error)) ||
486 		    (! xdr_int(xdrs, (int *)&remove.time)) ||
487 		    (! xdr_opaque(xdrs, (caddr_t)&remove.vfsp,
488 		    sizeof (remove.vfsp))) ||
489 		    (! xdr_opaque(xdrs, (caddr_t)&remove.fid,
490 		    sizeof (remove.fid))) ||
491 		    (! xdr_u_longlong_t(xdrs,
492 		    (u_longlong_t *)&remove.fileno)) ||
493 		    (! xdr_int(xdrs, (int *)&remove.uid))) {
494 			stats_perror(st, SE_CORRUPT,
495 			    gettext("Truncated remove record"));
496 			goto out;
497 		}
498 		remove.type = *type;
499 		size = sizeof (remove);
500 		if ((rc = (caddr_t)calloc(1, size)) == NULL) {
501 			stats_perror(st, SE_NOMEM,
502 			    gettext("Cannot malloc record"));
503 			goto out;
504 		}
505 		memcpy(rc, &remove, size);
506 		break;
507 
508 	case CACHEFS_LOG_RMDIR:
509 		if ((! xdr_int(xdrs, &rmdir.error)) ||
510 		    (! xdr_int(xdrs, (int *)&rmdir.time)) ||
511 		    (! xdr_opaque(xdrs, (caddr_t)&rmdir.vfsp,
512 		    sizeof (rmdir.vfsp))) ||
513 		    (! xdr_opaque(xdrs, (caddr_t)&rmdir.fid,
514 		    sizeof (rmdir.fid))) ||
515 		    (! xdr_u_longlong_t(xdrs, (u_longlong_t *)&rmdir.fileno)) ||
516 		    (! xdr_int(xdrs, (int *)&rmdir.uid))) {
517 			stats_perror(st, SE_CORRUPT,
518 			    gettext("Truncated rmdir record"));
519 			goto out;
520 		}
521 		rmdir.type = *type;
522 		size = sizeof (rmdir);
523 		if ((rc = (caddr_t)calloc(1, size)) == NULL) {
524 			stats_perror(st, SE_NOMEM,
525 			    gettext("Cannot malloc record"));
526 			goto out;
527 		}
528 		memcpy(rc, &rmdir, size);
529 		break;
530 
531 	case CACHEFS_LOG_TRUNCATE:
532 		if ((! xdr_int(xdrs, &truncate.error)) ||
533 		    (! xdr_int(xdrs, (int *)&truncate.time)) ||
534 		    (! xdr_opaque(xdrs, (caddr_t)&truncate.vfsp,
535 		    sizeof (truncate.vfsp))) ||
536 		    (! xdr_opaque(xdrs, (caddr_t)&truncate.fid,
537 		    sizeof (truncate.fid))) ||
538 		    (! xdr_u_longlong_t(xdrs,
539 		    (u_longlong_t *)&truncate.fileno)) ||
540 		    (! xdr_int(xdrs, (int *)&truncate.uid)) ||
541 		    (! xdr_u_longlong_t(xdrs,
542 		    (u_longlong_t *)&truncate.size))) {
543 			stats_perror(st, SE_CORRUPT,
544 			    gettext("Truncated truncate record"));
545 			goto out;
546 		}
547 		truncate.type = *type;
548 		size = sizeof (truncate);
549 		if ((rc = (caddr_t)calloc(1, size)) == NULL) {
550 			stats_perror(st, SE_NOMEM,
551 			    gettext("Cannot malloc record"));
552 			goto out;
553 		}
554 		memcpy(rc, &truncate, size);
555 		break;
556 
557 	case CACHEFS_LOG_PUTPAGE:
558 		if ((! xdr_int(xdrs, &putpage.error)) ||
559 		    (! xdr_int(xdrs, (int *)&putpage.time)) ||
560 		    (! xdr_opaque(xdrs, (caddr_t)&putpage.vfsp,
561 		    sizeof (putpage.vfsp))) ||
562 		    (! xdr_opaque(xdrs, (caddr_t)&putpage.fid,
563 		    sizeof (putpage.fid))) ||
564 		    (! xdr_u_longlong_t(xdrs,
565 		    (u_longlong_t *)&putpage.fileno)) ||
566 		    (! xdr_int(xdrs, (int *)&putpage.uid)) ||
567 		    (! xdr_u_longlong_t(xdrs,
568 		    (u_longlong_t *)&putpage.offset)) ||
569 		    (! xdr_u_int(xdrs, &putpage.len))) {
570 			stats_perror(st, SE_CORRUPT,
571 			    gettext("Truncated putpage record"));
572 			goto out;
573 		}
574 		putpage.type = *type;
575 		size = sizeof (putpage);
576 		if ((rc = (caddr_t)calloc(1, size)) == NULL) {
577 			stats_perror(st, SE_NOMEM,
578 			    gettext("Cannot malloc record"));
579 			goto out;
580 		}
581 		memcpy(rc, &putpage, size);
582 		break;
583 
584 	case CACHEFS_LOG_CREATE:
585 		if ((! xdr_int(xdrs, &create.error)) ||
586 		    (! xdr_int(xdrs, (int *)&create.time)) ||
587 		    (! xdr_opaque(xdrs, (caddr_t)&create.vfsp,
588 		    sizeof (create.vfsp))) ||
589 		    (! xdr_opaque(xdrs, (caddr_t)&create.fid,
590 		    sizeof (create.fid))) ||
591 		    (! xdr_u_longlong_t(xdrs,
592 		    (u_longlong_t *)&create.fileno)) ||
593 		    (! xdr_int(xdrs, (int *)&create.uid))) {
594 			stats_perror(st, SE_CORRUPT,
595 			    gettext("Truncated create record"));
596 			goto out;
597 		}
598 		create.type = *type;
599 		size = sizeof (create);
600 		if ((rc = (struct cachefs_log_create_record *)
601 		    calloc(1, size)) == NULL) {
602 			stats_perror(st, SE_NOMEM,
603 			    gettext("Cannot malloc record"));
604 			goto out;
605 		}
606 		memcpy(rc, &create, size);
607 		break;
608 
609 	case CACHEFS_LOG_MKDIR:
610 		if ((! xdr_int(xdrs, &mkdir.error)) ||
611 		    (! xdr_int(xdrs, (int *)&mkdir.time)) ||
612 		    (! xdr_opaque(xdrs, (caddr_t)&mkdir.vfsp,
613 		    sizeof (mkdir.vfsp))) ||
614 		    (! xdr_opaque(xdrs, (caddr_t)&mkdir.fid,
615 		    sizeof (mkdir.fid))) ||
616 		    (! xdr_u_longlong_t(xdrs, (u_longlong_t *)&mkdir.fileno)) ||
617 		    (! xdr_int(xdrs, (int *)&mkdir.uid))) {
618 			stats_perror(st, SE_CORRUPT,
619 			    gettext("Truncated mkdir record"));
620 			goto out;
621 		}
622 		mkdir.type = *type;
623 		size = sizeof (mkdir);
624 		if ((rc = (struct cachefs_log_mkdir_record *)
625 		    calloc(1, size)) == NULL) {
626 			stats_perror(st, SE_NOMEM,
627 			    gettext("Cannot malloc record"));
628 			goto out;
629 		}
630 		memcpy(rc, &mkdir, size);
631 		break;
632 
633 	case CACHEFS_LOG_RENAME:
634 		if ((! xdr_int(xdrs, &rename.error)) ||
635 		    (! xdr_int(xdrs, (int *)&rename.time)) ||
636 		    (! xdr_opaque(xdrs, (caddr_t)&rename.vfsp,
637 		    sizeof (rename.vfsp))) ||
638 		    (! xdr_opaque(xdrs, (caddr_t)&rename.gone,
639 		    sizeof (rename.gone))) ||
640 		    (! xdr_int(xdrs, &rename.removed)) ||
641 		    (! xdr_int(xdrs, (int *)&rename.uid))) {
642 			stats_perror(st, SE_CORRUPT,
643 			    gettext("Truncated rename record"));
644 			goto out;
645 		}
646 		rename.type = *type;
647 		size = sizeof (rename);
648 		if ((rc = (struct cachefs_log_rename_record *)
649 		    calloc(1, size)) == NULL) {
650 			stats_perror(st, SE_NOMEM,
651 			    gettext("Cannot malloc record"));
652 			goto out;
653 		}
654 		memcpy(rc, &rename, size);
655 		break;
656 
657 	case CACHEFS_LOG_SYMLINK:
658 		if ((! xdr_int(xdrs, &symlink.error)) ||
659 		    (! xdr_int(xdrs, (int *)&symlink.time)) ||
660 		    (! xdr_opaque(xdrs, (caddr_t)&symlink.vfsp,
661 		    sizeof (symlink.vfsp))) ||
662 		    (! xdr_opaque(xdrs, (caddr_t)&symlink.fid,
663 		    sizeof (symlink.fid))) ||
664 		    (! xdr_u_longlong_t(xdrs,
665 		    (u_longlong_t *)&symlink.fileno)) ||
666 		    (! xdr_int(xdrs, (int *)&symlink.uid)) ||
667 		    (! xdr_u_int(xdrs, &symlink.size))) {
668 			stats_perror(st, SE_CORRUPT,
669 			    gettext("Truncated symlink record"));
670 			goto out;
671 		}
672 		symlink.type = *type;
673 		size = sizeof (symlink);
674 		if ((rc = (struct cachefs_log_symlink_record *)
675 		    calloc(1, size)) == NULL) {
676 			stats_perror(st, SE_NOMEM,
677 			    gettext("Cannot malloc record"));
678 			goto out;
679 		}
680 		memcpy(rc, &symlink, size);
681 		break;
682 
683 	case CACHEFS_LOG_POPULATE:
684 		if ((! xdr_int(xdrs, &populate.error)) ||
685 		    (! xdr_int(xdrs, (int *)&populate.time)) ||
686 		    (! xdr_opaque(xdrs, (caddr_t)&populate.vfsp,
687 		    sizeof (populate.vfsp))) ||
688 		    (! xdr_opaque(xdrs, (caddr_t)&populate.fid,
689 		    sizeof (populate.fid))) ||
690 		    (! xdr_u_longlong_t(xdrs,
691 		    (u_longlong_t *)&populate.fileno)) ||
692 		    (! xdr_u_longlong_t(xdrs, (u_longlong_t *)&populate.off)) ||
693 		    (! xdr_u_int(xdrs, &populate.size))) {
694 			stats_perror(st, SE_CORRUPT,
695 			    gettext("Truncated populate record"));
696 			goto out;
697 		}
698 		populate.type = *type;
699 		if ((rc = (struct cachefs_log_populate_record *)
700 		    calloc(1, sizeof (populate))) == NULL) {
701 			stats_perror(st, SE_NOMEM,
702 			    gettext("Cannot malloc record"));
703 			goto out;
704 		}
705 		memcpy(rc, &populate, sizeof (populate));
706 		break;
707 
708 	case CACHEFS_LOG_CSYMLINK:
709 		if ((! xdr_int(xdrs, &csymlink.error)) ||
710 		    (! xdr_int(xdrs, (int *)&csymlink.time)) ||
711 		    (! xdr_opaque(xdrs, (caddr_t)&csymlink.vfsp,
712 		    sizeof (csymlink.vfsp))) ||
713 		    (! xdr_opaque(xdrs, (caddr_t)&csymlink.fid,
714 		    sizeof (csymlink.fid))) ||
715 		    (! xdr_u_longlong_t(xdrs,
716 		    (u_longlong_t *)&csymlink.fileno)) ||
717 		    (! xdr_int(xdrs, &csymlink.size))) {
718 			stats_perror(st, SE_CORRUPT,
719 			    gettext("Truncated csymlink record"));
720 			goto out;
721 		}
722 		csymlink.type = *type;
723 		if ((rc = (struct cachefs_log_csymlink_record *)
724 		    calloc(1, sizeof (csymlink))) == NULL) {
725 			stats_perror(st, SE_NOMEM,
726 			    gettext("Cannot malloc record"));
727 			goto out;
728 		}
729 		memcpy(rc, &csymlink, sizeof (csymlink));
730 		break;
731 
732 	case CACHEFS_LOG_FILLDIR:
733 		if ((! xdr_int(xdrs, &filldir.error)) ||
734 		    (! xdr_int(xdrs, (int *)&filldir.time)) ||
735 		    (! xdr_opaque(xdrs, (caddr_t)&filldir.vfsp,
736 		    sizeof (filldir.vfsp))) ||
737 		    (! xdr_opaque(xdrs, (caddr_t)&filldir.fid,
738 		    sizeof (filldir.fid))) ||
739 		    (! xdr_u_longlong_t(xdrs,
740 		    (u_longlong_t *)&filldir.fileno)) ||
741 		    (! xdr_int(xdrs, &filldir.size))) {
742 			stats_perror(st, SE_CORRUPT,
743 			    gettext("Truncated filldir record"));
744 			goto out;
745 		}
746 		filldir.type = *type;
747 		if ((rc = (struct cachefs_log_filldir_record *)
748 		    calloc(1, sizeof (filldir))) == NULL) {
749 			stats_perror(st, SE_NOMEM,
750 			    gettext("Cannot malloc record"));
751 			goto out;
752 		}
753 		memcpy(rc, &filldir, sizeof (filldir));
754 		break;
755 
756 	case CACHEFS_LOG_MDCREATE:
757 		if ((! xdr_int(xdrs, &mdcreate.error)) ||
758 		    (! xdr_int(xdrs, (int *)&mdcreate.time)) ||
759 		    (! xdr_opaque(xdrs, (caddr_t)&mdcreate.vfsp,
760 		    sizeof (mdcreate.vfsp))) ||
761 		    (! xdr_opaque(xdrs, (caddr_t)&mdcreate.fid,
762 		    sizeof (mdcreate.fid))) ||
763 		    (! xdr_u_longlong_t(xdrs,
764 		    (u_longlong_t *)&mdcreate.fileno)) ||
765 		    (! xdr_u_int(xdrs, &mdcreate.count))) {
766 			stats_perror(st, SE_CORRUPT,
767 			    gettext("Truncated mdcreate record"));
768 			goto out;
769 		}
770 		mdcreate.type = *type;
771 		if ((rc = (struct cachefs_log_mdcreate_record *)
772 		    calloc(1, sizeof (mdcreate))) == NULL) {
773 			stats_perror(st, SE_NOMEM,
774 			    gettext("Cannot malloc record"));
775 			goto out;
776 		}
777 		memcpy(rc, &mdcreate, sizeof (mdcreate));
778 		break;
779 
780 	case CACHEFS_LOG_GPFRONT:
781 		if ((! xdr_int(xdrs, &gpfront.error)) ||
782 		    (! xdr_int(xdrs, (int *)&gpfront.time)) ||
783 		    (! xdr_opaque(xdrs, (caddr_t)&gpfront.vfsp,
784 		    sizeof (gpfront.vfsp))) ||
785 		    (! xdr_opaque(xdrs, (caddr_t)&gpfront.fid,
786 		    sizeof (gpfront.fid))) ||
787 		    (! xdr_u_longlong_t(xdrs,
788 		    (u_longlong_t *)&gpfront.fileno)) ||
789 		    (! xdr_int(xdrs, (int *)&gpfront.uid)) ||
790 		    (! xdr_u_longlong_t(xdrs, (u_longlong_t *)&gpfront.off)) ||
791 		    (! xdr_u_int(xdrs, &gpfront.len))) {
792 			stats_perror(st, SE_CORRUPT,
793 			    gettext("Truncated gpfront record"));
794 			goto out;
795 		}
796 		gpfront.type = *type;
797 		if ((rc = (struct cachefs_log_gpfront_record *)
798 		    calloc(1, sizeof (gpfront))) == NULL) {
799 			stats_perror(st, SE_NOMEM,
800 			    gettext("Cannot malloc record"));
801 			goto out;
802 		}
803 		memcpy(rc, &gpfront, sizeof (gpfront));
804 		break;
805 
806 	case CACHEFS_LOG_RFDIR:
807 		if ((! xdr_int(xdrs, &rfdir.error)) ||
808 		    (! xdr_int(xdrs, (int *)&rfdir.time)) ||
809 		    (! xdr_opaque(xdrs, (caddr_t)&rfdir.vfsp,
810 		    sizeof (rfdir.vfsp))) ||
811 		    (! xdr_opaque(xdrs, (caddr_t)&rfdir.fid,
812 		    sizeof (rfdir.fid))) ||
813 		    (! xdr_u_longlong_t(xdrs, (u_longlong_t *)&rfdir.fileno)) ||
814 		    (! xdr_int(xdrs, (int *)&rfdir.uid))) {
815 			stats_perror(st, SE_CORRUPT,
816 			    gettext("Truncated rfdir record"));
817 			goto out;
818 		}
819 		rfdir.type = *type;
820 		if ((rc = (struct cachefs_log_rfdir_record *)
821 		    calloc(1, sizeof (rfdir))) == NULL) {
822 			stats_perror(st, SE_NOMEM,
823 			    gettext("Cannot malloc record"));
824 			goto out;
825 		}
826 		memcpy(rc, &rfdir, sizeof (rfdir));
827 		break;
828 
829 	case CACHEFS_LOG_UALLOC:
830 		if ((! xdr_int(xdrs, &ualloc.error)) ||
831 		    (! xdr_int(xdrs, (int *)&ualloc.time)) ||
832 		    (! xdr_opaque(xdrs, (caddr_t)&ualloc.vfsp,
833 		    sizeof (ualloc.vfsp))) ||
834 		    (! xdr_opaque(xdrs, (caddr_t)&ualloc.fid,
835 		    sizeof (ualloc.fid))) ||
836 		    (! xdr_u_longlong_t(xdrs,
837 		    (u_longlong_t *)&ualloc.fileno)) ||
838 		    (! xdr_u_longlong_t(xdrs, (u_longlong_t *)&ualloc.off)) ||
839 		    (! xdr_u_int(xdrs, &ualloc.len))) {
840 			stats_perror(st, SE_CORRUPT,
841 			    gettext("Truncated ualloc record"));
842 			goto out;
843 		}
844 		ualloc.type = *type;
845 		if ((rc = (struct cachefs_log_ualloc_record *)
846 		    calloc(1, sizeof (ualloc))) == NULL) {
847 			stats_perror(st, SE_NOMEM,
848 			    gettext("Cannot malloc record"));
849 			goto out;
850 		}
851 		memcpy(rc, &ualloc, sizeof (ualloc));
852 		break;
853 
854 	case CACHEFS_LOG_CALLOC:
855 		if ((! xdr_int(xdrs, &challoc.error)) ||
856 		    (! xdr_int(xdrs, (int *)&challoc.time)) ||
857 		    (! xdr_opaque(xdrs, (caddr_t)&challoc.vfsp,
858 		    sizeof (challoc.vfsp))) ||
859 		    (! xdr_opaque(xdrs, (caddr_t)&challoc.fid,
860 		    sizeof (challoc.fid))) ||
861 		    (! xdr_u_longlong_t(xdrs,
862 		    (u_longlong_t *)&challoc.fileno)) ||
863 		    (! xdr_u_longlong_t(xdrs, (u_longlong_t *)&challoc.off)) ||
864 		    (! xdr_u_int(xdrs, &challoc.len))) {
865 			stats_perror(st, SE_CORRUPT,
866 			    gettext("Truncated calloc record"));
867 			goto out;
868 		}
869 		challoc.type = *type;
870 		if ((rc = (struct cachefs_log_calloc_record *)
871 		    calloc(1, sizeof (challoc))) == NULL) {
872 			stats_perror(st, SE_NOMEM,
873 			    gettext("Cannot malloc record"));
874 			goto out;
875 		}
876 		memcpy(rc, &challoc, sizeof (challoc));
877 		break;
878 
879 	case CACHEFS_LOG_NOCACHE:
880 		if ((! xdr_int(xdrs, &nocache.error)) ||
881 		    (! xdr_int(xdrs, (int *)&nocache.time)) ||
882 		    (! xdr_opaque(xdrs, (caddr_t)&nocache.vfsp,
883 		    sizeof (nocache.vfsp))) ||
884 		    (! xdr_opaque(xdrs, (caddr_t)&nocache.fid,
885 		    sizeof (nocache.fid))) ||
886 		    (! xdr_u_longlong_t(xdrs,
887 		    (u_longlong_t *)&nocache.fileno))) {
888 			stats_perror(st, SE_CORRUPT,
889 			    gettext("Truncated nocache record"));
890 			goto out;
891 		}
892 		nocache.type = *type;
893 		if ((rc = (struct cachefs_log_nocache_record *)
894 		    calloc(1, sizeof (nocache))) == NULL) {
895 			stats_perror(st, SE_NOMEM,
896 			    gettext("Cannot malloc record"));
897 			goto out;
898 		}
899 		memcpy(rc, &nocache, sizeof (nocache));
900 		break;
901 
902 	default:
903 		stats_perror(st, SE_CORRUPT,
904 		    gettext("Corrupt logfile (position %x)"),
905 		    ftell(st->st_logstream));
906 		break;
907 	}
908 
909 out:
910 	return (rc);
911 }
912 
913 /*
914  * convert a logfile record (read by stats_log_logfile_read()) to
915  * ascii.  probably not for end-user consumption, but this should be
916  * the official way to do it.
917  */
918 
919 char *
920 stats_log_record_toascii(stats_cookie_t *st, void *recp)
921 {
922 	int rectype = *((int *)recp);
923 	int recerror = *((int *)recp + 1);
924 	time_t tt = *((time_t *)((int *)recp + 2));
925 	struct tm *tm = localtime(&tt);
926 	char buffy[BUFSIZ], *fidstr, *fidstr2, *fidstr3;
927 
928 	struct cachefs_log_mount_record *mountp;
929 	struct cachefs_log_umount_record *umountp;
930 	struct cachefs_log_getpage_record *getpagep;
931 	struct cachefs_log_readdir_record *readdirp;
932 	struct cachefs_log_readlink_record *readlinkp;
933 	struct cachefs_log_remove_record *removep;
934 	struct cachefs_log_rmdir_record *rmdirp;
935 	struct cachefs_log_truncate_record *truncatep;
936 	struct cachefs_log_putpage_record *putpagep;
937 	struct cachefs_log_create_record *createp;
938 	struct cachefs_log_mkdir_record *mkdirp;
939 	struct cachefs_log_rename_record *renamep;
940 	struct cachefs_log_symlink_record *symlinkp;
941 	struct cachefs_log_populate_record *populatep;
942 	struct cachefs_log_csymlink_record *csymlinkp;
943 	struct cachefs_log_filldir_record *filldirp;
944 	struct cachefs_log_mdcreate_record *mdcreatep;
945 	struct cachefs_log_gpfront_record *gpfrontp;
946 	struct cachefs_log_rfdir_record *rfdirp;
947 	struct cachefs_log_ualloc_record *uallocp;
948 	struct cachefs_log_calloc_record *callocp;
949 	struct cachefs_log_nocache_record *nocachep;
950 
951 	assert(stats_good(st));
952 
953 	(void) sprintf(st->st_asciirec, "%2d/%-2d %2d:%.2d %2d",
954 	    tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min,
955 	    recerror);
956 
957 	switch (rectype) {
958 	case CACHEFS_LOG_MOUNT:
959 		mountp = (struct cachefs_log_mount_record *)recp;
960 		(void) snprintf(buffy, sizeof (buffy),
961 		    " %-8s %llx %8x %d %d %s (%s)", "Mount", mountp->vfsp,
962 		    mountp->flags, mountp->popsize,
963 		    mountp->fgsize, mountp->path,
964 		    mountp->path + mountp->pathlen + 1);
965 		(void) strlcat(st->st_asciirec, buffy,
966 		    sizeof (st->st_asciirec));
967 		break;
968 
969 	case CACHEFS_LOG_UMOUNT:
970 		umountp = (struct cachefs_log_umount_record *)recp;
971 		(void) snprintf(buffy, sizeof (buffy), " %-8s %llx",
972 		    "Umount", umountp->vfsp);
973 		(void) strlcat(st->st_asciirec, buffy,
974 		    sizeof (st->st_asciirec));
975 		break;
976 
977 	case CACHEFS_LOG_GETPAGE:
978 		getpagep = (struct cachefs_log_getpage_record *)recp;
979 		(void) snprintf(buffy, sizeof (buffy),
980 		    " %-8s %llx %s %llu %ld %llu %u",
981 		    "Getpage",
982 		    getpagep->vfsp, fidstr = stats_log_fmtfid(&getpagep->fid),
983 		    getpagep->fileno,
984 		    getpagep->uid, getpagep->offset, getpagep->len);
985 		(void) strlcat(st->st_asciirec, buffy,
986 		    sizeof (st->st_asciirec));
987 		free(fidstr);
988 		break;
989 
990 	case CACHEFS_LOG_READDIR:
991 		readdirp = (struct cachefs_log_readdir_record *)recp;
992 		(void) snprintf(buffy, sizeof (buffy),
993 		    " %-8s %llx %s %llu %d %llx %d", "Readdir",
994 		    readdirp->vfsp, fidstr = stats_log_fmtfid(&readdirp->fid),
995 		    readdirp->fileno,
996 		    readdirp->uid, readdirp->offset, readdirp->eof);
997 		(void) strlcat(st->st_asciirec, buffy,
998 		    sizeof (st->st_asciirec));
999 		free(fidstr);
1000 		break;
1001 
1002 	case CACHEFS_LOG_READLINK:
1003 		readlinkp = (struct cachefs_log_readlink_record *)recp;
1004 		(void) snprintf(buffy, sizeof (buffy),
1005 		    " %-8s %llx %s %llu %d %u", "Readlink",
1006 		    readlinkp->vfsp,
1007 		    fidstr = stats_log_fmtfid(&readlinkp->fid),
1008 		    readlinkp->fileno,
1009 		    readlinkp->uid, readlinkp->length);
1010 		(void) strlcat(st->st_asciirec, buffy,
1011 		    sizeof (st->st_asciirec));
1012 		free(fidstr);
1013 		break;
1014 
1015 	case CACHEFS_LOG_REMOVE:
1016 		removep = (struct cachefs_log_remove_record *)recp;
1017 		(void) snprintf(buffy, sizeof (buffy),
1018 		    " %-8s %llx %s %llu %d", "Remove",
1019 		    removep->vfsp, fidstr = stats_log_fmtfid(&removep->fid),
1020 		    removep->fileno,
1021 		    removep->uid);
1022 		(void) strlcat(st->st_asciirec, buffy,
1023 		    sizeof (st->st_asciirec));
1024 		free(fidstr);
1025 		break;
1026 
1027 	case CACHEFS_LOG_RMDIR:
1028 		rmdirp = (struct cachefs_log_rmdir_record *)recp;
1029 		(void) snprintf(buffy, sizeof (buffy),
1030 		    " %-8s %llx %s %llu %d", "Rmdir",
1031 		    rmdirp->vfsp, fidstr = stats_log_fmtfid(&rmdirp->fid),
1032 		    rmdirp->fileno,
1033 		    rmdirp->uid);
1034 		(void) strlcat(st->st_asciirec, buffy,
1035 		    sizeof (st->st_asciirec));
1036 		free(fidstr);
1037 		break;
1038 
1039 	case CACHEFS_LOG_TRUNCATE:
1040 		truncatep = (struct cachefs_log_truncate_record *)recp;
1041 		(void) snprintf(buffy, sizeof (buffy),
1042 		    " %-8s %llx %s %llu %d %llu", "Truncate",
1043 		    truncatep->vfsp,
1044 		    fidstr = stats_log_fmtfid(&truncatep->fid),
1045 		    truncatep->fileno,
1046 		    truncatep->uid, truncatep->size);
1047 		(void) strlcat(st->st_asciirec, buffy,
1048 		    sizeof (st->st_asciirec));
1049 		free(fidstr);
1050 		break;
1051 
1052 	case CACHEFS_LOG_PUTPAGE:
1053 		putpagep = (struct cachefs_log_putpage_record *)recp;
1054 		(void) snprintf(buffy, sizeof (buffy),
1055 		    " %-8s %llx %s %llu %d %llu %u", "Putpage",
1056 		    putpagep->vfsp, fidstr = stats_log_fmtfid(&putpagep->fid),
1057 		    putpagep->fileno,
1058 		    putpagep->uid, putpagep->offset, putpagep->len);
1059 		(void) strlcat(st->st_asciirec, buffy,
1060 		    sizeof (st->st_asciirec));
1061 		free(fidstr);
1062 		break;
1063 
1064 	case CACHEFS_LOG_CREATE:
1065 		createp = (struct cachefs_log_create_record *)recp;
1066 		(void) snprintf(buffy, sizeof (buffy),
1067 		    " %-8s %llx %s %llu %d", "Create",
1068 		    createp->vfsp,
1069 		    fidstr = stats_log_fmtfid(&createp->fid),
1070 		    createp->fileno,
1071 		    createp->uid);
1072 		(void) strlcat(st->st_asciirec, buffy,
1073 		    sizeof (st->st_asciirec));
1074 		free(fidstr);
1075 		break;
1076 
1077 	case CACHEFS_LOG_MKDIR:
1078 		mkdirp = (struct cachefs_log_mkdir_record *)recp;
1079 		(void) snprintf(buffy, sizeof (buffy),
1080 		    " %-8s %llx %s %llu %d", "Mkdir",
1081 		    mkdirp->vfsp,
1082 		    fidstr = stats_log_fmtfid(&mkdirp->fid),
1083 		    mkdirp->fileno,
1084 		    mkdirp->uid);
1085 		(void) strlcat(st->st_asciirec, buffy,
1086 		    sizeof (st->st_asciirec));
1087 		free(fidstr);
1088 		break;
1089 
1090 	case CACHEFS_LOG_RENAME:
1091 		renamep = (struct cachefs_log_rename_record *)recp;
1092 		(void) snprintf(buffy, sizeof (buffy),
1093 		    " %-8s %llx %s %llu %d %d", "Rename",
1094 		    renamep->vfsp,
1095 		    fidstr = stats_log_fmtfid(&renamep->gone),
1096 		    renamep->fileno,
1097 		    renamep->removed, renamep->uid);
1098 		(void) strlcat(st->st_asciirec, buffy,
1099 		    sizeof (st->st_asciirec));
1100 		free(fidstr);
1101 		break;
1102 
1103 	case CACHEFS_LOG_SYMLINK:
1104 		symlinkp = (struct cachefs_log_symlink_record *)recp;
1105 		(void) snprintf(buffy, sizeof (buffy),
1106 		    " %-8s %llx %s %llu %d %u", "Symlink",
1107 		    symlinkp->vfsp,
1108 		    fidstr = stats_log_fmtfid(&symlinkp->fid),
1109 		    symlinkp->fileno,
1110 		    symlinkp->uid, symlinkp->size);
1111 		(void) strlcat(st->st_asciirec, buffy,
1112 		    sizeof (st->st_asciirec));
1113 		free(fidstr);
1114 		break;
1115 
1116 	case CACHEFS_LOG_POPULATE:
1117 		populatep = (struct cachefs_log_populate_record *)recp;
1118 		(void) snprintf(buffy, sizeof (buffy),
1119 		    " %-8s %llx %s %llu %llu %d", "Populate",
1120 		    populatep->vfsp,
1121 		    fidstr = stats_log_fmtfid(&populatep->fid),
1122 		    populatep->fileno,
1123 		    populatep->off, populatep->size);
1124 		(void) strlcat(st->st_asciirec, buffy,
1125 		    sizeof (st->st_asciirec));
1126 		free(fidstr);
1127 		break;
1128 
1129 	case CACHEFS_LOG_CSYMLINK:
1130 		csymlinkp = (struct cachefs_log_csymlink_record *)recp;
1131 		(void) snprintf(buffy, sizeof (buffy),
1132 		    " %-8s %llx %s %llu %d", "Csymlink",
1133 		    csymlinkp->vfsp,
1134 		    fidstr = stats_log_fmtfid(&csymlinkp->fid),
1135 		    csymlinkp->fileno,
1136 		    csymlinkp->size);
1137 		(void) strlcat(st->st_asciirec, buffy,
1138 		    sizeof (st->st_asciirec));
1139 		free(fidstr);
1140 		break;
1141 
1142 	case CACHEFS_LOG_FILLDIR:
1143 		filldirp = (struct cachefs_log_filldir_record *)recp;
1144 		(void) snprintf(buffy, sizeof (buffy),
1145 		    " %-8s %llx %s %llu %d", "Filldir",
1146 		    filldirp->vfsp,
1147 		    fidstr = stats_log_fmtfid(&filldirp->fid),
1148 		    filldirp->fileno,
1149 		    filldirp->size);
1150 		(void) strlcat(st->st_asciirec, buffy,
1151 		    sizeof (st->st_asciirec));
1152 		free(fidstr);
1153 		break;
1154 
1155 	case CACHEFS_LOG_MDCREATE:
1156 		mdcreatep = (struct cachefs_log_mdcreate_record *)recp;
1157 		(void) snprintf(buffy, sizeof (buffy),
1158 		    " %-8s %llx %s %llu %u", "Mdcreate",
1159 		    mdcreatep->vfsp,
1160 		    fidstr = stats_log_fmtfid(&mdcreatep->fid),
1161 		    mdcreatep->fileno, mdcreatep->count);
1162 		(void) strlcat(st->st_asciirec, buffy,
1163 		    sizeof (st->st_asciirec));
1164 		free(fidstr);
1165 		break;
1166 
1167 	case CACHEFS_LOG_GPFRONT:
1168 		gpfrontp = (struct cachefs_log_gpfront_record *)recp;
1169 		(void) snprintf(buffy, sizeof (buffy),
1170 		    " %-8s %llx %s %llu %d %llu %u", "Gpfront",
1171 		    gpfrontp->vfsp,
1172 		    fidstr = stats_log_fmtfid(&gpfrontp->fid),
1173 		    gpfrontp->fileno,
1174 		    gpfrontp->uid, gpfrontp->off, gpfrontp->len);
1175 		(void) strlcat(st->st_asciirec, buffy,
1176 		    sizeof (st->st_asciirec));
1177 		free(fidstr);
1178 		break;
1179 
1180 	case CACHEFS_LOG_RFDIR:
1181 		rfdirp = (struct cachefs_log_rfdir_record *)recp;
1182 		(void) snprintf(buffy, sizeof (buffy),
1183 		    " %-8s %llx %s %llu %d", "Rfdir",
1184 		    rfdirp->vfsp,
1185 		    fidstr = stats_log_fmtfid(&rfdirp->fid),
1186 		    rfdirp->fileno,
1187 		    rfdirp->uid);
1188 		(void) strlcat(st->st_asciirec, buffy,
1189 		    sizeof (st->st_asciirec));
1190 		free(fidstr);
1191 		break;
1192 
1193 	case CACHEFS_LOG_UALLOC:
1194 		uallocp = (struct cachefs_log_ualloc_record *)recp;
1195 		(void) snprintf(buffy, sizeof (buffy),
1196 		    " %-8s %llx %s %llu %llu %u", "Ualloc",
1197 		    uallocp->vfsp,
1198 		    fidstr = stats_log_fmtfid(&uallocp->fid),
1199 		    uallocp->fileno,
1200 		    uallocp->off, uallocp->len);
1201 		(void) strlcat(st->st_asciirec, buffy,
1202 		    sizeof (st->st_asciirec));
1203 		free(fidstr);
1204 		break;
1205 
1206 	case CACHEFS_LOG_CALLOC:
1207 		callocp = (struct cachefs_log_calloc_record *)recp;
1208 		(void) snprintf(buffy, sizeof (buffy),
1209 		    " %-8s %llx %s %llu %llu %u", "Calloc",
1210 		    callocp->vfsp,
1211 		    fidstr = stats_log_fmtfid(&callocp->fid),
1212 		    callocp->fileno, callocp->off, callocp->len);
1213 		(void) strlcat(st->st_asciirec, buffy,
1214 		    sizeof (st->st_asciirec));
1215 		free(fidstr);
1216 		break;
1217 
1218 	case CACHEFS_LOG_NOCACHE:
1219 		nocachep = (struct cachefs_log_nocache_record *)recp;
1220 		(void) snprintf(buffy, sizeof (buffy),
1221 		    " %-8s %llx %s %llu", "Nocache",
1222 		    nocachep->vfsp,
1223 		    fidstr = stats_log_fmtfid(&nocachep->fid),
1224 		    nocachep->fileno);
1225 		(void) strlcat(st->st_asciirec, buffy,
1226 		    sizeof (st->st_asciirec));
1227 		free(fidstr);
1228 		break;
1229 
1230 	default:
1231 		stats_perror(st, SE_CORRUPT,
1232 		    gettext(
1233 		    "Attempt to format invalid log type=%d (position %x)"),
1234 		    rectype, ftell(st->st_logstream));
1235 		return (NULL);
1236 	}
1237 
1238 	return (st->st_asciirec);
1239 }
1240 
1241 uint_t
1242 stats_log_get_record_info(stats_cookie_t *sc,
1243     void *recp, caddr_t *vfsp, cfs_fid_t **fidp, ino64_t *filenop,
1244     u_offset_t *offp, u_offset_t *lenp)
1245 {
1246 	int type = ((int *)recp)[0];
1247 	int error = ((int *)recp)[1];
1248 	uint_t rc = 0;
1249 
1250 	struct cachefs_log_getpage_record *getpagep;
1251 	struct cachefs_log_readdir_record *readdirp;
1252 	struct cachefs_log_readlink_record *readlinkp;
1253 	struct cachefs_log_remove_record *removep;
1254 	struct cachefs_log_rmdir_record *rmdirp;
1255 	struct cachefs_log_truncate_record *truncatep;
1256 	struct cachefs_log_putpage_record *putpagep;
1257 	struct cachefs_log_create_record *createp;
1258 	struct cachefs_log_mkdir_record *mkdirp;
1259 	struct cachefs_log_rename_record *renamep;
1260 	struct cachefs_log_symlink_record *symlinkp;
1261 	struct cachefs_log_populate_record *populatep;
1262 	struct cachefs_log_csymlink_record *csymlinkp;
1263 	struct cachefs_log_filldir_record *filldirp;
1264 	struct cachefs_log_mdcreate_record *mdcreatep;
1265 	struct cachefs_log_gpfront_record *gpfrontp;
1266 	struct cachefs_log_rfdir_record *rfdirp;
1267 	struct cachefs_log_ualloc_record *uallocp;
1268 	struct cachefs_log_calloc_record *callocp;
1269 	struct cachefs_log_nocache_record *nocachep;
1270 
1271 	switch (type) {
1272 	case CACHEFS_LOG_RFDIR:
1273 		if ((error == EINVAL) || (error == ENOENT))
1274 			error = 0;
1275 		break;
1276 	}
1277 
1278 	if (error != 0)
1279 		return (0);
1280 
1281 	switch (type) {
1282 	case CACHEFS_LOG_GETPAGE:
1283 		getpagep = (struct cachefs_log_getpage_record *)recp;
1284 		*fidp = &getpagep->fid;
1285 		*filenop = getpagep->fileno;
1286 		*vfsp = (caddr_t)(uintptr_t)getpagep->vfsp;
1287 		*offp = getpagep->offset;
1288 		*lenp = (u_offset_t)getpagep->len;
1289 		rc = (GRI_ADD | GRI_EXPENSIVE);
1290 		break;
1291 
1292 	case CACHEFS_LOG_READDIR:
1293 		readdirp = (struct cachefs_log_readdir_record *)recp;
1294 		*fidp = &readdirp->fid;
1295 		*filenop = readdirp->fileno;
1296 		*vfsp = (caddr_t)(uintptr_t)readdirp->vfsp;
1297 		*offp = readdirp->offset;
1298 		*lenp = (u_offset_t)sc->st_loghead.lh_maxbsize;
1299 		rc = (GRI_ADD | GRI_EXPENSIVE);
1300 		break;
1301 
1302 	case CACHEFS_LOG_READLINK:
1303 		readlinkp = (struct cachefs_log_readlink_record *)recp;
1304 		*fidp = &readlinkp->fid;
1305 		*filenop = readlinkp->fileno;
1306 		*vfsp = (caddr_t)(uintptr_t)readlinkp->vfsp;
1307 		*offp = 0LL;
1308 		*lenp = (u_offset_t)((readlinkp->length > C_FSL_SIZE) ?
1309 		    readlinkp->length : 0);
1310 		rc = (GRI_ADD | GRI_EXPENSIVE);
1311 		break;
1312 
1313 	case CACHEFS_LOG_REMOVE:
1314 		removep = (struct cachefs_log_remove_record *)recp;
1315 		*fidp = &removep->fid;
1316 		*filenop = removep->fileno;
1317 		*vfsp = (caddr_t)(uintptr_t)removep->vfsp;
1318 		*offp = *lenp = 0LL;
1319 		rc = (GRI_TRUNC | GRI_MODIFY);
1320 		break;
1321 
1322 	case CACHEFS_LOG_RMDIR:
1323 		rmdirp = (struct cachefs_log_rmdir_record *)recp;
1324 		*fidp = &rmdirp->fid;
1325 		*filenop = rmdirp->fileno;
1326 		*vfsp = (caddr_t)(uintptr_t)rmdirp->vfsp;
1327 		*offp = *lenp = 0LL;
1328 		rc = (GRI_TRUNC | GRI_MODIFY);
1329 		break;
1330 
1331 	case CACHEFS_LOG_TRUNCATE:
1332 		truncatep = (struct cachefs_log_truncate_record *)recp;
1333 		*fidp = &truncatep->fid;
1334 		*filenop = truncatep->fileno;
1335 		*vfsp = (caddr_t)(uintptr_t)truncatep->vfsp;
1336 		*offp = 0LL;
1337 		*lenp = truncatep->size;
1338 		rc = (GRI_TRUNC | GRI_MODIFY);
1339 		break;
1340 
1341 	case CACHEFS_LOG_PUTPAGE:
1342 		putpagep = (struct cachefs_log_putpage_record *)recp;
1343 		*fidp = &putpagep->fid;
1344 		*filenop = putpagep->fileno;
1345 		*vfsp = (caddr_t)(uintptr_t)putpagep->vfsp;
1346 		*offp = putpagep->offset;
1347 		*lenp = (u_offset_t)putpagep->len;
1348 		rc = (GRI_ADD | GRI_MODIFY);
1349 		break;
1350 
1351 	case CACHEFS_LOG_CREATE:
1352 		createp = (struct cachefs_log_create_record *)recp;
1353 		*fidp = &createp->fid;
1354 		*filenop = createp->fileno;
1355 		*vfsp = (caddr_t)(uintptr_t)createp->vfsp;
1356 		*offp = *lenp = 0LL;
1357 		rc = (GRI_ADD | GRI_MODIFY);
1358 		break;
1359 
1360 	case CACHEFS_LOG_MKDIR:
1361 		mkdirp = (struct cachefs_log_mkdir_record *)recp;
1362 		*fidp = &mkdirp->fid;
1363 		*filenop = mkdirp->fileno;
1364 		*vfsp = (caddr_t)(uintptr_t)mkdirp->vfsp;
1365 		*offp = *lenp = 0LL;
1366 		rc = (GRI_ADD | GRI_MODIFY);
1367 		break;
1368 
1369 	case CACHEFS_LOG_RENAME:
1370 		renamep = (struct cachefs_log_rename_record *)recp;
1371 		*fidp = &renamep->gone;
1372 		*filenop = renamep->fileno;
1373 		*vfsp = (caddr_t)(uintptr_t)renamep->vfsp;
1374 		*offp = *lenp = 0LL;
1375 		rc = GRI_MODIFY;
1376 		if (renamep->removed)
1377 			rc |= GRI_TRUNC;
1378 		break;
1379 
1380 	case CACHEFS_LOG_SYMLINK:
1381 		symlinkp = (struct cachefs_log_symlink_record *)recp;
1382 		*fidp = &symlinkp->fid;
1383 		*filenop = symlinkp->fileno;
1384 		*vfsp = (caddr_t)(uintptr_t)symlinkp->vfsp;
1385 		*offp = 0LL;
1386 		*lenp = (u_offset_t)((symlinkp->size > C_FSL_SIZE) ?
1387 		    symlinkp->size : 0);
1388 		rc = (GRI_ADD | GRI_MODIFY);
1389 		break;
1390 
1391 	case CACHEFS_LOG_POPULATE:
1392 		populatep = (struct cachefs_log_populate_record *)recp;
1393 		*fidp = &populatep->fid;
1394 		*filenop = populatep->fileno;
1395 		*vfsp = (caddr_t)(uintptr_t)populatep->vfsp;
1396 		*offp = populatep->off;
1397 		*lenp = (u_offset_t)populatep->size;
1398 		rc = GRI_ADD;
1399 		break;
1400 
1401 	case CACHEFS_LOG_CSYMLINK:
1402 		csymlinkp = (struct cachefs_log_csymlink_record *)recp;
1403 		*fidp = &csymlinkp->fid;
1404 		*filenop = csymlinkp->fileno;
1405 		*vfsp = (caddr_t)(uintptr_t)csymlinkp->vfsp;
1406 		*offp = 0LL;
1407 		*lenp = (u_offset_t)((csymlinkp->size > C_FSL_SIZE) ?
1408 		    csymlinkp->size : 0);
1409 		rc = GRI_ADD;
1410 		break;
1411 
1412 	case CACHEFS_LOG_FILLDIR:
1413 		filldirp = (struct cachefs_log_filldir_record *)recp;
1414 		*fidp = &filldirp->fid;
1415 		*filenop = filldirp->fileno;
1416 		*vfsp = (caddr_t)(uintptr_t)filldirp->vfsp;
1417 		*offp = 0LL;
1418 		*lenp = (u_offset_t)(filldirp->size);
1419 		rc = GRI_ADD;
1420 		break;
1421 
1422 	case CACHEFS_LOG_MDCREATE:
1423 		mdcreatep = (struct cachefs_log_mdcreate_record *)recp;
1424 		*fidp = &mdcreatep->fid;
1425 		*filenop = mdcreatep->fileno;
1426 		*vfsp = (caddr_t)(uintptr_t)mdcreatep->vfsp;
1427 		*lenp = (u_offset_t)mdcreatep->count;
1428 		rc = GRI_METADATA;
1429 		break;
1430 
1431 	case CACHEFS_LOG_GPFRONT:
1432 		gpfrontp = (struct cachefs_log_gpfront_record *)recp;
1433 		*fidp = &gpfrontp->fid;
1434 		*filenop = gpfrontp->fileno;
1435 		*vfsp = (caddr_t)(uintptr_t)gpfrontp->vfsp;
1436 		*offp = gpfrontp->off;
1437 		*lenp = (u_offset_t)sc->st_loghead.lh_pagesize;
1438 		rc = (GRI_ADD | GRI_EXPENSIVE);
1439 		break;
1440 
1441 	case CACHEFS_LOG_RFDIR:
1442 		rfdirp = (struct cachefs_log_rfdir_record *)recp;
1443 		rfdirp->error = 0;
1444 		*fidp = &rfdirp->fid;
1445 		*filenop = rfdirp->fileno;
1446 		*vfsp = (caddr_t)(uintptr_t)rfdirp->vfsp;
1447 		*offp = 0LL;
1448 		*lenp = (u_offset_t)sc->st_loghead.lh_maxbsize;
1449 		rc = (GRI_ADD | GRI_EXPENSIVE);
1450 		break;
1451 
1452 	case CACHEFS_LOG_UALLOC:
1453 		uallocp = (struct cachefs_log_ualloc_record *)recp;
1454 		*fidp = &uallocp->fid;
1455 		*filenop = uallocp->fileno;
1456 		*vfsp = (caddr_t)(uintptr_t)uallocp->vfsp;
1457 		*offp = uallocp->off;
1458 		*lenp = (u_offset_t)uallocp->len;
1459 		rc = (GRI_ADD);
1460 		break;
1461 
1462 	case CACHEFS_LOG_CALLOC:
1463 		callocp = (struct cachefs_log_calloc_record *)recp;
1464 		*fidp = &callocp->fid;
1465 		*filenop = callocp->fileno;
1466 		*vfsp = (caddr_t)(uintptr_t)callocp->vfsp;
1467 		*offp = callocp->off;
1468 		*lenp = (u_offset_t)callocp->len;
1469 		rc = (GRI_ADD | GRI_EXPENSIVE);
1470 		break;
1471 
1472 	case CACHEFS_LOG_NOCACHE:
1473 		nocachep = (struct cachefs_log_nocache_record *)recp;
1474 		*fidp = &nocachep->fid;
1475 		*filenop = nocachep->fileno;
1476 		*vfsp = (caddr_t)(uintptr_t)nocachep->vfsp;
1477 		*offp = *lenp = 0LL;
1478 		rc = (GRI_TRUNC);
1479 		break;
1480 	}
1481 
1482 	return (rc);
1483 }
1484 
1485 /*
1486  * ascii formatter for fids.  returns a malloc()ed string -- it's up to
1487  * the caller to free it.
1488  */
1489 
1490 static char *
1491 stats_log_fmtfid(cfs_fid_t *fidp)
1492 {
1493 	char buffy[BUFSIZ], *rc;
1494 
1495 (void) strcpy(buffy, "<fid>");
1496 
1497 	rc = strdup(buffy);
1498 	if (rc == NULL)
1499 		rc = "out of memory";
1500 
1501 	return (rc);
1502 }
1503 
1504 void
1505 stats_log_fi_add(stats_cookie_t *st, fid_info *fip, u_offset_t off,
1506 u_offset_t len)
1507 {
1508 	int i, j;
1509 	u_offset_t iend, jend, tmp;
1510 
1511 	assert(stats_good(st));
1512 	assert(st->st_flags & ST_DBMOPEN);
1513 	assert(st->st_flags & ST_LFOPEN);
1514 
1515 	/* shortcut if we had some sort of zero-length thing */
1516 
1517 	if (len == 0LL)
1518 		return;
1519 
1520 	/* `smear' the offset and length to block boundaries */
1521 
1522 	/*
1523 	 * pre-largefiles: iend = off & ~(st->st_loghead.lh_maxbsize - 1);
1524 	 * largefiles:  make sure that we ~ all bits in the 64 bit
1525 	 * version of (st->st_loghead.lh_maxbsize - 1)
1526 	 */
1527 	tmp = (u_offset_t)(st->st_loghead.lh_maxbsize - 1);
1528 	iend = off & ~tmp;
1529 
1530 	jend = off + len;
1531 	jend += (u_offset_t)(st->st_loghead.lh_maxbsize - 1);
1532 	/*
1533 	 * pre-largefiles:  jend &= ~(st->st_loghead.lh_maxbsize - 1);
1534 	 * largefiles: make sure that we ~ all bits in the 64 bit
1535 	 * version of (st->st_loghead.lh_maxbsize - 1)
1536 	 */
1537 	jend &= ~tmp;
1538 
1539 	off = iend;
1540 	len = jend - off;
1541 
1542 	/* see if our offset falls within an existing chunk */
1543 	for (i = 0; i < fip->fi_ent_n; i++) {
1544 		iend = fip->fi_ent[i].offset + fip->fi_ent[i].len;
1545 		if ((fip->fi_ent[i].offset <= off) && (iend >= off))
1546 			break;
1547 	}
1548 
1549 	/* update the chunk, or make a new one */
1550 	if (i < fip->fi_ent_n) {
1551 		if ((off + len) > iend)
1552 			fip->fi_ent[i].len = off + len - fip->fi_ent[i].offset;
1553 	} else if (i < C_MAX_ALLOCINFO_SLOTS) {
1554 		fip->fi_ent_n = i + 1;
1555 		fip->fi_ent[i].offset = off;
1556 		fip->fi_ent[i].len = len;
1557 	} else {
1558 		/* cachefs does a nocache, so we'll immitate */
1559 
1560 		/*
1561 		 * XXX we're free to grow again.  assume we got
1562 		 * inactivated right away -- the worst case!
1563 		 */
1564 
1565 		fip->fi_ent_n = 0;
1566 		fip->fi_total = 0LL;
1567 	}
1568 
1569 	/* quit for the trivial (hopefully the usual) case... */
1570 	if (fip->fi_ent_n <= 1) {
1571 		if (fip->fi_ent_n == 0)
1572 			fip->fi_total = 0LL;
1573 		else
1574 			fip->fi_total = fip->fi_ent[0].len;
1575 		return;
1576 	}
1577 
1578 	/*
1579 	 * we have to see if we can consolidate any chunks.  the
1580 	 * chunks aren't guaranteed to be in any kind of order, so we
1581 	 * do a qsort.  otherwise, the consolidation would be N^2 (but
1582 	 * we're probably close here).
1583 	 */
1584 
1585 	qsort(fip->fi_ent, fip->fi_ent_n, sizeof (fip->fi_ent[0]),
1586 	    stats_log_fi_comp);
1587 
1588 	/* tag non-essential entries with offset == -1, and consolidate */
1589 	for (i = 0; i < fip->fi_ent_n - 1; i++) {
1590 		if ((offset_t)fip->fi_ent[i].offset < 0)
1591 			continue;
1592 		iend = fip->fi_ent[i].offset + fip->fi_ent[i].len;
1593 
1594 		for (j = i + 1; j < fip->fi_ent_n; j++) {
1595 			if (iend < fip->fi_ent[j].offset)
1596 				break;
1597 			jend = fip->fi_ent[j].offset + fip->fi_ent[j].len;
1598 			if (jend >= iend)
1599 				fip->fi_ent[i].len =
1600 				    jend - fip->fi_ent[i].offset;
1601 			fip->fi_ent[j].offset = (u_offset_t)-1;
1602 		}
1603 	}
1604 
1605 	/* get rid of non-essential entries (without preserving order) */
1606 	for (i = 0; i < fip->fi_ent_n; i++)
1607 		if ((offset_t)fip->fi_ent[i].offset < 0)
1608 			fip->fi_ent[i--] = fip->fi_ent[--(fip->fi_ent_n)];
1609 
1610 	/* add up the new total size */
1611 	for (i = fip->fi_total = 0LL; i < fip->fi_ent_n; i++)
1612 		fip->fi_total += fip->fi_ent[i].len;
1613 }
1614 
1615 static int
1616 stats_log_fi_comp(const void *a, const void *b)
1617 {
1618 	struct fid_info_allocent *fa = (struct fid_info_allocent *)a;
1619 	struct fid_info_allocent *fb = (struct fid_info_allocent *)b;
1620 
1621 	if ((offset_t)(fa->offset - fb->offset) > 0)
1622 		return (1);
1623 	if ((offset_t)(fa->offset - fb->offset) < 0)
1624 		return (-1);
1625 	return (0);
1626 }
1627 
1628 void
1629 stats_log_fi_trunc(stats_cookie_t *st, fid_info *fip, u_offset_t off,
1630 u_offset_t len)
1631 {
1632 	fip->fi_ent_n = 1;
1633 	fip->fi_ent[0].offset = off;
1634 	fip->fi_ent[0].len = len;
1635 	fip->fi_total = len;
1636 }
1637 
1638 struct cachefs_log_logfile_header *
1639 stats_log_getheader(stats_cookie_t *st)
1640 {
1641 	assert(stats_good(st));
1642 	assert(st->st_flags & ST_LFOPEN);
1643 
1644 	return (&st->st_loghead);
1645 }
1646 
1647 void
1648 stats_log_compute_wssize(stats_cookie_t *st)
1649 {
1650 	void *record;
1651 	int type;
1652 	struct cachefs_log_mount_record *mountp;
1653 	struct cachefs_log_umount_record *umountp;
1654 	datum key;
1655 	caddr_t vfsp;
1656 	mount_info *mi = NULL, *mip;
1657 	size_t len1, len2, maxlen;
1658 	char *string1, *string2;
1659 	uint_t rflags;
1660 	fid_info fi, *fip;
1661 	cfs_fid_t *fidp;
1662 	ino64_t fileno;
1663 	u_offset_t off;
1664 	u_offset_t len;
1665 	struct cachefs_log_logfile_header *lh = &st->st_loghead;
1666 	size_t delta;
1667 
1668 	assert(stats_good(st));
1669 	assert(st->st_flags & ST_LFOPEN);
1670 	assert(st->st_flags & ST_DBMOPEN);
1671 
1672 	/*
1673 	 * The maximum size of a mount_info structure is the size of
1674 	 * the structure less the space already defined for char mi_path[]
1675 	 * plus the maximum size of mi_path.
1676 	 *
1677 	 * Additional space is allocated to mi_path at runtime using
1678 	 * malloc(). The size needs to be calculated in-situ as ANSI C
1679 	 * will only allow 'sizeof expression' or 'sizeof (type)'.
1680 	 */
1681 
1682 	mi = malloc(sizeof (*mi) - sizeof (mi->mi_path) + MI_MAX_MI_PATH);
1683 	if (mi == NULL) {
1684 		stats_perror(st, SE_NOMEM, gettext("Out of memory"));
1685 		goto out;
1686 	}
1687 
1688 	st->st_ws_init = st->st_loghead.lh_blocks;
1689 
1690 	while (record = stats_log_logfile_read(st, &type)) {
1691 		switch (type) {
1692 		case CACHEFS_LOG_MOUNT:
1693 			mountp = (struct cachefs_log_mount_record *)record;
1694 			if (mountp->error != 0)
1695 				break;
1696 			for (key = stats_dbm_firstkey(st);
1697 			    key.dptr != NULL;
1698 			    key = stats_dbm_nextkey(st)) {
1699 				if (key.dsize != sizeof (vfsp))
1700 					continue;
1701 
1702 				memcpy((caddr_t)&vfsp, key.dptr,
1703 				    sizeof (vfsp));
1704 				mip = stats_dbm_fetch_byvfsp(st, vfsp);
1705 				if (mip == NULL)
1706 					continue;
1707 
1708 				len1 = strlen(mip->mi_path);
1709 				len2 = strlen(mip->mi_path + len1 + 1);
1710 				memcpy((caddr_t)mi, mip, sizeof (*mi) +
1711 				    len1 + len2 - CLPAD(mount_info, mi_path));
1712 				free(mip);
1713 
1714 				string1 = mi->mi_path + len1 + 1;
1715 				string2 = mountp->path + mountp->pathlen + 1;
1716 				if (strcmp(string1, string2) == 0) {
1717 					stats_dbm_delete_byvfsp(st, vfsp);
1718 					break;
1719 				}
1720 			}
1721 			if (key.dptr == NULL) {
1722 				/* non-idempotent setup stuff */
1723 				memset(mi, '\0', sizeof (*mi));
1724 				mi->mi_flags = mountp->flags;
1725 				mi->mi_filegrp_size = mountp->fgsize;
1726 			}
1727 
1728 			/*
1729 			 * idempotent setup stuff
1730 			 *
1731 			 * Careful string handling around mi_path
1732 			 * is required as it contains two NULL
1733 			 * terminated strings.
1734 			 */
1735 
1736 			mi->mi_mounted = 1;
1737 			maxlen = MI_MAX_MI_PATH - 1;
1738 			len1 = strlcpy(mi->mi_path, mountp->path, maxlen);
1739 			if (len1 >= maxlen) {
1740 				stats_perror(st, SE_CORRUPT,
1741 				    gettext("Path too long in log file"));
1742 				break;
1743 			}
1744 
1745 			len1 = strlen(mi->mi_path);
1746 			maxlen = MI_MAX_MI_PATH - (len1 + 1);
1747 			len2 = strlcpy(mi->mi_path + len1 + 1,
1748 			    mountp->path + mountp->pathlen + 1, maxlen);
1749 			if (len2 >= maxlen) {
1750 				stats_perror(st, SE_CORRUPT,
1751 				    gettext("CacheID too long in log file"));
1752 				break;
1753 			}
1754 
1755 			stats_dbm_store_byvfsp(st,
1756 					(caddr_t)(uintptr_t)mountp->vfsp, mi);
1757 			break;
1758 
1759 		case CACHEFS_LOG_UMOUNT:
1760 			umountp = (struct cachefs_log_umount_record *)record;
1761 			if (umountp->error != 0)
1762 				break;
1763 			mip = stats_dbm_fetch_byvfsp(st,
1764 					(caddr_t)(uintptr_t)umountp->vfsp);
1765 			if (mip == NULL)
1766 				break;
1767 			mip->mi_mounted = 0;
1768 			stats_dbm_store_byvfsp(st,
1769 					(caddr_t)(uintptr_t)umountp->vfsp, mip);
1770 			free(mip);
1771 			break;
1772 
1773 		default:
1774 			rflags = stats_log_get_record_info(st, record,
1775 			    &vfsp, &fidp, &fileno, &off, &len);
1776 			if (rflags == 0) /* shortcut */
1777 				break;
1778 
1779 			mip = stats_dbm_fetch_byvfsp(st, vfsp);
1780 			if (mip == NULL) /* hopefully very rare */
1781 				break;
1782 
1783 			fip = stats_dbm_fetch_byfid(st, fidp);
1784 			if (fip == NULL) {
1785 				fip = &fi;
1786 				memset(&fi, '\0', sizeof (fi));
1787 				fi.fi_vfsp = vfsp;
1788 			}
1789 
1790 			/* account for the creation of the fscache */
1791 			if (! mip->mi_used) {
1792 				mip->mi_used = 1;
1793 
1794 				/* account for the .cfs_option file */
1795 				mip->mi_current += (u_offset_t)lh->lh_maxbsize;
1796 				st->st_ws_current +=
1797 				    (u_offset_t)lh->lh_maxbsize;
1798 			}
1799 
1800 			/*
1801 			 * Add in the size-growth of the attrcache.
1802 			 * len will be non-zero only for the record type
1803 			 * CACHEFS_LOG_MDCREATE, and len can't be > 2GB because
1804 			 * it refers to the number of entries in
1805 			 * the attribute cache file.
1806 			 */
1807 			assert(len <= UINT_MAX);
1808 			delta = stats_dbm_attrcache_addsize(st, mip, fileno,
1809 			    (type == CACHEFS_LOG_MDCREATE) ? (uint_t)len : 0);
1810 			st->st_ws_current += (u_offset_t)delta;
1811 			mip->mi_current += (u_offset_t)delta;
1812 
1813 			/* see if this is an `expensive' logfile */
1814 			if ((! st->st_ws_expensive) && (rflags & GRI_EXPENSIVE))
1815 				st->st_ws_expensive = 1;
1816 
1817 			/* subtract current frontfile size ... */
1818 			st->st_ws_current -= fip->fi_total;
1819 			mip->mi_current -= fip->fi_total;
1820 
1821 			/* compute new frontfile size */
1822 			if ((mip->mi_flags & CFS_WRITE_AROUND) &&
1823 			    (rflags & GRI_MODIFY)) {
1824 				fip->fi_total = 0LL;
1825 				fip->fi_ent_n = 0;
1826 			} else if (rflags & GRI_ADD) {
1827 				stats_log_fi_add(st, fip, off, len);
1828 			} else if (rflags & GRI_TRUNC) {
1829 				stats_log_fi_trunc(st, fip, off, len);
1830 			}
1831 			if (rflags & GRI_METADATA)
1832 				fip->fi_flags |= FI_METADATA;
1833 
1834 			/* add back in new frontfile size */
1835 			mip->mi_current += fip->fi_total;
1836 			if (mip->mi_current > mip->mi_high)
1837 				mip->mi_high = mip->mi_current;
1838 			stats_dbm_store_byvfsp(st, vfsp, mip);
1839 			free(mip);
1840 			st->st_ws_current += fip->fi_total;
1841 			if (st->st_ws_current > st->st_ws_high)
1842 				st->st_ws_high = st->st_ws_current;
1843 
1844 			stats_dbm_store_byfid(st, fidp, fip);
1845 			if (fip != &fi)
1846 				free(fip);
1847 			break;
1848 		}
1849 
1850 		free(record);
1851 
1852 		if (stats_inerror(st))
1853 			break;
1854 	}
1855 
1856 out:
1857 	if (mi != NULL)
1858 		free(mi);
1859 	if (! stats_inerror(st))
1860 		st->st_flags |= ST_WSCOMP;
1861 }
1862 
1863 int
1864 stats_log_wssize_init(stats_cookie_t *st)
1865 {
1866 	assert(stats_good(st));
1867 	assert(st->st_flags & ST_WSCOMP);
1868 
1869 	return (st->st_ws_init);
1870 }
1871 
1872 u_offset_t
1873 stats_log_wssize_current(stats_cookie_t *st)
1874 {
1875 	assert(stats_good(st));
1876 	assert(st->st_flags & ST_WSCOMP);
1877 
1878 	return (st->st_ws_current);
1879 }
1880 
1881 u_offset_t
1882 stats_log_wssize_high(stats_cookie_t *st)
1883 {
1884 	assert(stats_good(st));
1885 	assert(st->st_flags & ST_WSCOMP);
1886 
1887 	return (st->st_ws_high);
1888 }
1889 
1890 
1891 int
1892 stats_log_wssize_expensive(stats_cookie_t *st)
1893 {
1894 	assert(stats_good(st));
1895 	assert(st->st_flags & ST_WSCOMP);
1896 
1897 	return (st->st_ws_expensive);
1898 }
1899