#include <sys/param.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <sys/vnode.h>
#include <sys/stat.h>
#include <sys/mount.h>

#include <ufs/ufs/dinode.h>
#include <ufs/lfs/lfs.h>
#include <ufs/lfs/lfs_extern.h>

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include "clean.h"

/*
 * fs_getmntinfo:
 *
 *    This function will get information on all mounted file systems
 * of a given type.
 */
int
fs_getmntinfo(buf, type)
	struct	statfs	**buf;
	int	type;
{
	int	i;
	int	count;
	int	tcount;
	struct	statfs	*tstatfsp;

	tcount = getmntinfo(&tstatfsp, 0);

	if (tcount < 0) {
		perror ("fs_getmntinfo: getmntinfo failed");
		return -1;
	}

	for (count = 0, i = 0 ; i < tcount ; i ++)
		if (type == 0 || tstatfsp[i].f_type == type)
			++ count;

	if (count > 0) {
		*buf = (struct statfs *)
			malloc(count*sizeof(struct statfs));
		if (*buf == 0) { perror ("fs_getmntinfo: out of space"); exit (1); }
		for (i = 0, count = 0 ; i < tcount ; i ++) {
			if (type == 0 || tstatfsp[i].f_type == type) {
				(*buf)[count] = tstatfsp[i];
				++count;
			}
		}
		return count;
	}
	return 0;
}

/*
 * get_fs_info:
 *
 * get all the information available on a file system
 */
int
get_fs_info (lstatfsp, fspp, count)
	struct  statfs  *lstatfsp;	/* IN: array of statfs structs */
	FS_INFO **fspp;			/* OUT: resulting array of FS_INFOs */
	int	count;			/* IN: number of file systems */
{
	int	i;
	caddr_t	ifp;
	FS_INFO	*fsp;
	
	*fspp = (FS_INFO *)malloc(count * sizeof(FS_INFO));

	for (i = 0 ; i < count ; i++) {
		fsp = *fspp + i;
		statfsp = lstatfsp + i;
		lfsp = (struct lfs *)malloc (LFS_SBPAD);
		if (get_superblock (fsp, lfsp) < 0) {
			perror("get_fs_info: get_superblock failed");
			return -1;
		}
		fsp->fi_daddr_shift = lfsp->lfs_bshift - lfsp->lfs_fsbtodb;
		if (get_ifile (fsp) < 0) {
			perror("get_fs_info: get_ifile failed");
			return -1;
		}
	}
	return 0;
}

/* this is needed temporarily, because of the bug in mmap'ed files */
void
free_fs_info (fsp, count)
	FS_INFO *fsp;	/* IN: array of fs_infos we will dispose of */
	int	count;	/* IN: number of file systems */
{
	int	i;
	caddr_t	fsp_base = (caddr_t)fsp;
	
	for (i = 0 ; i < count ; i++, fsp++) {
		/* free superblock */
		free (lfsp);
		/* sdp points to the beginning of the ifile area */
#ifndef MMAP_WORKS
		free (cip);
#else
		if (munmap (cip, ifile_length) < 0) {
			perror("free_fs_info: munmap failed\n");
		}
#endif /* MMAP_WORKS */
	}
	
	free (fsp_base);
}

/* 
 * get_superblock: 
 *    gets the superblock from disk (possibly in face of errors) 
 */
int
get_superblock (fsp, sbp)
	FS_INFO *fsp;	/* IN: array of fs_infos we will dispose of */
	struct	lfs	*sbp;
{
        int 	fid;
	char	mntfromname[MNAMELEN+1];

	strcpy(mntfromname, "/dev/r");
	strcat(mntfromname, statfsp->f_mntfromname+5);

	if ((fid = open(mntfromname, O_RDONLY, (mode_t)0)) < 0) {
		perror("get_superblock: bad open");
		return -1;
	}

	if(lseek (fid, LFS_LABELPAD, SEEK_SET) != LFS_LABELPAD) {
		perror("get_superblock: bad seek");
		return -1;
	}
	if(read (fid, (char *)sbp, LFS_SBPAD) != LFS_SBPAD) {
		perror("get_superblock: bad read");
		return -1;
	}
	close (fid);
	
	return 0;
}

/* 
 * get_ifile: 
 *    This function will map the ifile into memory.  It returns
 * NULL on failure.
 */
int
get_ifile (fsp)
	FS_INFO	*fsp;
{
	int	fid;
	int	count;
	caddr_t	ifp = NULL;
	char    *ifile_name;
	struct	stat file_stat;

	ifile_name = (char *)
		malloc(strlen(statfsp->f_mntonname)+strlen(IFILE_NAME)+2);
	strcpy(ifile_name, statfsp->f_mntonname);
	strcat(ifile_name, "/");
	strcat(ifile_name, IFILE_NAME);

	if ((fid = open(ifile_name, O_RDWR, (mode_t)0)) < 0) {
		perror("get_ifile: bad open");
		return -1;
	}

	if(fstat (fid, &file_stat)) {
		perror("get_ifile: fstat failed");
		return -1;
	}
	ifile_length = file_stat.st_size;

	/* get the ifile */
#ifndef MMAP_WORKS
	ifp = (caddr_t)malloc (ifile_length);
	if (ifp == 0) {
		perror ("get_ifile: malloc failed, out of memory?"); 
		return -1;
	}
	count = read (fid, ifp, ifile_length);

	if (count != ifile_length) {
		perror("get_ifile: bad ifile read"); 
		return -1;
	}
#else	/* MMAP_WORKS */
	ifp = mmap ((caddr_t)0, ifile_length, PROT_READ|PROT_WRITE,
		MAP_FILE|MAP_SHARED, fid, (off_t)0);
	if (ifp < 0) {
		perror("get_ifile: mmap failed");
		return NULL;
	}
#endif	/* MMAP_WORKS */

	close (fid);

	cip = (CLEANERINFO*)ifp;
	segusep = (SEGUSE*)(ifp + CLEANSIZE(lfsp));
	ifilep  = (IFILE*)(ifp + CLEANSIZE(lfsp) + SEGTABSIZE(lfsp));
	/* # of bytes in ifile table */
	ifile_count = ifile_length - (CLEANSIZE(lfsp) + SEGTABSIZE(lfsp));
	/* # of ifile entries in ifile table */
	ifile_count = (ifile_count / lfsp->lfs_bsize) * lfsp->lfs_ifpb;
	free (ifile_name);
	return 0;
}


/*
 * segmapv:
 *
 *   This function will scan a segment and return a list of
 * <inode, blocknum> pairs which indicate which blocks were
 * contained as live data within the segment at some point
 * (it may have "died" since then).  Any given pair will be 
 * listed at most once.
 */
int 
lfs_segmapv(fsp, seg, seg_buf, blocks, bcount, inodes, icount)
	FS_INFO *fsp;		/* pointer to super block */
	int	seg;		/* the segment id */
	caddr_t	seg_buf;	/* the buffer containing the segment's data */
				/* OUT: array of block_info for live blocks */
	BLOCK_INFO	**blocks;
	int	*bcount;	/* OUT: number of active blocks in segment */
				/* OUT: array of inode_info for live inodes */
	INODE_INFO	**inodes;
	int	*icount;	/* OUT: number of active inodes in segment */
{
	caddr_t	s;
	caddr_t	endofseg;
	int	nextsum;
	u_long	sb_off;
	time_t	timestamp;
	
	*bcount = 0;
	*blocks = (BLOCK_INFO *)malloc (sizeof(BLOCK_INFO));
	
	*icount = 0;
	*inodes = (INODE_INFO *)malloc(sizeof(INODE_INFO));

	sb_off = (SEGUSE_ENTRY(lfsp, segusep, seg)->su_flags & SEGUSE_SUPERBLOCK) ?
		LFS_SBPAD : 0;

	for (s = seg_buf + sb_off, endofseg = seg_buf + seg_size(lfsp), 
	     timestamp = 0 ; 
	     s < endofseg ; 
	     s += pseg_size (fsp, (SEGSUM*)s)) {
		BLOCK_INFO	*pblocks;
		int		pbcount;
		INODE_INFO	*pinodes;
		int		picount;

#ifdef VERBOSE
		printf("lfs_segmapv: seg_buf = 0x%x, pseg_buf = 0x%x, offset = %lu (0x%x), pseg = \n\t",
			(u_int)seg_buf, (u_int)s, 
			(u_int)s - (u_int)seg_buf - (u_int)sb_off,
			(u_int)s - (u_int)seg_buf - (u_int)sb_off);
/* this can cause core dumps when printing an invalid segsum
 *		print_SEGSUM ((SEGSUM*)s);
 *		printf("\n");
 *		printf("pseg_size = %lu\n", pseg_size(fsp, (SEGSUM*)s));
 */
		fflush(stdout);
#endif /* VERBOSE */

		/* we have hit the end of the valid data */
		if (! pseg_valid (fsp, (SEGSUM*)s)) break;

		/* we have gone back in time and hit old data */
		if (timestamp > ((SEGSUM*)s)->ss_create) break;

		timestamp = ((SEGSUM*)s)->ss_create;

		/* get the block and inode list */
		pseg_blocks (fsp, seg, (SEGSUM*)s, seg_buf, 
			&pblocks, &pbcount);
		pseg_bjoin  (fsp, blocks, bcount, pblocks, pbcount);

		pseg_inodes (fsp, seg, (SEGSUM*)s, seg_buf, 
			&pinodes, &picount);
		pseg_ijoin  (fsp, inodes, icount, pinodes, picount);
		
		/* free the temporary tables */
		free (pblocks);
		free (pinodes);
	}
	
}

/* 
 * this will parse a partial segment and create a vector of block_info's
 * for live data and a vector of inode_info's for live inodes.  It will 
 * not include blocks or inodes from files with new version numbers.  
 */
void
pseg_blocks (fsp, seg, s, seg_buf, blocks, count)
	FS_INFO *fsp;		/* pointer to super block */
	int	seg;		/* the segment id */
	SEGSUM	*s;		/* (unvalidated) segsum pointer */
	caddr_t	seg_buf;	/* the buffer containing the segment's data */
				/* OUT: array of block_info for live blocks */
	BLOCK_INFO	**blocks;
	int	*count;		/* OUT: number of active blocks in segment */
{
	FINFO	**finfos;
	int	finfoc;
	int	blockc;
	int	i;
	int	j;
	int	ninob;		/* number of inode blocks passed */
	daddr_t	seg_daddr;
	daddr_t	*cur_iaddrp;	/* pointer to current inode block */
	u_long	offset;		/* the offset (in bytes) within the segment */

	*count = 0;
	*blocks = NULL;
	
	pseg_finfos (fsp, s, &finfos, &finfoc);

#ifdef VERBOSE
	for(i=0;i<finfoc;i++){print_FINFO(finfos[i]);printf("\n");fflush(stdout);}
	printf("pseg_blocks: finfoc = %d\n", finfoc);fflush(stdout);
#endif

	/* count how many blocks are held by live FINFO's */
	for (i = 0, blockc = 0 ; i < finfoc ; ++i)
		if (finfos[i]->fi_version == 
		    IFILE_ENTRY(lfsp, ifilep, finfos[i]->fi_ino)->if_version) 
			blockc += finfos[i]->fi_nblocks;

	if (finfoc == 0 || blockc == 0) return;
	
	ninob = 0;
	offset = LFS_SUMMARY_SIZE + ((u_int)s - (u_int)seg_buf) + 
		s->ss_next * datobyte(fsp, 1<<lfsp->lfs_bshift);
	cur_iaddrp = (daddr_t*)(s->ss_ninos == 0 ? 0 :
	    (char *)s + LFS_SUMMARY_SIZE - sizeof(daddr_t));
	seg_daddr = sntoda(lfsp, seg);
	*blocks = (BLOCK_INFO *)malloc (blockc*sizeof(BLOCK_INFO));

	for (i = 0 ; i < finfoc ; i ++) {
		FINFO		*f = finfos[i];

		if (f->fi_version != IFILE_ENTRY(lfsp, ifilep, f->fi_ino)->if_version) 
			continue;

#ifdef VERBOSE
		printf("finfo %d = ", i);
		print_FINFO(f);
		printf("\n");
		fflush(stdout);
		printf("IFILE entry for file %d = ", f->fi_ino);
		print_IFILE (IFILE_ENTRY(lfsp, ifilep, f->fi_ino));
		printf("\n");
		fflush(stdout);
#endif
		for (j = 0 ; j < finfos[i]->fi_nblocks ; j ++) {
			BLOCK_INFO	*b = &(*blocks)[*count];
		
			/*
			 * XXX: 
			 * this changes if we have variable size blocks
			 */
			for (;cur_iaddrp && 
			    seg_daddr + bytetoda(fsp, offset) == *cur_iaddrp; 
			    offset += datobyte(fsp, 1<<lfsp->lfs_bshift)) {
				if (ninob <= (s->ss_ninos + INOPB(lfsp) - 1) 
				    / INOPB(lfsp)) {
					++ninob;
					--cur_iaddrp;
				} else
					cur_iaddrp = NULL;
			}
			b->bi_inode = f->fi_ino;
			b->bi_lbn = f->fi_blocks[j];
			b->bi_daddr = seg_daddr + bytetoda(fsp, offset);
			b->bi_segcreate = s->ss_create;
			b->bi_bp = seg_buf + offset;
			
			(*count) ++;
			offset += blocksize(fsp, b->bi_lbn);
#ifdef VERBOSE
			printf("\tb[%d] = ", j);
			print_BLOCK_INFO(b);
			printf("\n");
			fflush(stdout);
#endif
		}
	}
	free (finfos);
}

void
pseg_inodes (fsp, seg, s, seg_buf, inodes, count)
	FS_INFO *fsp;		/* pointer to super block */
	int	seg;		/* the segment id */
	SEGSUM	*s;		/* (unvalidated) segsum pointer */
	caddr_t	seg_buf;	/* the buffer containing the segment's data */
				/* OUT: array of inode_info for live inodes */
	INODE_INFO	**inodes;
	int	*count;		/* OUT: number of active inodes in segment */
{
	int	i;
	ino_t	inum;
	daddr_t	*daddrp, i_daddr, seg_daddr;
	struct	dinode	*di;
	
	*count = 0;
	*inodes = NULL;

	if (s->ss_ninos <= 0) return;
	
	*inodes = (INODE_INFO *)malloc (s->ss_ninos * sizeof(INODE_INFO));

	seg_daddr = sntoda(lfsp, seg);

#ifdef VERBOSE
	printf("pseg_inodes:\n");
	print_SEGSUM(s);
	printf("\n");
	fflush(stdout);
#endif

	daddrp = (daddr_t *)((caddr_t)s + LFS_SUMMARY_SIZE);

	for (i = 0 ; i < s->ss_ninos ; ++i) {

		if (i % INOPB(lfsp) == 0) {
			i_daddr = *--daddrp;
			if (datosn(lfsp, i_daddr) != seg ||
			    datobyte(fsp, i_daddr - seg_daddr) > seg_size(lfsp)) {
				printf("pseg_inodes: bad i_daddr\n");
				print_SEGSUM(s);
				printf("\n");
				fflush(stdout);
				printf("i_daddr = %d, seg_daddr = %d, offset = %d, pseg_size = %d\n",
				    i_daddr, seg_daddr, i_daddr - seg_daddr, 
				    pseg_size(fsp, (SEGSUM*)s));
				fflush(stdout);
			}
			di = (struct dinode *)
				(seg_buf + datobyte(fsp, i_daddr - seg_daddr));
		} else 
			++di;
		
		inum = di->di_inum;

		if (IFILE_ENTRY(lfsp, ifilep, inum)->if_daddr == i_daddr) {
			(*inodes)[*count].ii_inode = inum;
			(*inodes)[*count].ii_daddr = i_daddr;
			(*inodes)[*count].ii_segcreate = s->ss_create;
			(*inodes)[*count].ii_dinode = di;
		
			(*count) ++;
		} 
	}
}

/* return the size of the partial segment in bytes. */
u_long
pseg_size (fsp, s)
	FS_INFO *fsp;   /* pointer to super block */
	SEGSUM	*s;	/* segsum pointer */
{
	int	i;
	int	j;
	FINFO	**finfos;
	int	finfoc;
	u_long	size = LFS_SUMMARY_SIZE;
	
	pseg_finfos (fsp, s, &finfos, &finfoc);
	for (i = 0 ; i < finfoc ; i ++) 
	for (j = 0 ; j < finfos[i]->fi_nblocks ; j ++) 
		size += blocksize(fsp, finfos[i]->fi_blocks[j]);

	/* inodes are packed INOPB inodes per block */
	/* there can be unused space in an inode block */
	size += datobyte(fsp, fsbtodb(lfsp,1)*((s->ss_ninos+INOPB(lfsp)-1)/INOPB(lfsp)));

	return size;
}

/* 
 * join block list b with list a (eliminating duplicates), leaving result
 * in list a.
 */
void
pseg_bjoin (fsp, ablocks, acount, bblocks, bcount)
	FS_INFO *fsp;   /* pointer to file system info */
				/* INOUT: array of live blocks block_info */
	BLOCK_INFO	**ablocks;
	int	*acount;	/* INOUT: number of active blocks */
				/* IN: array of live blocks block_info */
	BLOCK_INFO	*bblocks;
	int	bcount;	/* IN: number of active blocks */
{
	int	i;
	int	j;
	BLOCK_INFO	*abp;
	BLOCK_INFO	*bbp;

#ifdef VERBOSE
	printf("pseg_bjoin: *acount = %d, bcount = %d\n", *acount, bcount);
/**/
	printf("ablocks = \n");
	for(i=0;i<*acount;i++){print_BLOCK_INFO((*ablocks)+i); printf("\n");}
/**/
	printf("bblocks = \n");
	for(i=0;i<bcount;i++){print_BLOCK_INFO(bblocks+i); printf("\n");}
/**/
	fflush(stdout);
/**/
#endif

	for (i = 0, bbp = bblocks ; i < bcount ; ++i, ++bbp) {
		for (j = 0, abp = *ablocks ; j < *acount ; ++j, ++abp) {
			if (abp->bi_inode == bbp->bi_inode
				&& abp->bi_lbn == bbp->bi_lbn) {
				/* the data is for the same file and logical block */
				if (abp->bi_segcreate < bbp->bi_segcreate)
					*abp = *bbp;
				break;
			}
		}
		if (j == *acount) {
			/* this is a block we haven't seen before */
			*ablocks = (BLOCK_INFO*)
				realloc (*ablocks, sizeof(BLOCK_INFO)*(*acount + 1));
			(*ablocks)[*acount] = *bbp;
			(*acount) ++;
		}
	}
}

/* 
 * join block list b with list a (eliminating duplicates), leaving result
 * in list a.
 */
void
pseg_ijoin (fsp, ainodes, acount, binodes, bcount)
	FS_INFO *fsp;   /* pointer to file system info */
				/* INOUT: array of live inodes inode_info */
	INODE_INFO	**ainodes;
	int	*acount;	/* INOUT: number of active inodes */
				/* IN: array of live inodes inode_info */
	INODE_INFO	*binodes;
	int	bcount;		/* IN: number of active inodes */
{
	int	i;
	int	j;
	daddr_t	daddr;
	INODE_INFO	*aip;
	INODE_INFO	*bip;

	/* we assume that we have no duplicate live inodes on "a" and "b" */
	
	/* eliminate dead inodes from "a" */
	for (i = 0, aip = *ainodes ; i < *acount ; ++aip ) {
		daddr = IFILE_ENTRY(lfsp, ifilep, aip->ii_inode)->if_daddr;
		if (daddr != aip->ii_daddr) 
			*aip = (*ainodes)[--(*acount)];
		else 	i++;
	}

	/* eliminate dead inodes from "b" */
	for (i = 0, bip = binodes ; i < bcount ; ++bip) {
		daddr = IFILE_ENTRY(lfsp, ifilep, bip->ii_inode)->if_daddr;
		if (daddr != bip->ii_daddr) {
			/* don't really need to do this, only we don't want
			   to lose any inodes, just in case */
			INODE_INFO	tmp;
			tmp = *bip;
			*bip = binodes[bcount];
			binodes[bcount] = tmp;
			bcount --;
		}
		else	i++;
	}
	/* append "b" to "a" */
	if (bcount > 0) {
		*ainodes = (INODE_INFO *)realloc ((void *)*ainodes,
			(*acount + bcount + 1)*sizeof(INODE_INFO));
		for (i = 0 ; i < bcount ; i ++)
			(*ainodes)[(*acount)++] = binodes[i];
	}
}

/* is the segsum block valid? return TRUE if it is, FALSE otherwise */
int 
segsum_valid (fsp, ssp)
	FS_INFO *fsp;   /* pointer to file system info */
	SEGSUM	*ssp;	/* pointer to segment summary block */
{
	u_long	sumsum;

	/* check segsum block checksum */
	sumsum = cksum(&ssp->ss_datasum, 
	    LFS_SUMMARY_SIZE - sizeof(ssp->ss_sumsum));

	if (sumsum != ssp->ss_sumsum) return FALSE;
	
	return TRUE;
}

/*
 * pseg_valid:
 *
 * returns 1 if the partial segment is valid, and 0 if it is invalid.
 * it uses the checksums to verify validity.
 */	 
int
pseg_valid (fsp, ssp)
	FS_INFO *fsp;   /* pointer to file system info */
	SEGSUM	*ssp;	/* pointer to segment summary block */
{
	u_long	datasum;
	u_long	size;
	int	nblocks;
	int	i;
	u_long	*datap;
	caddr_t	p;

	/* check segsum block checksum */
	if (segsum_valid (fsp, ssp) == FALSE) return FALSE;

	return TRUE;
		
	/* check data/inode block(s) checksum too... */
	size = pseg_size (fsp, ssp);
	nblocks = size/fsbtodb(lfsp, 1);
	datap = (u_long*)malloc(sizeof(u_long)*nblocks);
	p = (caddr_t)ssp + LFS_SUMMARY_SIZE;
	for (i = 0 ; i < nblocks ; i ++) {
		datap[i] = *((u_long *)p);
		p += lfsp->lfs_bsize;
	}
	datasum = cksum ((void *)datap, nblocks*sizeof(u_long));
	if (datasum != ssp->ss_datasum) return FALSE;
	
	return TRUE;
}

/* get array of FINFO pointers for partial segment */
void
pseg_finfos (fsp, ssp, finfos, count)
	FS_INFO	*fsp;   /* pointer to file system info */
	SEGSUM	*ssp;	/* pointer to segment summary block */
	FINFO	***finfos;	/* OUT: return an array of FINFO pointers */
	int	*count;		/* OUT: return size of array */
{
	caddr_t	p = (caddr_t)ssp + sizeof(SEGSUM);
	int	i;
	FINFO	*fip;
	
	*count = 0;
	*finfos = NULL;

	if (ssp->ss_nfinfo > 0)
		*finfos = (FINFO**)malloc (ssp->ss_nfinfo*sizeof(FINFO*));

	for (i = 0 ; i < ssp->ss_nfinfo ; i ++) {
		fip = (FINFO *)p;
		(*finfos)[*count] = fip;
		(*count) ++;
		p += finfo_size (fip);
	}
}

/*
 * blocksize:
 *
 * returns the size (in bytes) of a (logical) block.
 * this is used because lfs uses different block sizes, depending
 * on the logical # of the block.  Lfs uses various sizes so
 * it doesn't need fragments.
 */ 
u_long
blocksize (fsp, index)
	FS_INFO *fsp;   /* pointer to file system info */
	int	index;	/* logical block # w/in file */
{
	return lfsp->lfs_bsize;	/* XXX: blocksize might depend on
					the logical block number */
}

/*
 * finfo_size
 *
 * returns the size in bytes of an FINFO structure 
 */
u_long
finfo_size (finfop)
	FINFO	*finfop;
{
	return sizeof(FINFO) + sizeof(long)*(finfop->fi_nblocks-1);
}
	

/* #define MMAP_SEGMENT */
/* 
 * read a segment into a memory buffer
 */
int
mmap_segment (fsp, segment, seg_buf)
	FS_INFO	*fsp;		/* file system information */
	int	segment;	/* the index of the segment to be cleaned */
	caddr_t	*seg_buf;	/* pointer to buffer area */
{
	off_t	seg_daddr;	/* base disk address of segment */
	int	fid;		/* fildes for file system device */
	char	mntfromname[MNAMELEN+2];

	/* get the disk address of the beginning of the segment */
	seg_daddr = sntoda(lfsp, segment);

	strcpy(mntfromname, "/dev/r");
	strcat(mntfromname, statfsp->f_mntfromname+5);

	if ((fid = open(mntfromname, O_RDONLY, (mode_t)0)) < 0) {
		perror("mmap_segment: bad open");
		return -1;
	}

#ifdef MMAP_SEGMENT
	*seg_buf = mmap ((caddr_t)0, seg_size(lfsp), PROT_READ,
		MAP_FILE, fid, (off_t)datobyte(fsp, seg_daddr));
	if ((long)*seg_buf < 0) {
		perror("mmap_segment: mmap failed");
		return NULL;
	}
#else /* MMAP_SEGMENT */
	printf("mmap_segment: seg_daddr = %lu, seg_size = %lu, seg_offset = %lu\n", 
		seg_daddr, seg_size(lfsp), datobyte(fsp, seg_daddr));
	/* malloc the space for the buffer */
	*seg_buf = (caddr_t)malloc(seg_size(lfsp));

	/* read the segment data into the buffer */
	if (datobyte(fsp, seg_daddr) != lseek (fid, datobyte(fsp, seg_daddr), SEEK_SET)) {
		perror ("mmap_segment: bad lseek");
		return -1;
	}
	
	if (seg_size(lfsp) != read (fid, *seg_buf, seg_size(lfsp))) {
		perror ("mmap_segment: bad read");
		return -1;
	}
#endif /* MMAP_SEGMENT */
	close (fid);

	return 0;
}

void
munmap_segment (fsp, seg_buf)
	FS_INFO	*fsp;		/* file system information */
	caddr_t	seg_buf;	/* pointer to buffer area */
{
#ifdef MMAP_SEGMENT
	munmap (seg_buf, seg_size(lfsp));
#else /* MMAP_SEGMENT */
	free (seg_buf);
#endif /* MMAP_SEGMENT */
}


/*
 * USEFUL DEBUGGING TOOLS:
 */

void
print_IFILE (p)
	IFILE	*p;
{
	if (p) {
		if (p->if_daddr == 0) 
			printf("{free, if_version=%lu, if_nextfree=%lu}",
				p->if_version, p->if_nextfree);
		else
			printf("{if_version=%lu, if_daddr=%lu}", 
				p->if_version, p->if_daddr);
	}
	else printf("0x0");
	fflush(stdout);
}

void
print_SEGUSE (p)
	SEGUSE	*p;
{
	if (p) {
		printf("{su_nbytes=%lu, su_flags=%c%c%c, su_lastmod=",
			p->su_nbytes, 
			((p->su_flags & SEGUSE_DIRTY) ? 'D' : 'C'),
			((p->su_flags & SEGUSE_ACTIVE) ? 'A' : ' '),
			((p->su_flags & SEGUSE_SUPERBLOCK) ? 'S' : ' '));
			print_time_t(p->su_lastmod);
			printf("}");
	}
	else 
		printf("0x0");
	fflush(stdout);
}

void
print_CLEANERINFO (p)
	CLEANERINFO	*p;
{
	if (p) printf("{clean=%lu, dirty=%lu}", p->clean, p->dirty);
	else printf("0x0");
	fflush(stdout);
}

void
print_SEGSUM (p)
	SEGSUM	*p;
{
	if (p) {
		printf("{ss_sumsum=%lu, ss_datasum=%lu, ss_next=%lu, ",
			p->ss_sumsum, p->ss_datasum, p->ss_next);
		printf("ss_create=%lu, ss_nfinfo=%lu, ss_ninos=%lu",
			p->ss_create, p->ss_nfinfo, p->ss_ninos);
		printf("}");
	}
	else printf("0x0");
	fflush(stdout);
}

void
print_time_t (t)
	time_t	t;
{
	char temp[128];
	int len;

	strcpy (temp, ctime(&t));
	len = strlen(temp);
	if (temp[len-1] == '\n') temp[len-1] = 0;
	printf("%s", temp);
	fflush(stdout);
}

void
print_FINFO (p)
	FINFO	*p;
{
	int i;

	if (p) {
		printf("{fi_nblocks=%lu, fi_version=%lu, fi_ino=%lu, fi_blocks={",
			p->fi_nblocks, p->fi_version, p->fi_ino);
		for (i = 0 ; i < p->fi_nblocks ; i ++) {
			if (i > 0) printf(", ");
			printf("%ld", p->fi_blocks[i]);
		}
		printf("}}");
	} else printf("0x0");
	fflush(stdout);
}

void
print_BLOCK_INFO (p)
	BLOCK_INFO	*p;
{
	if (p) {
		printf("{bi_inode=%lu, bi_lbn=%ld, bi_daddr=%lu, bi_segcreate=",
			p->bi_inode, p->bi_lbn, p->bi_daddr);
		print_time_t(p->bi_segcreate);
		printf(", bi_bp = 0x%x}", p->bi_bp);
	}
	else
		printf("0x0");
	fflush(stdout);
}

void
print_INODE_INFO (p)
	INODE_INFO	*p;
{
	if (p) {
		printf("{ii_inode=%lu, ii_daddr=%lu, ii_segcreate=",
			p->ii_inode, p->ii_daddr);
		print_time_t (p->ii_segcreate);
		printf(", ii_dinode=0x%x}", p->ii_dinode);
	}
	else
		printf("0x0");
	fflush(stdout);
}

void
print_lfs (p)
	struct	lfs	*p;
{
	int	i;
	
	if (p) {
		printf("{\n");
		printf("\tlfs_magic=0x%x\n", p->lfs_magic);
		printf("\tlfs_version=%lu\n", p->lfs_version);
		printf("\tlfs_size=%lu\n", p->lfs_size);
		printf("\tlfs_ssize=%lu\n", p->lfs_ssize);
		printf("\tlfs_dsize=%lu\n", p->lfs_dsize);
		printf("\tlfs_bsize=%lu\n", p->lfs_bsize);
		printf("\tlfs_fsize=%lu\n", p->lfs_fsize);
		printf("\tlfs_frag=%lu\n", p->lfs_frag);
		/* checkpoint region */
		printf("\tlfs_free=%lu\n", p->lfs_free);
		printf("\tlfs_bfree=%lu\n", p->lfs_bfree);
		printf("\tlfs_nfiles=%lu\n", p->lfs_nfiles);
		printf("\tlfs_idaddr=%lu\n", p->lfs_idaddr);
		printf("\tlfs_ifile=%lu\n", p->lfs_ifile);
		printf("\tlfs_lastseg=%lu\n", p->lfs_lastseg);
		printf("\tlfs_nextseg=%lu\n", p->lfs_nextseg);
		printf("\tlfs_curseg=%lu\n", p->lfs_curseg);
		printf("\tlfs_offset=%lu\n", p->lfs_offset);
		printf("\tlfs_tstamp=%lu\n", p->lfs_tstamp);
		/* configuration parameters */
		printf("\tlfs_minfree=%lu\n", p->lfs_minfree);
		/* these fields can be computed from the others */
		printf("\tlfs_dbpseg=%lu\n", p->lfs_dbpseg);
		printf("\tlfs_inopb=%lu\n", p->lfs_inopb);
		printf("\tlfs_ifpb=%lu\n", p->lfs_ifpb);
		printf("\tlfs_sepb=%lu\n", p->lfs_sepb);
		printf("\tlfs_nindir=%lu\n", p->lfs_nindir);
		printf("\tlfs_nseg=%lu\n", p->lfs_nseg);
		printf("\tlfs_nspf=%lu\n", p->lfs_nspf);
		printf("\tlfs_cleansz=%lu\n", p->lfs_cleansz);
		printf("\tlfs_segtabsz=%lu\n", p->lfs_segtabsz);

		printf("\tlfs_segmask=%lu\n", p->lfs_segmask);
		printf("\tlfs_segshift=%lu\n", p->lfs_segshift);
		printf("\tlfs_bmask=%lu\n", p->lfs_bmask);
		printf("\tlfs_bshift=%lu\n", p->lfs_bshift);
		printf("\tlfs_ffmask=%lu\n", p->lfs_ffmask);
		printf("\tlfs_ffshift=%lu\n", p->lfs_ffshift);
		printf("\tlfs_fbmask=%lu\n", p->lfs_fbmask);
		printf("\tlfs_fbshift=%lu\n", p->lfs_fbshift);
		printf("\tlfs_fsbtodb=%lu\n", p->lfs_fsbtodb);
		/* superblock offsets */
		printf("\tlfs_sboffs={");
		for (i = 0 ; i < LFS_MAXNUMSB ; i ++) {
			if (i > 0) printf(", ");
			printf("%lu", p->lfs_sboffs[i]);
		}
		printf("}\n");

		printf("}");
	}
	else
		printf("0x0");
	fflush(stdout);
}