Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

PR/6248: Konrad Schroder: lfs_cleanerd could use syslog() for notices, 

instead of err()/warn()
This commit is contained in:
christos 1998-10-07 15:00:34 +00:00
parent e044377a39
commit 977a282bd1
5 changed files with 197 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
libexec/lfs_cleanerd/clean.h
View File

@ -1,4 +1,4 @@
/* $NetBSD: clean.h,v 1.5 1998/09/11 21:21:29 pk Exp $ */ /* $NetBSD: clean.h,v 1.6 1998/10/07 15:00:34 christos Exp $ */
/*- /*-
* Copyright (c) 1992, 1993 * Copyright (c) 1992, 1993
@ -121,50 +121,37 @@ void toss __P((void *, int *, size_t,
/* /*
* USEFUL DEBUGGING FUNCTIONS: * USEFUL DEBUGGING FUNCTIONS:
*/ */
#ifdef VERBOSE #define PRINT_FINFO(fp, ip) if(debug > 1) { \
#define PRINT_FINFO(fp, ip) { \ syslog(LOG_DEBUG," %s %s%d version %d nblocks %d\n", \
(void)printf(" %s %s%d version %d nblocks %d\n", \
(ip)->if_version > (fp)->fi_version ? "TOSSING" : "KEEPING", \ (ip)->if_version > (fp)->fi_version ? "TOSSING" : "KEEPING", \
"FINFO for inode: ", (fp)->fi_ino, \ "FINFO for inode: ", (fp)->fi_ino, \
(fp)->fi_version, (fp)->fi_nblocks); \ (fp)->fi_version, (fp)->fi_nblocks); \
fflush(stdout); \
} }
#define PRINT_INODE(b, bip) { \ #define PRINT_INODE(b, bip) if(debug > 1) { \
(void) printf("\t%s inode: %d daddr: 0x%lx create: %s\n", \ syslog(LOG_DEBUG,"\t%s inode: %d daddr: 0x%lx create: %s\n", \
b ? "KEEPING" : "TOSSING", (bip)->bi_inode, (long)(bip)->bi_daddr, \ b ? "KEEPING" : "TOSSING", (bip)->bi_inode, (long)(bip)->bi_daddr, \
ctime((time_t *)&(bip)->bi_segcreate)); \ ctime((time_t *)&(bip)->bi_segcreate)); \
fflush(stdout); \
} }
#define PRINT_BINFO(bip) { \ #define PRINT_BINFO(bip) if(debug > 1 ) { \
(void)printf("\tinode: %d lbn: %d daddr: 0x%lx create: %s\n", \ syslog(LOG_DEBUG,"\tinode: %d lbn: %d daddr: 0x%lx create: %s\n", \
(bip)->bi_inode, (bip)->bi_lbn, (unsigned long)(bip)->bi_daddr, \ (bip)->bi_inode, (bip)->bi_lbn, (unsigned long)(bip)->bi_daddr, \
ctime((time_t *)&(bip)->bi_segcreate)); \ ctime((time_t *)&(bip)->bi_segcreate)); \
fflush(stdout); \
} }
#define PRINT_SEGUSE(sup, n) { \ #define PRINT_SEGUSE(sup, n) if(debug > 1) { \
(void)printf("Segment %d nbytes=%lu\tflags=%c%c%c ninos=%d nsums=%d lastmod: %s\n", \ syslog(LOG_DEBUG,"Segment %d nbytes=%lu\tflags=%c%c%c ninos=%d nsums=%d lastmod: %s\n", \
n, (unsigned long)(sup)->su_nbytes, \ n, (unsigned long)(sup)->su_nbytes, \
(sup)->su_flags & SEGUSE_DIRTY ? 'D' : 'C', \ (sup)->su_flags & SEGUSE_DIRTY ? 'D' : 'C', \
(sup)->su_flags & SEGUSE_ACTIVE ? 'A' : ' ', \ (sup)->su_flags & SEGUSE_ACTIVE ? 'A' : ' ', \
(sup)->su_flags & SEGUSE_SUPERBLOCK ? 'S' : ' ', \ (sup)->su_flags & SEGUSE_SUPERBLOCK ? 'S' : ' ', \
(sup)->su_ninos, (sup)->su_nsums, \ (sup)->su_ninos, (sup)->su_nsums, \
ctime((time_t *)&(sup)->su_lastmod)); \ ctime((time_t *)&(sup)->su_lastmod)); \
fflush(stdout); \
} }
void dump_super __P((struct lfs *)); void dump_super __P((struct lfs *));
void dump_cleaner_info __P((void *)); void dump_cleaner_info __P((void *));
void print_SEGSUM __P(( struct lfs *, SEGSUM *)); void print_SEGSUM __P(( struct lfs *, SEGSUM *));
void print_CLEANERINFO __P((CLEANERINFO *)); void print_CLEANERINFO __P((CLEANERINFO *));
#else
#define PRINT_FINFO(fp, ip)
#define PRINT_INODE(b, bip)
#define PRINT_BINFO(bip)
#define PRINT_SEGUSE(sup, n)
#define dump_cleaner_info(cip)
#define dump_super(lfsp)
#endif
__END_DECLS __END_DECLS

138
libexec/lfs_cleanerd/cleanerd.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: cleanerd.c,v 1.10 1998/10/07 14:57:30 christos Exp $ */ /* $NetBSD: cleanerd.c,v 1.11 1998/10/07 15:00:34 christos Exp $ */
/*- /*-
* Copyright (c) 1992, 1993 * Copyright (c) 1992, 1993
@ -40,7 +40,7 @@ __COPYRIGHT("@(#) Copyright (c) 1992, 1993\n\
#if 0 #if 0
static char sccsid[] = "@(#)cleanerd.c 8.5 (Berkeley) 6/10/95"; static char sccsid[] = "@(#)cleanerd.c 8.5 (Berkeley) 6/10/95";
#else #else
__RCSID("$NetBSD: cleanerd.c,v 1.10 1998/10/07 14:57:30 christos Exp $"); __RCSID("$NetBSD: cleanerd.c,v 1.11 1998/10/07 15:00:34 christos Exp $");
#endif #endif
#endif /* not lint */ #endif /* not lint */
@ -57,11 +57,14 @@ __RCSID("$NetBSD: cleanerd.c,v 1.10 1998/10/07 14:57:30 christos Exp $");
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include <syslog.h>
#include "clean.h" #include "clean.h"
char *special = "cleanerd"; char *special = "cleanerd";
int do_small = 0; int do_small = 0;
int do_mmap = 0; int do_mmap = 0;
int stat_report = 0; int stat_report = 0;
int debug = 0;
struct cleaner_stats { struct cleaner_stats {
double util_tot; double util_tot;
double util_sos; double util_sos;
@ -142,12 +145,10 @@ cost_benefit(fsp, su)
* *
* priority = ((seg_size - live) * age) / (seg_size + live) * priority = ((seg_size - live) * age) / (seg_size + live)
*/ */
#ifdef VERBOSE
if (live < 0 || live > seg_size(lfsp)) { if (live < 0 || live > seg_size(lfsp)) {
err(0, "Bad segusage count: %d", live); syslog(LOG_NOTICE,"bad segusage count: %d", live);
live = 0; live = 0;
} }
#endif
return (lblkno(lfsp, seg_size(lfsp) - live) * age) return (lblkno(lfsp, seg_size(lfsp) - live) * age)
/ lblkno(lfsp, seg_size(lfsp) + live); / lblkno(lfsp, seg_size(lfsp) + live);
} }
@ -163,11 +164,11 @@ main(argc, argv)
struct timeval timeout; /* sleep timeout */ struct timeval timeout; /* sleep timeout */
fsid_t fsid; fsid_t fsid;
long clean_opts; /* cleaning options */ long clean_opts; /* cleaning options */
int nodaemon, segs_per_clean; int segs_per_clean;
int opt, cmd_err; int opt, cmd_err;
char *fs_name; /* name of filesystem to clean */ char *fs_name; /* name of filesystem to clean */
cmd_err = nodaemon = 0; cmd_err = debug = 0;
clean_opts = 0; clean_opts = 0;
segs_per_clean = 1; segs_per_clean = 1;
while ((opt = getopt(argc, argv, "bdmn:r:s")) != -1) { while ((opt = getopt(argc, argv, "bdmn:r:s")) != -1) {
@ -180,7 +181,7 @@ main(argc, argv)
clean_opts |= CLEAN_BYTES; clean_opts |= CLEAN_BYTES;
break; break;
case 'd': /* Debug mode. */ case 'd': /* Debug mode. */
nodaemon = 1; debug++;
break; break;
case 'm': case 'm':
do_mmap = 1; do_mmap = 1;
@ -201,7 +202,7 @@ main(argc, argv)
argc -= optind; argc -= optind;
argv += optind; argv += optind;
if (cmd_err || (argc != 1)) if (cmd_err || (argc != 1))
err(1, "usage: lfs_cleanerd [-smd] fs_name"); err(1, "usage: lfs_cleanerd [-bdms] [-n nsegs] [-r report_freq] fs_name");
fs_name = argv[0]; fs_name = argv[0];
@ -213,9 +214,15 @@ main(argc, argv)
err(1, "lfs_cleanerd: filesystem %s isn't an LFS!", fs_name); err(1, "lfs_cleanerd: filesystem %s isn't an LFS!", fs_name);
} }
if (!nodaemon) /* should we become a daemon, chdir to / & close fd's */ /* should we become a daemon, chdir to / & close fd's */
if (debug == 0) {
if (daemon(0, 0) == -1) if (daemon(0, 0) == -1)
err(1, "lfs_cleanerd: couldn't become a daemon!"); err(1, "lfs_cleanerd: couldn't become a daemon!");
openlog("lfs_cleanerd", LOG_NDELAY|LOG_PID, LOG_DAEMON);
} else {
openlog("lfs_cleanerd", LOG_NDELAY|LOG_PID|LOG_PERROR,
LOG_DAEMON);
}
timeout.tv_sec = 5*60; /* five minutes */ timeout.tv_sec = 5*60; /* five minutes */
timeout.tv_usec = 0; timeout.tv_usec = 0;
@ -233,14 +240,12 @@ main(argc, argv)
if (clean_loop(fsp, segs_per_clean, clean_opts)) if (clean_loop(fsp, segs_per_clean, clean_opts))
continue; continue;
#ifdef VERBOSE if(debug > 1)
(void)printf("Cleaner going to sleep.\n"); syslog(LOG_DEBUG,"Cleaner going to sleep.\n");
#endif
if (lfs_segwait(&fsid, &timeout) < 0) if (lfs_segwait(&fsid, &timeout) < 0)
err(0, "lfs_segwait: returned error\n"); syslog(LOG_WARNING,"lfs_segwait returned error\n");
#ifdef VERBOSE if(debug > 1)
(void)printf("Cleaner waking up.\n"); syslog(LOG_DEBUG,"Cleaner waking up.\n");
#endif
} }
} }
@ -268,18 +273,22 @@ clean_loop(fsp, nsegs, options)
* space is less than BUSY_LIM % of possible clean space. * space is less than BUSY_LIM % of possible clean space.
*/ */
now = time((time_t *)NULL); now = time((time_t *)NULL);
#ifdef VERBOSE
printf("db_per_seg = %lu max_free_segs = %lu, bfree = %u avail = %d ", if(debug > 1) {
syslog(LOG_DEBUG, "db_per_seg = %lu max_free_segs = %lu, bfree = %u avail = %d ",
db_per_seg, max_free_segs, fsp->fi_lfs.lfs_bfree, db_per_seg, max_free_segs, fsp->fi_lfs.lfs_bfree,
fsp->fi_lfs.lfs_avail); fsp->fi_lfs.lfs_avail);
printf("clean = %d\n", fsp->fi_cip->clean); syslog(LOG_DEBUG, "clean = %d\n", fsp->fi_cip->clean);
#endif }
if ((fsp->fi_lfs.lfs_bfree - fsp->fi_lfs.lfs_avail > db_per_seg && if ((fsp->fi_lfs.lfs_bfree - fsp->fi_lfs.lfs_avail > db_per_seg &&
fsp->fi_lfs.lfs_avail < db_per_seg) || fsp->fi_lfs.lfs_avail < db_per_seg) ||
(fsp->fi_cip->clean < max_free_segs && (fsp->fi_cip->clean < max_free_segs &&
(fsp->fi_cip->clean <= MIN_SEGS(&fsp->fi_lfs) || (fsp->fi_cip->clean <= MIN_SEGS(&fsp->fi_lfs) ||
fsp->fi_cip->clean < max_free_segs * BUSY_LIM))) { fsp->fi_cip->clean < max_free_segs * BUSY_LIM)))
printf("Cleaner Running at %s (%d of %lu segments available)\n", {
if(debug)
syslog(LOG_DEBUG, "Cleaner Running at %s (%d of %lu segments available)\n",
ctime(&now), fsp->fi_cip->clean, max_free_segs); ctime(&now), fsp->fi_cip->clean, max_free_segs);
clean_fs(fsp, cost_benefit, nsegs, options); clean_fs(fsp, cost_benefit, nsegs, options);
return (1); return (1);
@ -296,12 +305,14 @@ clean_loop(fsp, nsegs, options)
if (loadavg[ONE_MIN] == 0.0 && loadavg[FIVE_MIN] && if (loadavg[ONE_MIN] == 0.0 && loadavg[FIVE_MIN] &&
fsp->fi_cip->clean < max_free_segs * IDLE_LIM) { fsp->fi_cip->clean < max_free_segs * IDLE_LIM) {
clean_fs(fsp, cost_benefit, nsegs, options); clean_fs(fsp, cost_benefit, nsegs, options);
printf("Cleaner Running at %s (system idle)\n", if(debug)
syslog(LOG_DEBUG, "Cleaner Running at %s (system idle)\n",
ctime(&now)); ctime(&now));
return (1); return (1);
} }
} }
printf("Cleaner Not Running at %s\n", ctime(&now)); if(debug)
syslog(LOG_DEBUG, "Cleaner Not Running at %s", ctime(&now));
return (0); return (0);
} }
@ -319,15 +330,15 @@ clean_fs(fsp, cost_func, nsegs, options)
if ((segs = if ((segs =
malloc(fsp->fi_lfs.lfs_nseg * sizeof(struct seglist))) == NULL) { malloc(fsp->fi_lfs.lfs_nseg * sizeof(struct seglist))) == NULL) {
err(0, "malloc failed"); syslog(LOG_WARNING,"malloc failed: %m");
return; return;
} }
i = choose_segments(fsp, segs, cost_func); i = choose_segments(fsp, segs, cost_func);
#ifdef VERBOSE
printf("clean_fs: found %d segments to clean in file system %s\n", if(debug > 1)
syslog(LOG_DEBUG, "clean_fs: found %d segments to clean in file system %s\n",
i, fsp->fi_statfsp->f_mntonname); i, fsp->fi_statfsp->f_mntonname);
fflush(stdout);
#endif
if (i) { if (i) {
/* Check which cleaning algorithm to use. */ /* Check which cleaning algorithm to use. */
if (options & CLEAN_BYTES) { if (options & CLEAN_BYTES) {
@ -341,7 +352,8 @@ clean_fs(fsp, cost_func, nsegs, options)
else if (lfs_segclean(&fsp->fi_statfsp->f_fsid, else if (lfs_segclean(&fsp->fi_statfsp->f_fsid,
sp->sl_id) < 0) sp->sl_id) < 0)
perror("lfs_segclean failed"); perror("lfs_segclean failed");
printf("Cleaned segment %d (%d bytes)\n", if(debug)
syslog(LOG_DEBUG, "Cleaned segment %d (%d bytes)\n",
sp->sl_id, sp->sl_bytes); sp->sl_id, sp->sl_bytes);
cleaned_bytes += sp->sl_bytes; cleaned_bytes += sp->sl_bytes;
} }
@ -352,7 +364,8 @@ clean_fs(fsp, cost_func, nsegs, options)
else if (lfs_segclean(&fsp->fi_statfsp->f_fsid, else if (lfs_segclean(&fsp->fi_statfsp->f_fsid,
sp->sl_id) < 0) sp->sl_id) < 0)
perror("lfs_segclean failed"); perror("lfs_segclean failed");
printf("Completed cleaning segment %d\n", sp->sl_id); if(debug)
syslog(LOG_DEBUG,"Completed cleaning segment %d\n", sp->sl_id);
} }
} }
free(segs); free(segs);
@ -390,9 +403,8 @@ choose_segments(fsp, seglist, cost_func)
lfsp = &fsp->fi_lfs; lfsp = &fsp->fi_lfs;
#ifdef VERBOSE if(debug > 1)
(void)printf("Entering choose_segments\n"); syslog(LOG_DEBUG,"Entering choose_segments\n");
#endif
dump_super(lfsp); dump_super(lfsp);
dump_cleaner_info(fsp->fi_cip); dump_cleaner_info(fsp->fi_cip);
@ -402,9 +414,8 @@ choose_segments(fsp, seglist, cost_func)
if (!(sup->su_flags & SEGUSE_DIRTY) || if (!(sup->su_flags & SEGUSE_DIRTY) ||
sup->su_flags & SEGUSE_ACTIVE) sup->su_flags & SEGUSE_ACTIVE)
continue; continue;
#ifdef VERBOSE if(debug > 1)
(void)printf("\tchoosing segment %d\n", i); syslog(LOG_DEBUG, "\tchoosing segment %d\n", i);
#endif
sp->sl_cost = (*cost_func)(fsp, sup); sp->sl_cost = (*cost_func)(fsp, sup);
sp->sl_id = i; sp->sl_id = i;
sp->sl_bytes = sup->su_nbytes; sp->sl_bytes = sup->su_nbytes;
@ -412,9 +423,10 @@ choose_segments(fsp, seglist, cost_func)
} }
nsegs = sp - seglist; nsegs = sp - seglist;
qsort(seglist, nsegs, sizeof(struct seglist), cost_compare); qsort(seglist, nsegs, sizeof(struct seglist), cost_compare);
#ifdef VERBOSE
(void)printf("Returning %d segments\n", nsegs); if(debug > 1)
#endif syslog(LOG_DEBUG,"Returning %d segments\n", nsegs);
return (nsegs); return (nsegs);
} }
@ -424,22 +436,22 @@ clean_segment(fsp, id)
FS_INFO *fsp; /* file system information */ FS_INFO *fsp; /* file system information */
int id; /* segment number */ int id; /* segment number */
{ {
BLOCK_INFO *block_array, *bp; BLOCK_INFO *block_array, *bp, *_bip;
SEGUSE *sp; SEGUSE *sp;
struct lfs *lfsp; struct lfs *lfsp;
struct tossstruct t; struct tossstruct t;
double util; double util;
caddr_t seg_buf; caddr_t seg_buf;
int num_blocks, maxblocks, clean_blocks; int num_blocks, maxblocks, clean_blocks, i;
unsigned long *lp;
lfsp = &fsp->fi_lfs; lfsp = &fsp->fi_lfs;
sp = SEGUSE_ENTRY(lfsp, fsp->fi_segusep, id); sp = SEGUSE_ENTRY(lfsp, fsp->fi_segusep, id);
#ifdef VERBOSE if(debug > 1)
(void)printf("cleaning segment %d: contains %lu bytes\n", id, syslog(LOG_DEBUG, "cleaning segment %d: contains %lu bytes\n", id,
(unsigned long)sp->su_nbytes); (unsigned long)sp->su_nbytes);
fflush(stdout);
#endif
/* XXX could add debugging to verify that segment is really empty */ /* XXX could add debugging to verify that segment is really empty */
if (sp->su_nbytes == sp->su_nsums * LFS_SUMMARY_SIZE) { if (sp->su_nbytes == sp->su_nsums * LFS_SUMMARY_SIZE) {
++cleaner_stats.segs_empty; ++cleaner_stats.segs_empty;
@ -448,22 +460,20 @@ clean_segment(fsp, id)
/* map the segment into a buffer */ /* map the segment into a buffer */
if (mmap_segment(fsp, id, &seg_buf, do_mmap) < 0) { if (mmap_segment(fsp, id, &seg_buf, do_mmap) < 0) {
err(0, "mmap_segment failed"); syslog(LOG_WARNING,"clean_segment: mmap_segment failed: %m");
++cleaner_stats.segs_error; ++cleaner_stats.segs_error;
return (-1); return (-1);
} }
/* get a list of blocks that are contained by the segment */ /* get a list of blocks that are contained by the segment */
if (lfs_segmapv(fsp, id, seg_buf, &block_array, &num_blocks) < 0) { if (lfs_segmapv(fsp, id, seg_buf, &block_array, &num_blocks) < 0) {
err(0, "clean_segment: lfs_segmapv failed"); syslog(LOG_WARNING,"clean_segment: lfs_segmapv failed");
++cleaner_stats.segs_error; ++cleaner_stats.segs_error;
return (-1); return (-1);
} }
cleaner_stats.blocks_read += fsp->fi_lfs.lfs_ssize; cleaner_stats.blocks_read += fsp->fi_lfs.lfs_ssize;
#ifdef VERBOSE if(debug > 1)
(void)printf("lfs_segmapv returned %d blocks\n", num_blocks); syslog(LOG_DEBUG, "lfs_segmapv returned %d blocks\n", num_blocks);
fflush(stdout);
#endif
/* get the current disk address of blocks contained by the segment */ /* get the current disk address of blocks contained by the segment */
if (lfs_bmapv(&fsp->fi_statfsp->f_fsid, block_array, num_blocks) < 0) { if (lfs_bmapv(&fsp->fi_statfsp->f_fsid, block_array, num_blocks) < 0) {
@ -481,22 +491,16 @@ clean_segment(fsp, id)
if (num_blocks && bi_tossold(&t, block_array + num_blocks - 1, NULL)) if (num_blocks && bi_tossold(&t, block_array + num_blocks - 1, NULL))
--num_blocks; --num_blocks;
#ifdef VERBOSE if(debug > 1) {
{ syslog(LOG_DEBUG, "after bmapv still have %d blocks\n", num_blocks);
BLOCK_INFO *_bip;
u_long *lp;
int i;
(void)printf("after bmapv still have %d blocks\n", num_blocks);
fflush(stdout);
if (num_blocks) if (num_blocks)
printf("BLOCK INFOS\n"); syslog(LOG_DEBUG, "BLOCK INFOS\n");
for (_bip = block_array, i=0; i < num_blocks; ++_bip, ++i) { for (_bip = block_array, i=0; i < num_blocks; ++_bip, ++i) {
PRINT_BINFO(_bip); PRINT_BINFO(_bip);
lp = (u_long *)_bip->bi_bp; lp = (u_long *)_bip->bi_bp;
} }
} }
#endif
++cleaner_stats.segs_cleaned; ++cleaner_stats.segs_cleaned;
cleaner_stats.blocks_written += num_blocks; cleaner_stats.blocks_written += num_blocks;
util = ((double)num_blocks / fsp->fi_lfs.lfs_ssize); util = ((double)num_blocks / fsp->fi_lfs.lfs_ssize);
@ -511,7 +515,7 @@ clean_segment(fsp, id)
clean_blocks = maxblocks < num_blocks ? maxblocks : num_blocks; clean_blocks = maxblocks < num_blocks ? maxblocks : num_blocks;
if (lfs_markv(&fsp->fi_statfsp->f_fsid, if (lfs_markv(&fsp->fi_statfsp->f_fsid,
bp, clean_blocks) < 0) { bp, clean_blocks) < 0) {
err(0, "clean_segment: lfs_markv failed"); syslog(LOG_WARNING,"clean_segment: lfs_markv failed: %m");
++cleaner_stats.segs_error; ++cleaner_stats.segs_error;
return (-1); return (-1);
} }
@ -546,16 +550,16 @@ sig_report(sig)
{ {
double avg = 0.0; double avg = 0.0;
printf("lfs_cleanerd:\t%s%d\n\t\t%s%d\n\t\t%s%d\n\t\t%s%d\n\t\t%s%d\n", syslog(LOG_DEBUG, "lfs_cleanerd:\t%s%d\n\t\t%s%d\n\t\t%s%d\n\t\t%s%d\n\t\t%s%d\n",
"blocks_read ", cleaner_stats.blocks_read, "blocks_read ", cleaner_stats.blocks_read,
"blocks_written ", cleaner_stats.blocks_written, "blocks_written ", cleaner_stats.blocks_written,
"segs_cleaned ", cleaner_stats.segs_cleaned, "segs_cleaned ", cleaner_stats.segs_cleaned,
"segs_empty ", cleaner_stats.segs_empty, "segs_empty ", cleaner_stats.segs_empty,
"seg_error ", cleaner_stats.segs_error); "seg_error ", cleaner_stats.segs_error);
printf("\t\t%s%5.2f\n\t\t%s%5.2f\n", syslog(LOG_DEBUG, "\t\t%s%5.2f\n\t\t%s%5.2f\n",
"util_tot ", cleaner_stats.util_tot, "util_tot ", cleaner_stats.util_tot,
"util_sos ", cleaner_stats.util_sos); "util_sos ", cleaner_stats.util_sos);
printf("\t\tavg util: %4.2f std dev: %9.6f\n", syslog(LOG_DEBUG, "\t\tavg util: %4.2f std dev: %9.6f\n",
avg = cleaner_stats.util_tot / cleaner_stats.segs_cleaned, avg = cleaner_stats.util_tot / cleaner_stats.segs_cleaned,
cleaner_stats.util_sos / cleaner_stats.segs_cleaned - avg * avg); cleaner_stats.util_sos / cleaner_stats.segs_cleaned - avg * avg);

126
libexec/lfs_cleanerd/library.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: library.c,v 1.8 1998/09/11 21:21:29 pk Exp $ */ /* $NetBSD: library.c,v 1.9 1998/10/07 15:00:34 christos Exp $ */
/*- /*-
* Copyright (c) 1992, 1993 * Copyright (c) 1992, 1993
@ -38,7 +38,7 @@
#if 0 #if 0
static char sccsid[] = "@(#)library.c 8.3 (Berkeley) 5/24/95"; static char sccsid[] = "@(#)library.c 8.3 (Berkeley) 5/24/95";
#else #else
__RCSID("$NetBSD: library.c,v 1.8 1998/09/11 21:21:29 pk Exp $"); __RCSID("$NetBSD: library.c,v 1.9 1998/10/07 15:00:34 christos Exp $");
#endif #endif
#endif /* not lint */ #endif /* not lint */
@ -58,6 +58,7 @@ __RCSID("$NetBSD: library.c,v 1.8 1998/09/11 21:21:29 pk Exp $");
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <syslog.h>
#include "clean.h" #include "clean.h"
@ -72,6 +73,7 @@ int get_superblock __P((FS_INFO *, struct lfs *));
int pseg_valid __P((FS_INFO *, SEGSUM *)); int pseg_valid __P((FS_INFO *, SEGSUM *));
void print_SEGSUM __P((struct lfs *, SEGSUM *)); void print_SEGSUM __P((struct lfs *, SEGSUM *));
extern int debug;
extern u_long cksum __P((void *, size_t)); /* XXX */ extern u_long cksum __P((void *, size_t)); /* XXX */
/* /*
@ -125,8 +127,10 @@ get_fs_info (lstatfsp, use_mmap)
memset(fsp, 0, sizeof(FS_INFO)); memset(fsp, 0, sizeof(FS_INFO));
fsp->fi_statfsp = lstatfsp; fsp->fi_statfsp = lstatfsp;
if (get_superblock (fsp, &fsp->fi_lfs)) if (get_superblock (fsp, &fsp->fi_lfs)) {
err(1, "get_fs_info: get_superblock failed"); syslog(LOG_ERR, "Exiting: get_fs_info: get_superblock failed: %m");
exit(1);
}
fsp->fi_daddr_shift = fsp->fi_daddr_shift =
fsp->fi_lfs.lfs_bshift - fsp->fi_lfs.lfs_fsbtodb; fsp->fi_lfs.lfs_bshift - fsp->fi_lfs.lfs_fsbtodb;
get_ifile (fsp, use_mmap); get_ifile (fsp, use_mmap);
@ -144,8 +148,10 @@ reread_fs_info(fsp, use_mmap)
int use_mmap; int use_mmap;
{ {
if (statfs(fsp->fi_statfsp->f_mntonname, fsp->fi_statfsp)) if (statfs(fsp->fi_statfsp->f_mntonname, fsp->fi_statfsp)) {
err(1, "reread_fs_info: statfs failed"); syslog(LOG_ERR, "Exiting: reread_fs_info: statfs failed: %m");
exit(1);
}
get_ifile (fsp, use_mmap); get_ifile (fsp, use_mmap);
} }
@ -165,7 +171,7 @@ get_superblock (fsp, sbp)
strcat(mntfromname, fsp->fi_statfsp->f_mntfromname+5); strcat(mntfromname, fsp->fi_statfsp->f_mntfromname+5);
if ((fid = open(mntfromname, O_RDONLY, (mode_t)0)) < 0) { if ((fid = open(mntfromname, O_RDONLY, (mode_t)0)) < 0) {
err(0, "get_superblock: bad open"); syslog(LOG_WARNING,"get_superblock: bad open: %m");
return (-1); return (-1);
} }
@ -197,11 +203,15 @@ get_ifile (fsp, use_mmap)
strcat(strcat(strcpy(ifile_name, fsp->fi_statfsp->f_mntonname), "/"), strcat(strcat(strcpy(ifile_name, fsp->fi_statfsp->f_mntonname), "/"),
IFILE_NAME); IFILE_NAME);
if ((fid = open(ifile_name, O_RDWR, (mode_t)0)) < 0) if ((fid = open(ifile_name, O_RDWR, (mode_t)0)) < 0) {
err(1, "get_ifile: bad open"); syslog(LOG_ERR, "Exiting: get_ifile: bad open: %m");
exit(1);
}
if (fstat (fid, &file_stat)) if (fstat (fid, &file_stat)) {
err(1, "get_ifile: fstat failed"); syslog(LOG_ERR, "Exiting: get_ifile: fstat failed: %m");
exit(1);
}
if (use_mmap && file_stat.st_size == fsp->fi_ifile_length) { if (use_mmap && file_stat.st_size == fsp->fi_ifile_length) {
(void) close(fid); (void) close(fid);
@ -214,22 +224,30 @@ get_ifile (fsp, use_mmap)
munmap((caddr_t)fsp->fi_cip, fsp->fi_ifile_length); munmap((caddr_t)fsp->fi_cip, fsp->fi_ifile_length);
ifp = mmap ((caddr_t)0, file_stat.st_size, ifp = mmap ((caddr_t)0, file_stat.st_size,
PROT_READ|PROT_WRITE, MAP_FILE|MAP_PRIVATE, fid, (off_t)0); PROT_READ|PROT_WRITE, MAP_FILE|MAP_PRIVATE, fid, (off_t)0);
if (ifp == (caddr_t)(-1)) if (ifp == (caddr_t)(-1)) {
err(1, "get_ifile: mmap failed"); syslog(LOG_ERR, "Exiting: get_ifile: mmap failed: %m");
exit(1);
}
} else { } else {
if (fsp->fi_cip) if (fsp->fi_cip)
free(fsp->fi_cip); free(fsp->fi_cip);
if (!(ifp = malloc (file_stat.st_size))) if (!(ifp = malloc (file_stat.st_size))) {
err (1, "get_ifile: malloc failed"); syslog(LOG_ERR, "Exiting: get_ifile: malloc failed: %m");
exit(1);
}
redo_read: redo_read:
count = read (fid, ifp, (size_t) file_stat.st_size); count = read (fid, ifp, (size_t) file_stat.st_size);
if (count < 0) if (count < 0) {
err(1, "get_ifile: bad ifile read"); syslog(LOG_ERR, "Exiting: get_ifile: bad ifile read: %m");
exit(1);
}
else if (count < file_stat.st_size) { else if (count < file_stat.st_size) {
err(0, "get_ifile"); syslog(LOG_WARNING, "get_ifile: %m");
if (lseek(fid, 0, SEEK_SET) < 0) if (lseek(fid, 0, SEEK_SET) < 0) {
err(1, "get_ifile: bad ifile lseek"); syslog(LOG_ERR, "Exiting: get_ifile: bad ifile lseek: %m");
exit(1);
}
goto redo_read; goto redo_read;
} }
} }
@ -268,18 +286,15 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount)
BLOCK_INFO **blocks; /* OUT: array of block_info for live blocks */ BLOCK_INFO **blocks; /* OUT: array of block_info for live blocks */
int *bcount; /* OUT: number of active blocks in segment */ int *bcount; /* OUT: number of active blocks in segment */
{ {
BLOCK_INFO *bip; BLOCK_INFO *bip, *_bip;
SEGSUM *sp; SEGSUM *sp;
SEGUSE *sup; SEGUSE *sup;
FINFO *fip; FINFO *fip;
struct lfs *lfsp; struct lfs *lfsp;
caddr_t s; caddr_t s;
daddr_t pseg_addr, seg_addr; daddr_t pseg_addr, seg_addr;
int nelem, nblocks, nsegs, sumsize; int nelem, nblocks, nsegs, sumsize, i;
time_t timestamp; time_t timestamp;
#if defined(DIAGNOSTIC)
int i;
#endif
i = 0; i = 0;
lfsp = &fsp->fi_lfs; lfsp = &fsp->fi_lfs;
@ -291,9 +306,10 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount)
s = seg_buf + (sup->su_flags & SEGUSE_SUPERBLOCK ? LFS_SBPAD : 0); s = seg_buf + (sup->su_flags & SEGUSE_SUPERBLOCK ? LFS_SBPAD : 0);
seg_addr = sntoda(lfsp, seg); seg_addr = sntoda(lfsp, seg);
pseg_addr = seg_addr + (sup->su_flags & SEGUSE_SUPERBLOCK ? btodb(LFS_SBPAD) : 0); pseg_addr = seg_addr + (sup->su_flags & SEGUSE_SUPERBLOCK ? btodb(LFS_SBPAD) : 0);
#ifdef VERBOSE
printf("\tsegment buffer at: %p\tseg_addr 0x%x\n", s, seg_addr); if(debug > 1)
#endif /* VERBOSE */ syslog(LOG_DEBUG, "\tsegment buffer at: %p\tseg_addr 0x%x\n", s, seg_addr);
*bcount = 0; *bcount = 0;
for (nsegs = 0, timestamp = 0; nsegs < sup->su_nsums; nsegs++) { for (nsegs = 0, timestamp = 0; nsegs < sup->su_nsums; nsegs++) {
@ -301,7 +317,7 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount)
nblocks = pseg_valid(fsp, sp); nblocks = pseg_valid(fsp, sp);
if (nblocks <= 0) { if (nblocks <= 0) {
printf("Warning: invalid segment summary at 0x%x\n", syslog(LOG_DEBUG, "Warning: invalid segment summary at 0x%x\n",
pseg_addr); pseg_addr);
break; break;
} }
@ -321,7 +337,7 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount)
fip = (FINFO *)(&fip->fi_blocks[fip->fi_nblocks]); fip = (FINFO *)(&fip->fi_blocks[fip->fi_nblocks]);
} }
if (sumsize > LFS_SUMMARY_SIZE) { if (sumsize > LFS_SUMMARY_SIZE) {
fprintf(stderr, syslog(LOG_ERR,
"Segment %d summary block too big: %d\n", "Segment %d summary block too big: %d\n",
seg, sumsize); seg, sumsize);
exit(1); exit(1);
@ -342,16 +358,13 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount)
} }
qsort(bip, *bcount, sizeof(BLOCK_INFO), bi_compare); qsort(bip, *bcount, sizeof(BLOCK_INFO), bi_compare);
toss(bip, bcount, sizeof(BLOCK_INFO), bi_toss, NULL); toss(bip, bcount, sizeof(BLOCK_INFO), bi_toss, NULL);
#ifdef VERBOSE
{
BLOCK_INFO *_bip;
int i;
printf("BLOCK INFOS\n"); if(debug > 1) {
syslog(LOG_DEBUG, "BLOCK INFOS\n");
for (_bip = bip, i=0; i < *bcount; ++_bip, ++i) for (_bip = bip, i=0; i < *bcount; ++_bip, ++i)
PRINT_BINFO(_bip); PRINT_BINFO(_bip);
} }
#endif
*blocks = bip; *blocks = bip;
return (0); return (0);
@ -383,9 +396,9 @@ add_blocks (fsp, bip, countp, sp, seg_buf, segaddr, psegaddr)
int db_frag; int db_frag;
u_long page_size; u_long page_size;
#ifdef VERBOSE if(debug > 1)
printf("FILE INFOS\n"); syslog(LOG_DEBUG, "FILE INFOS\n");
#endif
db_per_block = fsbtodb(&fsp->fi_lfs, 1); db_per_block = fsbtodb(&fsp->fi_lfs, 1);
page_size = fsp->fi_lfs.lfs_bsize; page_size = fsp->fi_lfs.lfs_bsize;
bp = seg_buf + datobyte(fsp, psegaddr - segaddr) + LFS_SUMMARY_SIZE; bp = seg_buf + datobyte(fsp, psegaddr - segaddr) + LFS_SUMMARY_SIZE;
@ -421,12 +434,12 @@ add_blocks (fsp, bip, countp, sp, seg_buf, segaddr, psegaddr)
db_frag = fragstodb(&(fsp->fi_lfs), db_frag = fragstodb(&(fsp->fi_lfs),
numfrags(&(fsp->fi_lfs), numfrags(&(fsp->fi_lfs),
fip->fi_lastlength)); fip->fi_lastlength));
#ifdef VERBOSE
printf("lastlength, frags: %d, %d, %d\n", if(debug > 1)
syslog(LOG_DEBUG, "lastlength, frags: %d, %d, %d\n",
fip->fi_lastlength, db_frag, fip->fi_lastlength, db_frag,
bytetoda(fsp, db_frag)); bytetoda(fsp, db_frag));
fflush(stdout);
#endif
bip->bi_size = fip->fi_lastlength; bip->bi_size = fip->fi_lastlength;
bp += fip->fi_lastlength; bp += fip->fi_lastlength;
psegaddr += db_frag; psegaddr += db_frag;
@ -464,9 +477,10 @@ add_inodes (fsp, bip, countp, sp, seg_buf, seg_addr)
bp = bip + *countp; bp = bip + *countp;
lfsp = &fsp->fi_lfs; lfsp = &fsp->fi_lfs;
#ifdef VERBOSE
(void) printf("INODES:\n"); if(debug > 1)
#endif syslog(LOG_DEBUG, "INODES:\n");
daddrp = (daddr_t *)((caddr_t)sp + LFS_SUMMARY_SIZE); daddrp = (daddr_t *)((caddr_t)sp + LFS_SUMMARY_SIZE);
for (i = 0; i < sp->ss_ninos; ++i) { for (i = 0; i < sp->ss_ninos; ++i) {
if (i % INOPB(lfsp) == 0) { if (i % INOPB(lfsp) == 0) {
@ -565,7 +579,7 @@ mmap_segment (fsp, segment, segbuf, use_mmap)
strcat(mntfromname, fsp->fi_statfsp->f_mntfromname+5); strcat(mntfromname, fsp->fi_statfsp->f_mntfromname+5);
if ((fid = open(mntfromname, O_RDONLY, (mode_t)0)) < 0) { if ((fid = open(mntfromname, O_RDONLY, (mode_t)0)) < 0) {
err(0, "mmap_segment: bad open"); syslog(LOG_WARNING,"mmap_segment: bad open: %m");
return (-1); return (-1);
} }
@ -573,30 +587,30 @@ mmap_segment (fsp, segment, segbuf, use_mmap)
*segbuf = mmap ((caddr_t)0, seg_size(lfsp), PROT_READ, *segbuf = mmap ((caddr_t)0, seg_size(lfsp), PROT_READ,
MAP_FILE|MAP_SHARED, fid, seg_byte); MAP_FILE|MAP_SHARED, fid, seg_byte);
if (*(long *)segbuf < 0) { if (*(long *)segbuf < 0) {
err(0, "mmap_segment: mmap failed"); syslog(LOG_WARNING,"mmap_segment: mmap failed: %m");
return (0); return (0);
} }
} else { } else {
#ifdef VERBOSE if(debug > 1)
printf("mmap_segment\tseg_daddr: %lu\tseg_size: %lu\tseg_offset: %qu\n", syslog(LOG_DEBUG, "mmap_segment\tseg_daddr: %lu\tseg_size: %lu\tseg_offset: %qu\n",
(u_long)seg_daddr, (u_long)ssize, seg_byte); (u_long)seg_daddr, (u_long)ssize, seg_byte);
#endif
/* malloc the space for the buffer */ /* malloc the space for the buffer */
*segbuf = malloc(ssize); *segbuf = malloc(ssize);
if (!*segbuf) { if (!*segbuf) {
err(0, "mmap_segment: malloc failed"); syslog(LOG_WARNING,"mmap_segment: malloc failed: %m");
return (0); return (0);
} }
/* read the segment data into the buffer */ /* read the segment data into the buffer */
if (lseek (fid, seg_byte, SEEK_SET) != seg_byte) { if (lseek (fid, seg_byte, SEEK_SET) != seg_byte) {
err (0, "mmap_segment: bad lseek"); syslog(LOG_WARNING,"mmap_segment: bad lseek: %m");
free(*segbuf); free(*segbuf);
return (-1); return (-1);
} }
if (read (fid, *segbuf, ssize) != ssize) { if (read (fid, *segbuf, ssize) != ssize) {
err (0, "mmap_segment: bad read"); syslog(LOG_WARNING,"mmap_segment: bad read: %m");
free(*segbuf); free(*segbuf);
return (-1); return (-1);
} }
@ -628,8 +642,8 @@ print_SEGSUM (lfsp, p)
{ {
if (p) if (p)
(void) dump_summary(lfsp, p, DUMP_ALL, NULL); (void) dump_summary(lfsp, p, DUMP_ALL, NULL);
else printf("0x0"); else
fflush(stdout); syslog(LOG_DEBUG, "0x0");
} }
int int

23
libexec/lfs_cleanerd/misc.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: misc.c,v 1.2 1997/10/07 13:39:59 mrg Exp $ */ /* $NetBSD: misc.c,v 1.3 1998/10/07 15:00:34 christos Exp $ */
/*- /*-
* Copyright (c) 1992, 1993 * Copyright (c) 1992, 1993
@ -38,7 +38,7 @@
#if 0 #if 0
static char sccsid[] = "from: @(#)misc.c 8.1 (Berkeley) 6/4/93"; static char sccsid[] = "from: @(#)misc.c 8.1 (Berkeley) 6/4/93";
#else #else
__RCSID("$NetBSD: misc.c,v 1.2 1997/10/07 13:39:59 mrg Exp $"); __RCSID("$NetBSD: misc.c,v 1.3 1998/10/07 15:00:34 christos Exp $");
#endif #endif
#endif /* not lint */ #endif /* not lint */
@ -53,6 +53,7 @@ __RCSID("$NetBSD: misc.c,v 1.2 1997/10/07 13:39:59 mrg Exp $");
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <syslog.h>
#include "clean.h" #include "clean.h"
@ -67,10 +68,16 @@ get(fd, off, p, len)
{ {
int rbytes; int rbytes;
if (lseek(fd, off, SEEK_SET) < 0) if (lseek(fd, off, SEEK_SET) < 0) {
err(1, "%s: %s", special, strerror(errno)); syslog(LOG_ERR, "Exiting: %s: lseek: %m", special);
if ((rbytes = read(fd, p, len)) < 0) exit(1);
err(1, "%s: %s", special, strerror(errno)); }
if (rbytes != len) if ((rbytes = read(fd, p, len)) < 0) {
err(1, "%s: short read (%d, not %d)", special, rbytes, len); syslog(LOG_ERR, "Exiting: %s: read: %m", special);
exit(1);
}
if (rbytes != len) {
syslog(LOG_ERR, "Exiting: %s: short read (%d, not %d)", special, rbytes, len);
exit(1);
}
} }

71
libexec/lfs_cleanerd/print.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: print.c,v 1.4 1998/09/11 21:21:29 pk Exp $ */ /* $NetBSD: print.c,v 1.5 1998/10/07 15:00:34 christos Exp $ */
/*- /*-
* Copyright (c) 1992, 1993 * Copyright (c) 1992, 1993
@ -38,7 +38,7 @@
#if 0 #if 0
static char sccsid[] = "from: @(#)print.c 8.1 (Berkeley) 6/4/93"; static char sccsid[] = "from: @(#)print.c 8.1 (Berkeley) 6/4/93";
#else #else
__RCSID("$NetBSD: print.c,v 1.4 1998/09/11 21:21:29 pk Exp $"); __RCSID("$NetBSD: print.c,v 1.5 1998/10/07 15:00:34 christos Exp $");
#endif #endif
#endif /* not lint */ #endif /* not lint */
@ -53,8 +53,11 @@ __RCSID("$NetBSD: print.c,v 1.4 1998/09/11 21:21:29 pk Exp $");
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <time.h> #include <time.h>
#include <syslog.h>
#include "clean.h" #include "clean.h"
extern int debug;
extern u_long cksum __P((void *, size_t)); /* XXX */ extern u_long cksum __P((void *, size_t)); /* XXX */
/* /*
@ -80,48 +83,40 @@ dump_summary(lfsp, sp, flags, iaddrp)
return(-1); return(-1);
if (flags & DUMP_SUM_HEADER) { if (flags & DUMP_SUM_HEADER) {
(void)printf(" %s0x%X\t%s%d\t%s%d\n %s0x%X\t%s0x%X", syslog(LOG_DEBUG, " %s0x%X\t%s%d\t%s%d\n %s0x%X\t%s0x%X",
"next ", sp->ss_next, "next ", sp->ss_next,
"nfinfo ", sp->ss_nfinfo, "nfinfo ", sp->ss_nfinfo,
"ninos ", sp->ss_ninos, "ninos ", sp->ss_ninos,
"sumsum ", sp->ss_sumsum, "sumsum ", sp->ss_sumsum,
"datasum ", sp->ss_datasum ); "datasum ", sp->ss_datasum );
(void)printf("\tcreate %s", ctime((time_t *)&sp->ss_create)); syslog(LOG_DEBUG, "\tcreate %s", ctime((time_t *)&sp->ss_create));
} }
numblocks = (sp->ss_ninos + INOPB(lfsp) - 1) / INOPB(lfsp); numblocks = (sp->ss_ninos + INOPB(lfsp) - 1) / INOPB(lfsp);
/* Dump out inode disk addresses */ /* Dump out inode disk addresses */
if (flags & DUMP_INODE_ADDRS) if (flags & DUMP_INODE_ADDRS)
printf(" Inode addresses:"); syslog(LOG_DEBUG, " Inode addresses:");
dp = (daddr_t *)((caddr_t)sp + LFS_SUMMARY_SIZE); dp = (daddr_t *)((caddr_t)sp + LFS_SUMMARY_SIZE);
for (--dp, i = 0; i < sp->ss_ninos; --dp) for (--dp, i = 0; i < sp->ss_ninos; --dp)
if (flags & DUMP_INODE_ADDRS) { if (flags & DUMP_INODE_ADDRS) {
(void)printf("\t0x%lx", (u_long)*dp); syslog(LOG_DEBUG, "\t0x%lx", (u_long)*dp);
if (++i % 7 == 0)
(void)printf("\n");
} else } else
++i; ++i;
if (iaddrp) if (iaddrp)
*iaddrp = ++dp; *iaddrp = ++dp;
if (flags & DUMP_INODE_ADDRS)
printf("\n");
for (fp = (FINFO *)(sp + 1), i = 0; i < sp->ss_nfinfo; ++i) { for (fp = (FINFO *)(sp + 1), i = 0; i < sp->ss_nfinfo; ++i) {
numblocks += fp->fi_nblocks; numblocks += fp->fi_nblocks;
if (flags & DUMP_FINFOS) { if (flags & DUMP_FINFOS) {
(void)printf(" %s%d version %d nblocks %d\n", syslog(LOG_DEBUG, " %s%d version %d nblocks %d\n",
"FINFO for inode: ", fp->fi_ino, "FINFO for inode: ", fp->fi_ino,
fp->fi_version, fp->fi_nblocks); fp->fi_version, fp->fi_nblocks);
dp = &(fp->fi_blocks[0]); dp = &(fp->fi_blocks[0]);
for (j = 0; j < fp->fi_nblocks; j++, dp++) { for (j = 0; j < fp->fi_nblocks; j++, dp++) {
(void)printf("\t%d", *dp); syslog(LOG_DEBUG, "\t%d", *dp);
if ((j % 8) == 7)
(void)printf("\n");
} }
if ((j % 8) != 0)
(void)printf("\n");
fp = (FINFO *)dp; fp = (FINFO *)dp;
} else { } else {
fp = (FINFO *)(&fp->fi_blocks[fp->fi_nblocks]); fp = (FINFO *)(&fp->fi_blocks[fp->fi_nblocks]);
@ -130,15 +125,17 @@ dump_summary(lfsp, sp, flags, iaddrp)
return (numblocks); return (numblocks);
} }
#ifdef VERBOSE
void void
dump_cleaner_info(ipage) dump_cleaner_info(ipage)
void *ipage; void *ipage;
{ {
CLEANERINFO *cip; CLEANERINFO *cip;
if(debug <= 1)
return;
cip = (CLEANERINFO *)ipage; cip = (CLEANERINFO *)ipage;
(void)printf("segments clean\t%d\tsegments dirty\t%d\n\n", syslog(LOG_DEBUG,"segments clean\t%d\tsegments dirty\t%d\n\n",
cip->clean, cip->dirty); cip->clean, cip->dirty);
} }
@ -148,81 +145,77 @@ dump_super(lfsp)
{ {
int i; int i;
(void)printf("%s0x%X\t%s0x%X\t%s%d\t%s%d\n", syslog(LOG_DEBUG,"%s0x%X\t%s0x%X\t%s%d\t%s%d\n",
"magic ", lfsp->lfs_magic, "magic ", lfsp->lfs_magic,
"version ", lfsp->lfs_version, "version ", lfsp->lfs_version,
"size ", lfsp->lfs_size, "size ", lfsp->lfs_size,
"ssize ", lfsp->lfs_ssize); "ssize ", lfsp->lfs_ssize);
(void)printf("%s%d\t\t%s%d\t%s%d\t%s%d\n", syslog(LOG_DEBUG, "%s%d\t\t%s%d\t%s%d\t%s%d\n",
"dsize ", lfsp->lfs_dsize, "dsize ", lfsp->lfs_dsize,
"bsize ", lfsp->lfs_bsize, "bsize ", lfsp->lfs_bsize,
"fsize ", lfsp->lfs_fsize, "fsize ", lfsp->lfs_fsize,
"frag ", lfsp->lfs_frag); "frag ", lfsp->lfs_frag);
(void)printf("%s%d\t\t%s%d\t%s%d\t%s%d\n", syslog(LOG_DEBUG, "%s%d\t\t%s%d\t%s%d\t%s%d\n",
"minfree ", lfsp->lfs_minfree, "minfree ", lfsp->lfs_minfree,
"inopb ", lfsp->lfs_inopb, "inopb ", lfsp->lfs_inopb,
"ifpb ", lfsp->lfs_ifpb, "ifpb ", lfsp->lfs_ifpb,
"nindir ", lfsp->lfs_nindir); "nindir ", lfsp->lfs_nindir);
(void)printf("%s%d\t\t%s%d\t%s%d\t%s%d\n", syslog(LOG_DEBUG, "%s%d\t\t%s%d\t%s%d\t%s%d\n",
"nseg ", lfsp->lfs_nseg, "nseg ", lfsp->lfs_nseg,
"nspf ", lfsp->lfs_nspf, "nspf ", lfsp->lfs_nspf,
"cleansz ", lfsp->lfs_cleansz, "cleansz ", lfsp->lfs_cleansz,
"segtabsz ", lfsp->lfs_segtabsz); "segtabsz ", lfsp->lfs_segtabsz);
(void)printf("%s0x%X\t%s%d\t%s0x%qX\t%s%lu\n", syslog(LOG_DEBUG, "%s0x%X\t%s%d\t%s0x%qX\t%s%lu\n",
"segmask ", lfsp->lfs_segmask, "segmask ", lfsp->lfs_segmask,
"segshift ", lfsp->lfs_segshift, "segshift ", lfsp->lfs_segshift,
"bmask ", (u_quad_t)lfsp->lfs_bmask, "bmask ", (u_quad_t)lfsp->lfs_bmask,
"bshift ", (u_long)lfsp->lfs_bshift); "bshift ", (u_long)lfsp->lfs_bshift);
(void)printf("%s0x%qX\t\t%s%lu\t%s0x%qX\t%s%lu\n", syslog(LOG_DEBUG, "%s0x%qX\t\t%s%lu\t%s0x%qX\t%s%lu\n",
"ffmask ", (u_quad_t)lfsp->lfs_ffmask, "ffmask ", (u_quad_t)lfsp->lfs_ffmask,
"ffshift ", (u_long)lfsp->lfs_ffshift, "ffshift ", (u_long)lfsp->lfs_ffshift,
"fbmask ", (u_quad_t)lfsp->lfs_fbmask, "fbmask ", (u_quad_t)lfsp->lfs_fbmask,
"fbshift ", (u_long)lfsp->lfs_fbshift); "fbshift ", (u_long)lfsp->lfs_fbshift);
(void)printf("%s%d\t\t%s0x%X\t%s0x%qx\n", syslog(LOG_DEBUG, "%s%d\t\t%s0x%X\t%s0x%qx\n",
"fsbtodb ", lfsp->lfs_fsbtodb, "fsbtodb ", lfsp->lfs_fsbtodb,
"cksum ", lfsp->lfs_cksum, "cksum ", lfsp->lfs_cksum,
"maxfilesize ", lfsp->lfs_maxfilesize); "maxfilesize ", lfsp->lfs_maxfilesize);
(void)printf("Superblock disk addresses:\t"); syslog(LOG_DEBUG, "Superblock disk addresses:\t");
for (i = 0; i < LFS_MAXNUMSB; i++) { for (i = 0; i < LFS_MAXNUMSB; i++) {
(void)printf(" 0x%X", lfsp->lfs_sboffs[i]); syslog(LOG_DEBUG, " 0x%X", lfsp->lfs_sboffs[i]);
if ( i == (LFS_MAXNUMSB >> 1))
(void)printf("\n\t\t\t\t");
} }
(void)printf("\n");
(void)printf("Checkpoint Info\n"); syslog(LOG_DEBUG, "Checkpoint Info\n");
(void)printf("%s%d\t%s0x%X\t%s%d\n", syslog(LOG_DEBUG, "%s%d\t%s0x%X\t%s%d\n",
"free ", lfsp->lfs_free, "free ", lfsp->lfs_free,
"idaddr ", lfsp->lfs_idaddr, "idaddr ", lfsp->lfs_idaddr,
"ifile ", lfsp->lfs_ifile); "ifile ", lfsp->lfs_ifile);
(void)printf("%s%d\t%s%d\t%s%d\n", syslog(LOG_DEBUG, "%s%d\t%s%d\t%s%d\n",
"bfree ", lfsp->lfs_bfree, "bfree ", lfsp->lfs_bfree,
"avail ", lfsp->lfs_avail, "avail ", lfsp->lfs_avail,
"uinodes ", lfsp->lfs_uinodes); "uinodes ", lfsp->lfs_uinodes);
(void)printf("%s%d\t%s0x%X\t%s0x%X\n%s0x%X\t%s0x%X\t", syslog(LOG_DEBUG, "%s%d\t%s0x%X\t%s0x%X\n%s0x%X\t%s0x%X\t",
"nfiles ", lfsp->lfs_nfiles, "nfiles ", lfsp->lfs_nfiles,
"lastseg ", lfsp->lfs_lastseg, "lastseg ", lfsp->lfs_lastseg,
"nextseg ", lfsp->lfs_nextseg, "nextseg ", lfsp->lfs_nextseg,
"curseg ", lfsp->lfs_curseg, "curseg ", lfsp->lfs_curseg,
"offset ", lfsp->lfs_offset); "offset ", lfsp->lfs_offset);
(void)printf("tstamp %s", ctime((time_t *)&lfsp->lfs_tstamp)); syslog(LOG_DEBUG, "tstamp %s", ctime((time_t *)&lfsp->lfs_tstamp));
(void)printf("\nIn-Memory Information\n"); syslog(LOG_DEBUG, "\nIn-Memory Information\n");
(void)printf("%s%d\t%s0x%X\t%s%d\t%s%d\t%s%d\n", syslog(LOG_DEBUG, "%s%d\t%s0x%X\t%s%d\t%s%d\t%s%d\n",
"seglock ", lfsp->lfs_seglock, "seglock ", lfsp->lfs_seglock,
"iocount ", lfsp->lfs_iocount, "iocount ", lfsp->lfs_iocount,
"writer ", lfsp->lfs_writer, "writer ", lfsp->lfs_writer,
"dirops ", lfsp->lfs_dirops, "dirops ", lfsp->lfs_dirops,
"doifile ", lfsp->lfs_doifile ); "doifile ", lfsp->lfs_doifile );
(void)printf("%s%d\t%s%d\t%s0x%X\t%s%d\n", syslog(LOG_DEBUG, "%s%d\t%s%d\t%s0x%X\t%s%d\n",
"nactive ", lfsp->lfs_nactive, "nactive ", lfsp->lfs_nactive,
"fmod ", lfsp->lfs_fmod, "fmod ", lfsp->lfs_fmod,
"clean ", lfsp->lfs_clean, "clean ", lfsp->lfs_clean,
"ronly ", lfsp->lfs_ronly); "ronly ", lfsp->lfs_ronly);
} }
#endif /* VERBOSE */