diff -rubB --new-file cromwell/Makefile cromwell-ufs/Makefile
--- cromwell/Makefile	Tue Jul 26 21:19:27 2005
+++ cromwell-ufs/Makefile	Thu Aug  4 11:58:05 2005
@@ -105,7 +105,7 @@
 OBJECTS-CROM += $(TOPDIR)/obj/BootInterrupts.o
 OBJECTS-CROM += $(TOPDIR)/obj/fsys_reiserfs.o
 OBJECTS-CROM += $(TOPDIR)/obj/fsys_ext2fs.o
-OBJECTS-CROM += $(TOPDIR)/obj/fsys_ufs2.o
+OBJECTS-CROM += $(TOPDIR)/obj/fsys_ufs.o
 OBJECTS-CROM += $(TOPDIR)/obj/char_io.o
 OBJECTS-CROM += $(TOPDIR)/obj/disk_io.o
 OBJECTS-CROM += $(TOPDIR)/obj/decode-jpg.o
diff -rubB --new-file cromwell/boot/LoadLinux.c cromwell-ufs/boot/LoadLinux.c
--- cromwell/boot/LoadLinux.c	Mon Jul 25 18:13:33 2005
+++ cromwell-ufs/boot/LoadLinux.c	Thu Aug  4 12:24:17 2005
@@ -108,7 +108,13 @@
 	disk_read_hook=NULL;
 	disk_read_func=NULL;
 
-	//Try for /boot/linuxboot.cfg first
+	//Very first is /boot/xboxboot.cfg, which sounds more generic
+	strcpy(&szGrub[4], "/boot/xboxboot.cfg");
+	nRet=grub_open(szGrub);
+
+	if(nRet!=1 || errnum) {
+		//Not found; try /boot/linuxboot.cfg
+		errnum=0;
 	strcpy(&szGrub[4], "/boot/linuxboot.cfg");
 	nRet=grub_open(szGrub);
 
@@ -117,6 +123,7 @@
 		errnum=0;
 		strcpy(&szGrub[4], "/linuxboot.cfg");
 		nRet=grub_open(szGrub);
+		}
 	}
 	
 	dwConfigSize=filemax;
diff -rubB --new-file cromwell/fs/grub/Makefile cromwell-ufs/fs/grub/Makefile
--- cromwell/fs/grub/Makefile	Tue Jul 26 21:19:30 2005
+++ cromwell-ufs/fs/grub/Makefile	Thu Aug  4 11:57:07 2005
@@ -1,5 +1,5 @@
-EXTRA_CFLAGS := -DNO_DECOMPRESSION -DFSYS_REISERFS -DFSYS_EXT2FS -DFSYS_UFS2 -I$(TOPDIR)/fs/grub -DSTAGE1_5 -DNO_GETENV -DCROMWELL
+EXTRA_CFLAGS := -DNO_DECOMPRESSION -DFSYS_REISERFS -DFSYS_EXT2FS -DFSYS_UFS -I$(TOPDIR)/fs/grub -DSTAGE1_5 -DNO_GETENV -DCROMWELL
 
-O_TARGET := fsys_reiserfs.o fsys_ext2fs.o fsys_ufs2.o char_io.o disk_io.o
+O_TARGET := fsys_reiserfs.o fsys_ext2fs.o fsys_ufs.o char_io.o disk_io.o
 
 include $(TOPDIR)/Rules.make
diff -rubB --new-file cromwell/fs/grub/disk_io.c cromwell-ufs/fs/grub/disk_io.c
--- cromwell/fs/grub/disk_io.c	Tue Jul 26 21:19:31 2005
+++ cromwell-ufs/fs/grub/disk_io.c	Thu Aug  4 11:57:43 2005
@@ -72,8 +72,8 @@
 # ifdef FSYS_XFS
   {"xfs", xfs_mount, xfs_read, xfs_dir, 0, 0},
 # endif
-# ifdef FSYS_UFS2
-  {"ufs2", ufs2_mount, ufs2_read, ufs2_dir, 0, ufs2_embed},
+# ifdef FSYS_UFS
+  {"ufs", ufs_mount, ufs_read, ufs_dir, 0, ufs_embed},
 # endif
   /* XX FFS should come last as it's superblock is commonly crossing tracks
      on floppies from track 1 to 2, while others only use 1.  */
diff -rubB --new-file cromwell/fs/grub/filesys.h cromwell-ufs/fs/grub/filesys.h
--- cromwell/fs/grub/filesys.h	Tue Jul 26 21:19:31 2005
+++ cromwell-ufs/fs/grub/filesys.h	Thu Aug  4 11:57:39 2005
@@ -30,14 +30,14 @@
 #define FSYS_FFS_NUM 0
 #endif
 
-#ifdef FSYS_UFS2
-#define FSYS_UFS2_NUM 1
-int ufs2_mount (void);
-int ufs2_read (char *buf, int len);
-int ufs2_dir (char *dirname);
-int ufs2_embed (int *start_sector, int needed_sectors);
+#ifdef FSYS_UFS
+#define FSYS_UFS_NUM 1
+int ufs_mount (void);
+int ufs_read (char *buf, int len);
+int ufs_dir (char *dirname);
+int ufs_embed (int *start_sector, int needed_sectors);
 #else
-#define FSYS_UFS2_NUM 0
+#define FSYS_UFS_NUM 0
 #endif
 
 #ifdef FSYS_FAT
@@ -119,7 +119,7 @@
 #define NUM_FSYS	\
   (FSYS_FFS_NUM + FSYS_FAT_NUM + FSYS_EXT2FS_NUM + FSYS_MINIX_NUM	\
    + FSYS_REISERFS_NUM + FSYS_VSTAFS_NUM + FSYS_JFS_NUM + FSYS_XFS_NUM	\
-   + FSYS_TFTP_NUM  + FSYS_UFS2_NUM)
+   + FSYS_TFTP_NUM  + FSYS_UFS_NUM)
 #endif
 
 /* defines for the block filesystem info area */
diff -rubB --new-file cromwell/fs/grub/fsys_ufs.c cromwell-ufs/fs/grub/fsys_ufs.c
--- cromwell/fs/grub/fsys_ufs.c	Thu Jan  1 01:00:00 1970
+++ cromwell-ufs/fs/grub/fsys_ufs.c	Thu Aug  4 12:21:16 2005
@@ -0,0 +1,398 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (c) 2000, 2001  Free Software Foundation, Inc.
+ *  Copyright (c) 2005  Rink Springer
+ *
+ *  This file is based on FreeBSD 5.4-RELEASE's /sys/boot/common/ufsread.c,
+ *  and has some minor patches so it'll work with Cromwell/GRUB.
+ *
+ */
+/*-
+ * Copyright (c) 2002 McAfee, Inc.
+ * All rights reserved.
+ *
+ * This software was developed for the FreeBSD Project by Marshall
+ * Kirk McKusick and McAfee Research,, the Security Research Division of
+ * McAfee, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as
+ * part of the DARPA CHATS research program
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*-
+ * Copyright (c) 1998 Robert Nordier
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are freely
+ * permitted provided that the above copyright notice and this
+ * paragraph and the following disclaimer are duplicated in all
+ * such forms.
+ *
+ * This software is provided "AS IS" and without any express or
+ * implied warranties, including, without limitation, the implied
+ * warranties of merchantability and fitness for a particular
+ * purpose.
+ */
+#ifdef FSYS_UFS
+
+#include <shared.h>
+#include <stdint.h>
+#include "ufs_dinode.h"
+#include "ufs_fs.h"
+
+#ifdef __i386__
+/* XXX: Revert to old (broken for over 1.5Tb filesystems) version of cgbase
+   (see sys/ufs/ffs/fs.h rev 1.39) so that i386 boot loader (boot2) can
+   support both UFS1 and UFS2 again. */
+#undef cgbase
+#define cgbase(fs, c)   ((ufs2_daddr_t)((fs)->fs_fpg * (c)))
+#endif
+
+/*
+ * We use 4k `virtual' blocks for filesystem data, whatever the actual
+ * filesystem block size. FFS blocks are always a multiple of 4k.
+ */
+#define VBLKSHIFT	12
+#define VBLKSIZE	(1 << VBLKSHIFT)
+#define VBLKMASK	(VBLKSIZE - 1)
+#define DBPERVBLK	(VBLKSIZE / DEV_BSIZE)
+#define INDIRPERVBLK(fs) (NINDIR(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
+#define IPERVBLK(fs)	(INOPB(fs) / ((fs)->fs_bsize >> VBLKSHIFT))
+#define INO_TO_VBA(fs, ipervblk, x) \
+    (fsbtodb(fs, cgimin(fs, ino_to_cg(fs, x))) + \
+    (((x) % (fs)->fs_ipg) / (ipervblk) * DBPERVBLK))
+#define INO_TO_VBO(ipervblk, x) ((x) % ipervblk)
+#define FS_TO_VBA(fs, fsb, off) (fsbtodb(fs, fsb) + \
+    ((off) / VBLKSIZE) * DBPERVBLK)
+#define FS_TO_VBO(fs, fsb, off) ((off) & VBLKMASK)
+
+/* Buffers that must not span a 64k boundary. */
+struct dmadat {
+	char blkbuf[VBLKSIZE];	/* filesystem blocks */
+	char indbuf[VBLKSIZE];	/* indir blocks */
+	char sbbuf[SBLOCKSIZE];	/* superblock */
+	char secbuf[DEV_BSIZE];	/* for MBR/disklabel */
+};
+struct dmadat *dmadat = (struct dmadat*)FSYS_BUF;
+
+#define SUPERBLOCK ((struct fs*)dmadat->sbbuf)
+
+ino_t lookup(const char *);
+ssize_t fsread(ino_t, void *, size_t);
+
+static int dsk_meta;
+static uint32_t fs_off;
+static ino_t cur_ino = 0;
+
+int devread (int, int, int, char*);
+
+static inline int
+dskread (void* buf, unsigned lba, unsigned nblk)
+{
+	return !devread (lba, 0, nblk * DEV_BSIZE, buf) ? -1 : 0;
+}
+
+static int
+strcmp (const char* s1, const char* s2)
+{
+	while (*s1 && *s2) if (*s1++ != *s2++) return 1;
+	return (*s1 == *s2) ? 0 : 1;
+}
+
+
+#if defined(UFS2_ONLY)
+#define DIP(field) dp2.field
+#elif defined(UFS1_ONLY)
+#define DIP(field) dp1.field
+#else
+#define DIP(field) fs->fs_magic == FS_UFS1_MAGIC ? dp1.field : dp2.field
+#endif
+
+static __inline int
+fsfind(const char *name, ino_t * ino)
+{
+	char buf[DEV_BSIZE];
+	struct ufs_dirent *d;
+	char *s;
+	ssize_t n;
+#ifndef UFS2_ONLY
+	static struct ufs1_dinode dp1;
+#endif
+#ifndef UFS1_ONLY
+	static struct ufs2_dinode dp2;
+#endif
+	char* blkbuf = dmadat->blkbuf;
+	struct fs* fs = (struct fs *)dmadat->sbbuf;
+
+	fs_off = 0;
+	while ((n = fsread(*ino, buf, DEV_BSIZE)) > 0)
+		for (s = buf; s < buf + DEV_BSIZE;) {
+			d = (void *)s;
+			if (!strcmp(name, d->d_name)) {
+				*ino = d->d_fileno;
+
+				/* below is for grub, which wants the file size
+				 */
+				n = IPERVBLK(fs);
+				if (dskread(blkbuf, INO_TO_VBA(fs, n, (*ino)), DBPERVBLK))
+					return -1;
+				n = INO_TO_VBO(n, (*ino));
+#if defined(UFS1_ONLY)
+				dp1 = ((struct ufs1_dinode *)blkbuf)[n];
+#elif defined(UFS2_ONLY)
+				dp2 = ((struct ufs2_dinode *)blkbuf)[n];
+#else
+				if (fs->fs_magic == FS_UFS1_MAGIC)
+					dp1 = ((struct ufs1_dinode *)blkbuf)[n];
+				else
+					dp2 = ((struct ufs2_dinode *)blkbuf)[n];
+#endif
+
+				filemax = DIP(di_size);
+				return d->d_type;
+			}
+			s += d->d_reclen;
+		}
+	return 0;
+}
+
+ino_t
+lookup(const char *path)
+{
+	char name[MAXNAMLEN + 1];
+	const char *s;
+	ino_t ino;
+	ssize_t n;
+	int dt;
+
+	ino = ROOTINO;
+	dt = DT_DIR;
+	name[0] = '/';
+	name[1] = '\0';
+	for (;;) {
+		if (*path == '/')
+			path++;
+		if (!*path)
+			break;
+		for (s = path; *s && *s != '/'; s++);
+		if ((n = s - path) > MAXNAMLEN)
+			return 0;
+		memcpy(name, path, n);
+		name[n] = 0;
+		if (dt != DT_DIR) {
+			printk("%s: not a directory.\n", name);
+			return (0);
+		}
+		if ((dt = fsfind(name, &ino)) <= 0)
+			break;
+		path = s;
+	}
+	return dt == DT_REG ? ino : 0;
+}
+
+/*
+ * Possible superblock locations ordered from most to least likely.
+ */
+static int sblock_try[] = SBLOCKSEARCH;
+
+ssize_t
+fsread(ino_t inode, void *buf, size_t nbyte)
+{
+#ifndef UFS2_ONLY
+	static struct ufs1_dinode dp1;
+#endif
+#ifndef UFS1_ONLY
+	static struct ufs2_dinode dp2;
+#endif
+	static ino_t inomap;
+	char *blkbuf;
+	void *indbuf;
+	struct fs *fs;
+	char *s;
+	size_t n, nb, size, off, vboff;
+	ufs_lbn_t lbn;
+	ufs2_daddr_t addr, vbaddr;
+	static ufs2_daddr_t blkmap, indmap;
+	unsigned int u;
+
+
+	blkbuf = dmadat->blkbuf;
+	indbuf = dmadat->indbuf;
+	fs = (struct fs *)dmadat->sbbuf;
+	if (!dsk_meta) {
+		inomap = 0;
+		for (n = 0; sblock_try[n] != -1; n++) {
+			if (dskread(fs, sblock_try[n] / DEV_BSIZE,
+			    SBLOCKSIZE / DEV_BSIZE))
+				return -1;
+			if ((
+#if defined(UFS1_ONLY)
+			     fs->fs_magic == FS_UFS1_MAGIC
+#elif defined(UFS2_ONLY)
+			    (fs->fs_magic == FS_UFS2_MAGIC &&
+			    fs->fs_sblockloc == sblock_try[n])
+#else
+			     fs->fs_magic == FS_UFS1_MAGIC ||
+			    (fs->fs_magic == FS_UFS2_MAGIC &&
+			    fs->fs_sblockloc == sblock_try[n])
+#endif
+			    ) &&
+			    fs->fs_bsize <= MAXBSIZE &&
+			    fs->fs_bsize >= sizeof(struct fs))
+				break;
+		}
+		if (sblock_try[n] == -1) {
+			printk("Not ufs\n");
+			return -1;
+		}
+		dsk_meta++;
+	}
+	if (!inode)
+		return 0;
+	if (inomap != inode) {
+		n = IPERVBLK(fs);
+		if (dskread(blkbuf, INO_TO_VBA(fs, n, inode), DBPERVBLK))
+			return -1;
+		n = INO_TO_VBO(n, inode);
+#if defined(UFS1_ONLY)
+		dp1 = ((struct ufs1_dinode *)blkbuf)[n];
+#elif defined(UFS2_ONLY)
+		dp2 = ((struct ufs2_dinode *)blkbuf)[n];
+#else
+		if (fs->fs_magic == FS_UFS1_MAGIC)
+			dp1 = ((struct ufs1_dinode *)blkbuf)[n];
+		else
+			dp2 = ((struct ufs2_dinode *)blkbuf)[n];
+#endif
+		inomap = inode;
+		fs_off = 0;
+		blkmap = indmap = 0;
+	}
+	s = buf;
+	size = DIP(di_size);
+	n = size - fs_off;
+	if (nbyte > n)
+		nbyte = n;
+	nb = nbyte;
+	while (nb) {
+		lbn = lblkno(fs, fs_off);
+		off = blkoff(fs, fs_off);
+		if (lbn < NDADDR) {
+			addr = DIP(di_db[lbn]);
+		} else if (lbn < NDADDR + NINDIR(fs)) {
+			n = INDIRPERVBLK(fs);
+			addr = DIP(di_ib[0]);
+			u = (unsigned int)(lbn - NDADDR) / (n * DBPERVBLK);
+			vbaddr = fsbtodb(fs, addr) + u;
+			if (indmap != vbaddr) {
+				if (dskread(indbuf, vbaddr, DBPERVBLK))
+					return -1;
+				indmap = vbaddr;
+			}
+			n = (lbn - NDADDR) & (n - 1);
+#if defined(UFS1_ONLY)
+			addr = ((ufs1_daddr_t *)indbuf)[n];
+#elif defined(UFS2_ONLY)
+			addr = ((ufs2_daddr_t *)indbuf)[n];
+#else
+			if (fs->fs_magic == FS_UFS1_MAGIC)
+				addr = ((ufs1_daddr_t *)indbuf)[n];
+			else
+				addr = ((ufs2_daddr_t *)indbuf)[n];
+#endif
+		} else {
+			return -1;
+		}
+		vbaddr = fsbtodb(fs, addr) + (off >> VBLKSHIFT) * DBPERVBLK;
+		vboff = off & VBLKMASK;
+		n = sblksize(fs, size, lbn) - (off & ~VBLKMASK);
+		if (n > VBLKSIZE)
+			n = VBLKSIZE;
+		if (blkmap != vbaddr) {
+			if (dskread(blkbuf, vbaddr, n >> DEV_BSHIFT))
+				return -1;
+			blkmap = vbaddr;
+		}
+		n -= vboff;
+		if (n > nb)
+			n = nb;
+		memcpy(s, blkbuf + vboff, n);
+		s += n;
+		fs_off += n;
+		nb -= n;
+	}
+	return nbyte;
+}
+
+int
+ufs_mount (void)
+{
+  int i, retval = 0;
+
+  /*
+   * We don't care about stuff being in disklabels or not. If the magic
+   * matches, we're good to go.
+   */
+  for (i = 0; sblock_try[i] != -1; ++i)
+  {
+	if (! (part_length < (sblock_try[i] + (SBLOCKSIZE / DEV_BSIZE))
+		 || ! devread (0, sblock_try[i], SBLOCKSIZE, (char *) SUPERBLOCK)))
+	    {
+		if (
+#if defined(UFS1_ONLY)
+		     SUPERBLOCK->fs_magic == FS_UFS1_MAGIC
+#elif defined(UFS2_ONLY)
+		    (SUPERBLOCK->fs_magic == FS_UFS2_MAGIC &&
+		     SUPERBLOCK->fs_sblockloc == sblock_try[i])
+#else
+		     SUPERBLOCK->fs_magic == FS_UFS1_MAGIC ||
+		    (SUPERBLOCK->fs_magic == FS_UFS2_MAGIC &&
+		     SUPERBLOCK->fs_sblockloc == sblock_try[i])
+#endif
+		) {
+			retval = 1; break;
+		}
+	    }
+  }
+  return retval;
+}
+
+int
+ufs_read (char *buf, int len)
+{
+	return fsread(cur_ino, buf, len);
+}
+
+int
+ufs_dir (char *dirname)
+{
+	cur_ino = lookup(dirname);
+	return cur_ino & 0xffffffff;
+}
+
+int
+ufs_embed (int* start_sector, int needed_sectors)
+{
+	/* TODO; unused by Cromwell */
+	return 0;
+}
+
+#endif /* FSYS_UFS */
diff -rubB --new-file cromwell/fs/grub/fsys_ufs2.c cromwell-ufs/fs/grub/fsys_ufs2.c
--- cromwell/fs/grub/fsys_ufs2.c	Tue Jul 26 21:48:06 2005
+++ cromwell-ufs/fs/grub/fsys_ufs2.c	Thu Jan  1 01:00:00 1970
@@ -1,331 +0,0 @@
-/*
- *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2000, 2001  Free Software Foundation, Inc.
- *  Copyright (c) 2004  Valery Hromov
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-/*
- * Elements of this file were originally from the FreeBSD "biosboot"
- * bootloader file "disk.c" dated 4/12/95.
- *
- * The license and header comments from that file are included here.
- */
-
-/*
- * Mach Operating System
- * Copyright (c) 1992, 1991 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- *
- *	from: Mach, Revision 2.2  92/04/04  11:35:49  rpd
- *	$Id: fsys_ufs2.c,v 1.1 2005/07/26 19:48:06 huceke Exp $
- */
-
-#ifdef FSYS_UFS2
-
-#include "shared.h"
-#include "filesys.h"
-
-#include "ufs2.h"
-
-/* used for filesystem map blocks */
-static int mapblock;
-static int mapblock_offset;
-static int mapblock_bsize;
-
-static int sblock_try[] = SBLOCKSEARCH;
-static ufs2_daddr_t sblockloc;
-static int type;
-
-/* pointer to superblock */
-#define SUPERBLOCK ((struct fs *) ( FSYS_BUF + 8192 ))
-
-#define INODE_UFS2 ((struct ufs2_dinode *) ( FSYS_BUF + 16384 ))
-
-#define MAPBUF ( FSYS_BUF + 24576 )
-#define MAPBUF_LEN 8192
-
-int
-ufs2_mount (void)
-{
-  int retval = 0;
-  int i;
-
-  sblockloc = -1;
-  type = 0;
-  
-  if (! (((current_drive & 0x80) || (current_slice != 0))
-	 && ! IS_PC_SLICE_TYPE_BSD_WITH_FS (current_slice, FS_BSDFFS)))
-    {
-      for (i = 0; sblock_try[i] != -1; ++i)
-	{
-	  if (! (part_length < (sblock_try[i] + (SBLOCKSIZE / DEV_BSIZE))
-		 || ! devread (0, sblock_try[i], SBLOCKSIZE, (char *) SUPERBLOCK)))
-	    {
-	      if (SUPERBLOCK->fs_magic == FS_UFS2_MAGIC /* &&
-							   (SUPERBLOCK->fs_sblockloc == sblockloc ||
-						     (SUPERBLOCK->fs_old_flags & FS_FLAGS_UPDATED) == 0)*/)
-		{
-		  type = 2;
-		}
-	      else
-		{
-		  continue;
-		}
-	      
-	      retval = 1;
-	      sblockloc = sblock_try[i];
-	      break;
-	    }
-	}
-    }
-  
-  mapblock = -1;
-  mapblock_offset = -1;
-  
-  return retval;
-}
-
-static grub_int64_t
-block_map (int file_block)
-{
-  int bnum, offset, bsize;
-  
-  if (file_block < NDADDR)
-    return (INODE_UFS2->di_db[file_block]);
-  
-  /* If the blockmap loaded does not include FILE_BLOCK,
-     load a new blockmap.  */
-
-  if ((bnum = fsbtodb (SUPERBLOCK, INODE_UFS2->di_ib[0])) != mapblock
-      || (mapblock_offset <= bnum && bnum <= mapblock_offset + mapblock_bsize))
-    {
-      if (MAPBUF_LEN < SUPERBLOCK->fs_bsize)
-	{
-	  offset = ((file_block - NDADDR) % NINDIR (SUPERBLOCK));
-	  bsize = MAPBUF_LEN;
-	  
-	  if (offset + MAPBUF_LEN > SUPERBLOCK->fs_bsize)
-	    offset = (SUPERBLOCK->fs_bsize - MAPBUF_LEN) / sizeof (int);
-	}
-      else
-	{
-	  bsize = SUPERBLOCK->fs_bsize;
-	  offset = 0;
-	}
-      
-      if (! devread (bnum, offset * sizeof (int), bsize, (char *) MAPBUF))
-	{
-	  mapblock = -1;
-	  mapblock_bsize = -1;
-	  mapblock_offset = -1;
-	  errnum = ERR_FSYS_CORRUPT;
-	  return -1;
-	}
-      
-      mapblock = bnum;
-      mapblock_bsize = bsize;
-      mapblock_offset = offset;
-    }
-  
-  return (((grub_int64_t *) MAPBUF)[((file_block - NDADDR) % NINDIR (SUPERBLOCK))
-				    - mapblock_offset]);
-}
-
-int
-ufs2_read (char *buf, int len)
-{
-  int logno, off, size, ret = 0;
-  grub_int64_t map;
-
-  while (len && !errnum)
-    {
-      off = blkoff (SUPERBLOCK, filepos);
-      logno = lblkno (SUPERBLOCK, filepos);
-      size = blksize (SUPERBLOCK, INODE_UFS2, logno);
-
-      if ((map = block_map (logno)) < 0)
-	break; 
-
-      size -= off;
-
-      if (size > len)
-	size = len;
-
-      disk_read_func = disk_read_hook;
-
-      devread (fsbtodb (SUPERBLOCK, map), off, size, buf);
-
-      disk_read_func = NULL;
-
-      buf += size;
-      len -= size;
-      filepos += size;
-      ret += size;
-    }
-
-  if (errnum)
-    ret = 0;
-
-  return ret;
-}
-
-int
-ufs2_dir (char *dirname)
-{
-  char *rest, ch;
-  int block, off, loc, ino = ROOTINO;
-  grub_int64_t map;
-  struct direct *dp;
-
-/* main loop to find destination inode */
-loop:
-
-  /* load current inode (defaults to the root inode) */
-
-    if (!devread (fsbtodb (SUPERBLOCK, ino_to_fsba (SUPERBLOCK, ino)),
-	    ino % (SUPERBLOCK->fs_inopb) * sizeof (struct ufs2_dinode),
-	    sizeof (struct ufs2_dinode), (char *) INODE_UFS2))
-		    return 0;			/* XXX what return value? */
-
-  /* if we have a real file (and we're not just printing possibilities),
-     then this is where we want to exit */
-
-  if (!*dirname || isspace (*dirname))
-    {
-      if ((INODE_UFS2->di_mode & IFMT) != IFREG)
-	{
-	  errnum = ERR_BAD_FILETYPE;
-	  return 0;
-	}
-
-      filemax = INODE_UFS2->di_size;
-
-      /* incomplete implementation requires this! */
-      fsmax = (NDADDR + NINDIR (SUPERBLOCK)) * SUPERBLOCK->fs_bsize;
-      return 1;
-    }
-
-  /* continue with file/directory name interpretation */
-
-  while (*dirname == '/')
-    dirname++;
-
-  if (!(INODE_UFS2->di_size) || ((INODE_UFS2->di_mode & IFMT) != IFDIR))
-    {
-      errnum = ERR_BAD_FILETYPE;
-      return 0;
-    }
-
-  for (rest = dirname; (ch = *rest) && !isspace (ch) && ch != '/'; rest++);
-
-  *rest = 0;
-  loc = 0;
-
-  /* loop for reading a the entries in a directory */
-
-  do
-    {
-      if (loc >= INODE_UFS2->di_size)
-	{
-	  if (print_possibilities < 0)
-	    return 1;
-
-	  errnum = ERR_FILE_NOT_FOUND;
-	  *rest = ch;
-	  return 0;
-	}
-
-      if (!(off = blkoff (SUPERBLOCK, loc)))
-	{
-	  block = lblkno (SUPERBLOCK, loc);
-
-	  if ((map = block_map (block)) < 0
-	      || !devread (fsbtodb (SUPERBLOCK, map), 0,
-			   blksize (SUPERBLOCK, INODE_UFS2, block),
-			   (char *) FSYS_BUF))
-	    {
-	      errnum = ERR_FSYS_CORRUPT;
-	      *rest = ch;
-	      return 0;
-	    }
-	}
-
-      dp = (struct direct *) (FSYS_BUF + off);
-      loc += dp->d_reclen;
-
-#ifndef STAGE1_5
-      if (dp->d_ino && print_possibilities && ch != '/'
-	  && (!*dirname || substring (dirname, dp->d_name) <= 0))
-	{
-	  if (print_possibilities > 0)
-	    print_possibilities = -print_possibilities;
-
-	  print_a_completion (dp->d_name);
-	}
-#endif /* STAGE1_5 */
-    }
-  while (!dp->d_ino || (substring (dirname, dp->d_name) != 0
-			|| (print_possibilities && ch != '/')));
-
-  /* only get here if we have a matching directory entry */
-
-  ino = dp->d_ino;
-  *(dirname = rest) = ch;
-
-  /* go back to main loop at top of function */
-  goto loop;
-}
-
-int
-ufs2_embed (int *start_sector, int needed_sectors)
-{
-  /* XXX: I don't know if this is really correct. Someone who is
-     familiar with BSD should check for this.  */
-  if (needed_sectors > 14)
-    return 0;
-  
-  *start_sector = 1;
-#if 1
-  /* FIXME: Disable the embedding in FFS until someone checks if
-     the code above is correct.  */
-  return 0;
-#else
-  return 1;
-#endif
-}
-
-#endif /* FSYS_UFS2 */
diff -rubB --new-file cromwell/fs/grub/shared.h cromwell-ufs/fs/grub/shared.h
--- cromwell/fs/grub/shared.h	Tue Jul 26 21:19:31 2005
+++ cromwell-ufs/fs/grub/shared.h	Thu Aug  4 11:57:59 2005
@@ -211,7 +211,7 @@
 #define STAGE2_ID_VSTAFS_STAGE1_5	6
 #define STAGE2_ID_JFS_STAGE1_5		7
 #define STAGE2_ID_XFS_STAGE1_5		8
-#define STAGE2_ID_UFS2_STAGE1_5		9
+#define STAGE2_ID_UFS_STAGE1_5		9
 
 #ifndef STAGE1_5
 # define STAGE2_ID	STAGE2_ID_STAGE2
@@ -232,8 +232,8 @@
 #  define STAGE2_ID	STAGE2_ID_JFS_STAGE1_5
 # elif defined(FSYS_XFS)
 #  define STAGE2_ID	STAGE2_ID_XFS_STAGE1_5
-# elif defined(FSYS_UFS2)
-#  define STAGE2_ID	STAGE2_ID_UFS2_STAGE1_5
+# elif defined(FSYS_UFS)
+#  define STAGE2_ID	STAGE2_ID_UFS_STAGE1_5
 # else
 #  error "unknown Stage 2"
 # endif
diff -rubB --new-file cromwell/fs/grub/ufs2.h cromwell-ufs/fs/grub/ufs2.h
--- cromwell/fs/grub/ufs2.h	Tue Jul 26 21:48:06 2005
+++ cromwell-ufs/fs/grub/ufs2.h	Thu Jan  1 01:00:00 1970
@@ -1,439 +0,0 @@
-/*
- * Copyright (C) 2004 Free Software Foundation, Inc.
- * Copyright (c) 2002 Networks Associates Technology, Inc.
- * All rights reserved.
- *
- * This software was developed for the FreeBSD Project by Marshall
- * Kirk McKusick and Network Associates Laboratories, the Security
- * Research Division of Network Associates, Inc. under DARPA/SPAWAR
- * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
- * research program
- *
- * Copyright (c) 1982, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The names of the authors may not be used to endorse or promote
- *    products derived from this software without specific prior written
- *    permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)dinode.h	8.3 (Berkeley) 1/21/94
- * $FreeBSD: src/sys/ufs/ufs/dinode.h,v 1.11 2002/07/16 22:36:00 mckusick Exp $
- */
-
-#ifndef _GRUB_UFS2_H_
-#define _GRUB_UFS2_H_
-
-typedef signed char            grub_int8_t;
-typedef signed short           grub_int16_t;
-typedef signed int             grub_int32_t;
-typedef signed long long int   grub_int64_t;
-typedef unsigned char          grub_uint8_t;
-typedef unsigned short         grub_uint16_t;
-typedef unsigned int           grub_uint32_t;
-typedef unsigned long long int grub_uint64_t;
-
-typedef grub_uint8_t                grub_u_char;
-typedef grub_uint32_t               grub_u_int;
-
-typedef grub_uint8_t                grub_u_int8_t;
-typedef grub_uint16_t               grub_u_int16_t;
-typedef grub_uint32_t               grub_u_int32_t;
-typedef grub_uint64_t               grub_u_int64_t;
-
-#define i_size di_size
-
-
-#define DEV_BSIZE 512
-
-/*
- * The root inode is the root of the filesystem.  Inode 0 can't be used for
- * normal purposes and historically bad blocks were linked to inode 1, thus
- * the root inode is 2.  (Inode 1 is no longer used for this purpose, however
- * numerous dump tapes make this assumption, so we are stuck with it).
- */
-#define	ROOTINO	((grub_ino_t)2)
-
-/*
- * The size of physical and logical block numbers and time fields in UFS.
- */
-typedef grub_int32_t ufs1_daddr_t;
-typedef	grub_int64_t	ufs2_daddr_t;
-typedef grub_int64_t ufs_lbn_t;
-typedef grub_int64_t ufs_time_t;
-
-/* inode number */
-typedef grub_uint32_t      grub_ino_t;
-
-/* File permissions. */
-#define	IEXEC		0000100		/* Executable. */
-#define	IWRITE		0000200		/* Writeable. */
-#define	IREAD		0000400		/* Readable. */
-#define	ISVTX		0001000		/* Sticky bit. */
-#define	ISGID		0002000		/* Set-gid. */
-#define	ISUID		0004000		/* Set-uid. */
-
-/* File types. */
-#define	IFMT		0170000		/* Mask of file type. */
-#define	IFIFO		0010000		/* Named pipe (fifo). */
-#define	IFCHR		0020000		/* Character device. */
-#define	IFDIR		0040000		/* Directory file. */
-#define	IFBLK		0060000		/* Block device. */
-#define	IFREG		0100000		/* Regular file. */
-#define	IFLNK		0120000		/* Symbolic link. */
-#define	IFSOCK		0140000		/* UNIX domain socket. */
-#define	IFWHT		0160000		/* Whiteout. */
-
-/*
- * A dinode contains all the meta-data associated with a UFS2 file.
- * This structure defines the on-disk format of a dinode. Since
- * this structure describes an on-disk structure, all its fields
- * are defined by types with precise widths.
- */
-
-#define	NXADDR	2			/* External addresses in inode. */
-#define	NDADDR	12			/* Direct addresses in inode. */
-#define	NIADDR	3			/* Indirect addresses in inode. */
-
-struct ufs1_dinode {
-	grub_u_int16_t       di_mode;        /*   0: IFMT, permissions; see below. */
-	grub_int16_t         di_nlink;       /*   2: File link count. */
-	union {
-		grub_u_int16_t oldids[2];    /*   4: Ffs: old user and group ids. */
-	} di_u;
-	grub_u_int64_t       di_size;        /*   8: File byte count. */
-	grub_int32_t         di_atime;       /*  16: Last access time. */
-	grub_int32_t         di_atimensec;   /*  20: Last access time. */
-	grub_int32_t         di_mtime;       /*  24: Last modified time. */
-	grub_int32_t         di_mtimensec;   /*  28: Last modified time. */
-	grub_int32_t         di_ctime;       /*  32: Last inode change time. */
-	grub_int32_t         di_ctimensec;   /*  36: Last inode change time. */
-	ufs1_daddr_t    di_db[NDADDR];  /*  40: Direct disk blocks. */
-	ufs1_daddr_t    di_ib[NIADDR];  /*  88: Indirect disk blocks. */
-	grub_u_int32_t       di_flags;       /* 100: Status flags (chflags). */
-	grub_int32_t         di_blocks;      /* 104: Blocks actually held. */
-	grub_int32_t         di_gen;         /* 108: Generation number. */
-	grub_u_int32_t       di_uid;         /* 112: File owner. */
-	grub_u_int32_t       di_gid;         /* 116: File group. */
-	grub_int32_t         di_spare[2];    /* 120: Reserved; currently unused */
-};
-
-struct ufs2_dinode {
-	grub_u_int16_t	di_mode;	/*   0: IFMT, permissions; see below. */
-	grub_int16_t		di_nlink;	/*   2: File link count. */
-	grub_u_int32_t	di_uid;		/*   4: File owner. */
-	grub_u_int32_t	di_gid;		/*   8: File group. */
-	grub_u_int32_t	di_blksize;	/*  12: Inode blocksize. */
-	grub_u_int64_t	di_size;	/*  16: File byte count. */
-	grub_u_int64_t	di_blocks;	/*  24: Bytes actually held. */
-	ufs_time_t	di_atime;	/*  32: Last access time. */
-	ufs_time_t	di_mtime;	/*  40: Last modified time. */
-	ufs_time_t	di_ctime;	/*  48: Last inode change time. */
-	ufs_time_t	di_birthtime;	/*  56: Inode creation time. */
-	grub_int32_t		di_mtimensec;	/*  64: Last modified time. */
-	grub_int32_t		di_atimensec;	/*  68: Last access time. */
-	grub_int32_t		di_ctimensec;	/*  72: Last inode change time. */
-	grub_int32_t		di_birthnsec;	/*  76: Inode creation time. */
-	grub_int32_t		di_gen;		/*  80: Generation number. */
-	grub_u_int32_t	di_kernflags;	/*  84: Kernel flags. */
-	grub_u_int32_t	di_flags;	/*  88: Status flags (chflags). */
-	grub_int32_t		di_extsize;	/*  92: External attributes block. */
-	ufs2_daddr_t	di_extb[NXADDR];/*  96: External attributes block. */
-	ufs2_daddr_t	di_db[NDADDR];	/* 112: Direct disk blocks. */
-	ufs2_daddr_t	di_ib[NIADDR];	/* 208: Indirect disk blocks. */
-	grub_int64_t		di_spare[3];	/* 232: Reserved; currently unused */
-};
-
-#define	MAXNAMLEN	255
-
-struct	direct {
-	grub_u_int32_t d_ino;		/* inode number of entry */
-	grub_u_int16_t d_reclen;		/* length of this record */
-	grub_u_int8_t  d_type; 		/* file type, see below */
-	grub_u_int8_t  d_namlen;		/* length of string in d_name */
-	char	  d_name[MAXNAMLEN + 1];/* name with length <= MAXNAMLEN */
-};
-
-/*
- * File types
- */
-#define DT_UNKNOWN       0
-#define DT_FIFO          1
-#define DT_CHR           2
-#define DT_DIR           4
-#define DT_BLK           6
-#define DT_REG           8
-#define DT_LNK          10
-#define DT_SOCK         12
-#define DT_WHT          14
-
-/*
- * Superblock offsets
- */
-#define SBLOCK_FLOPPY        0
-#define SBLOCK_UFS1       8192
-#define SBLOCK_UFS2      65536
-#define SBLOCK_PIGGY    262144
-#define SBLOCKSIZE        8192
-#define SBLOCKSEARCH \
-	{ SBLOCK_UFS2, SBLOCK_UFS1, SBLOCK_FLOPPY, SBLOCK_PIGGY, -1 }
-
-#define MAXMNTLEN	512
-
-#define	NOCSPTRS	((128 / sizeof(void *)) - 4)
-
-/*
- * The maximum number of snapshot nodes that can be associated
- * with each filesystem. This limit affects only the number of
- * snapshot files that can be recorded within the superblock so
- * that they can be found when the filesystem is mounted. However,
- * maintaining too many will slow the filesystem performance, so
- * having this limit is a good idea.
- */
-#define FSMAXSNAP 20
-	
-/*
- * Per cylinder group information; summarized in blocks allocated
- * from first cylinder group data blocks.  These blocks have to be
- * read in from fs_csaddr (size fs_cssize) in addition to the
- * super block.
- */
-struct csum {
-	grub_int32_t	cs_ndir;		/* number of directories */
-	grub_int32_t	cs_nbfree;		/* number of free blocks */
-	grub_int32_t	cs_nifree;		/* number of free inodes */
-	grub_int32_t	cs_nffree;		/* number of free frags */
-};
-
-struct csum_total {
-	grub_int64_t	cs_ndir;		/* number of directories */
-	grub_int64_t	cs_nbfree;		/* number of free blocks */
-	grub_int64_t	cs_nifree;		/* number of free inodes */
-	grub_int64_t	cs_nffree;		/* number of free frags */
-	grub_int64_t	cs_numclusters;		/* number of free clusters */
-	grub_int64_t	cs_spare[3];		/* future expansion */
-};
-
-/*
- * Super block for an FFS filesystem.
- */
-struct fs {
-	grub_int32_t	 fs_firstfield;		/* historic filesystem linked list, */
-	grub_int32_t	 fs_unused_1;		/*     used for incore super blocks */
-	grub_int32_t	 fs_sblkno;		/* offset of super-block in filesys */
-	grub_int32_t	 fs_cblkno;		/* offset of cyl-block in filesys */
-	grub_int32_t	 fs_iblkno;		/* offset of inode-blocks in filesys */
-	grub_int32_t	 fs_dblkno;		/* offset of first data after cg */
-	grub_int32_t	 fs_old_cgoffset;	/* cylinder group offset in cylinder */
-	grub_int32_t	 fs_old_cgmask;		/* used to calc mod fs_ntrak */
-	grub_int32_t  fs_old_time;		/* last time written */
-	grub_int32_t	 fs_old_size;		/* number of blocks in fs */
-	grub_int32_t	 fs_old_dsize;		/* number of data blocks in fs */
-	grub_int32_t	 fs_ncg;		/* number of cylinder groups */
-	grub_int32_t	 fs_bsize;		/* size of basic blocks in fs */
-	grub_int32_t	 fs_fsize;		/* size of frag blocks in fs */
-	grub_int32_t	 fs_frag;		/* number of frags in a block in fs */
-/* these are configuration parameters */
-	grub_int32_t	 fs_minfree;		/* minimum percentage of free blocks */
-	grub_int32_t	 fs_old_rotdelay;	/* num of ms for optimal next block */
-	grub_int32_t	 fs_old_rps;		/* disk revolutions per second */
-/* these fields can be computed from the others */
-	grub_int32_t	 fs_bmask;		/* ``blkoff'' calc of blk offsets */
-	grub_int32_t	 fs_fmask;		/* ``fragoff'' calc of frag offsets */
-	grub_int32_t	 fs_bshift;		/* ``lblkno'' calc of logical blkno */
-	grub_int32_t	 fs_fshift;		/* ``numfrags'' calc number of frags */
-/* these are configuration parameters */
-	grub_int32_t	 fs_maxcontig;		/* max number of contiguous blks */
-	grub_int32_t	 fs_maxbpg;		/* max number of blks per cyl group */
-/* these fields can be computed from the others */
-	grub_int32_t	 fs_fragshift;		/* block to frag shift */
-	grub_int32_t	 fs_fsbtodb;		/* fsbtodb and dbtofsb shift constant */
-	grub_int32_t	 fs_sbsize;		/* actual size of super block */
-	grub_int32_t	 fs_spare1[2];		/* old fs_csmask */
-					/* old fs_csshift */
-	grub_int32_t	 fs_nindir;		/* value of NINDIR */
-	grub_int32_t	 fs_inopb;		/* value of INOPB */
-	grub_int32_t	 fs_old_nspf;		/* value of NSPF */
-/* yet another configuration parameter */
-	grub_int32_t	 fs_optim;		/* optimization preference, see below */
-	grub_int32_t	 fs_old_npsect;		/* # sectors/track including spares */
-	grub_int32_t	 fs_old_interleave;	/* hardware sector interleave */
-	grub_int32_t	 fs_old_trackskew;	/* sector 0 skew, per track */
-	grub_int32_t	 fs_id[2];		/* unique filesystem id */
-/* sizes determined by number of cylinder groups and their sizes */
-	grub_int32_t	 fs_old_csaddr;		/* blk addr of cyl grp summary area */
-	grub_int32_t	 fs_cssize;		/* size of cyl grp summary area */
-	grub_int32_t	 fs_cgsize;		/* cylinder group size */
-	grub_int32_t	 fs_spare2;		/* old fs_ntrak */
-	grub_int32_t	 fs_old_nsect;		/* sectors per track */
-	grub_int32_t  fs_old_spc;		/* sectors per cylinder */
-	grub_int32_t	 fs_old_ncyl;		/* cylinders in filesystem */
-	grub_int32_t	 fs_old_cpg;		/* cylinders per group */
-	grub_int32_t	 fs_ipg;		/* inodes per group */
-	grub_int32_t	 fs_fpg;		/* blocks per group * fs_frag */
-/* this data must be re-computed after crashes */
-	struct	csum fs_old_cstotal;	/* cylinder summary information */
-/* these fields are cleared at mount time */
-	grub_int8_t   fs_fmod;		/* super block modified flag */
-	grub_int8_t   fs_clean;		/* filesystem is clean flag */
-	grub_int8_t 	 fs_ronly;		/* mounted read-only flag */
-	grub_int8_t   fs_old_flags;		/* old FS_ flags */
-	grub_u_char	 fs_fsmnt[MAXMNTLEN];	/* name mounted on */
-/* these fields retain the current block allocation info */
-	grub_int32_t	 fs_cgrotor;		/* last cg searched */
-	void 	*fs_ocsp[NOCSPTRS];	/* padding; was list of fs_cs buffers */
-	grub_u_int8_t *fs_contigdirs;	/* # of contiguously allocated dirs */
-	struct	csum *fs_csp;		/* cg summary info buffer for fs_cs */
-	grub_int32_t	*fs_maxcluster;		/* max cluster in each cyl group */
-	grub_u_int	*fs_active;		/* used by snapshots to track fs */
-	grub_int32_t	 fs_old_cpc;		/* cyl per cycle in postbl */
-	grub_int32_t	 fs_maxbsize;		/* maximum blocking factor permitted */
-	grub_int64_t	 fs_sparecon64[17];	/* old rotation block list head */
-	grub_int64_t	 fs_sblockloc;		/* byte offset of standard superblock */
-	struct	csum_total fs_cstotal;	/* cylinder summary information */
-	ufs_time_t fs_time;		/* last time written */
-	grub_int64_t	 fs_size;		/* number of blocks in fs */
-	grub_int64_t	 fs_dsize;		/* number of data blocks in fs */
-	ufs2_daddr_t fs_csaddr;		/* blk addr of cyl grp summary area */
-	grub_int64_t	 fs_pendingblocks;	/* blocks in process of being freed */
-	grub_int32_t	 fs_pendinginodes;	/* inodes in process of being freed */
-	grub_int32_t	 fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */
-	grub_int32_t	 fs_avgfilesize;	/* expected average file size */
-	grub_int32_t	 fs_avgfpdir;		/* expected # of files per directory */
-	grub_int32_t	 fs_save_cgsize;	/* save real cg size to use fs_bsize */
-	grub_int32_t	 fs_sparecon32[26];	/* reserved for future constants */
-	grub_int32_t  fs_flags;		/* see FS_ flags below */
-	grub_int32_t	 fs_contigsumsize;	/* size of cluster summary array */ 
-	grub_int32_t	 fs_maxsymlinklen;	/* max length of an internal symlink */
-	grub_int32_t	 fs_old_inodefmt;	/* format of on-disk inodes */
-	grub_u_int64_t fs_maxfilesize;	/* maximum representable file size */
-	grub_int64_t	 fs_qbmask;		/* ~fs_bmask for use with 64-bit size */
-	grub_int64_t	 fs_qfmask;		/* ~fs_fmask for use with 64-bit size */
-	grub_int32_t	 fs_state;		/* validate fs_clean field */
-	grub_int32_t	 fs_old_postblformat;	/* format of positional layout tables */
-	grub_int32_t	 fs_old_nrpos;		/* number of rotational positions */
-	grub_int32_t	 fs_spare5[2];		/* old fs_postbloff */
-					/* old fs_rotbloff */
-	grub_int32_t	 fs_magic;		/* magic number */
-};
-
-/*
- * Filesystem identification
- */
-#define FS_UFS1_MAGIC   0x011954        /* UFS1 fast filesystem magic number */
-#define	FS_UFS2_MAGIC	0x19540119	/* UFS2 fast filesystem magic number */
-
-/*
- * Turn filesystem block numbers into disk block addresses.
- * This maps filesystem blocks to device size blocks.
- */
-#define fsbtodb(fs, b)	((b) << (fs)->fs_fsbtodb)
-#define	dbtofsb(fs, b)	((b) >> (fs)->fs_fsbtodb)
-
-/*
- * Cylinder group macros to locate things in cylinder groups.
- * They calc filesystem addresses of cylinder group data structures.
- */
-#define	cgbase(fs, c)	((ufs2_daddr_t)((fs)->fs_fpg * (c)))
-#define	cgimin(fs, c)	(cgstart(fs, c) + (fs)->fs_iblkno)	/* inode blk */
-#define cgstart(fs, c)							\
-       ((fs)->fs_magic == FS_UFS2_MAGIC ? cgbase(fs, c) :		\
-       (cgbase(fs, c) + (fs)->fs_old_cgoffset * ((c) & ~((fs)->fs_old_cgmask))))
-
-/*
- * Macros for handling inode numbers:
- *     inode number to filesystem block offset.
- *     inode number to cylinder group number.
- *     inode number to filesystem block address.
- */
-#define	ino_to_cg(fs, x)	((x) / (fs)->fs_ipg)
-#define	ino_to_fsba(fs, x)						\
-	((ufs2_daddr_t)(cgimin(fs, ino_to_cg(fs, x)) +			\
-	    (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
-#define	ino_to_fsbo(fs, x)	((x) % INOPB(fs))
-
-/*
- * The following macros optimize certain frequently calculated
- * quantities by using shifts and masks in place of divisions
- * modulos and multiplications.
- */
-#define blkoff(fs, loc)		/* calculates (loc % fs->fs_bsize) */ \
-	((loc) & (fs)->fs_qbmask)
-
-/* Use this only when `blk' is known to be small, e.g., < NDADDR. */
-#define smalllblktosize(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
-	((blk) << (fs)->fs_bshift)
-
-
-#define lblkno(fs, loc)		/* calculates (loc / fs->fs_bsize) */ \
-	((loc) >> (fs)->fs_bshift)
-
-#define fragroundup(fs, size)	/* calculates roundup(size, fs->fs_fsize) */ \
-	(((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)
-
-#define fragstoblks(fs, frags)	/* calculates (frags / fs->fs_frag) */ \
-	((frags) >> (fs)->fs_fragshift)
-#define blkstofrags(fs, blks)	/* calculates (blks * fs->fs_frag) */ \
-	((blks) << (fs)->fs_fragshift)
-#define fragnum(fs, fsb)	/* calculates (fsb % fs->fs_frag) */ \
-	((fsb) & ((fs)->fs_frag - 1))
-#define blknum(fs, fsb)		/* calculates rounddown(fsb, fs->fs_frag) */ \
-	((fsb) &~ ((fs)->fs_frag - 1))
-
-/*
- * Determining the size of a file block in the filesystem.
- */
-#define blksize(fs, ip, lbn) \
-	(((lbn) >= NDADDR || (ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \
-	    ? (fs)->fs_bsize \
-	    : (fragroundup(fs, blkoff(fs, (ip)->i_size))))
-#define sblksize(fs, size, lbn) \
-	(((lbn) >= NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \
-	  ? (fs)->fs_bsize \
-	  : (fragroundup(fs, blkoff(fs, (size)))))
-
-
-/*
- * Number of inodes in a secondary storage block/fragment.
- */
-#define	INOPB(fs)	((fs)->fs_inopb)
-#define	INOPF(fs)	((fs)->fs_inopb >> (fs)->fs_fragshift)
-
-/*
- * Number of indirects in a filesystem block.
- */
-#define	NINDIR(fs)	((fs)->fs_nindir)
-
-#define FS_UNCLEAN    0x01      /* filesystem not clean at mount */
-#define FS_DOSOFTDEP  0x02      /* filesystem using soft dependencies */
-#define FS_NEEDSFSCK  0x04      /* filesystem needs sync fsck before mount */
-#define FS_INDEXDIRS  0x08      /* kernel supports indexed directories */
-#define FS_ACLS       0x10      /* file system has ACLs enabled */
-#define FS_MULTILABEL 0x20      /* file system is MAC multi-label */
-#define FS_FLAGS_UPDATED 0x80   /* flags have been moved to new location */
-
-#endif /* _GRUB_UFS2_H_ */
diff -rubB --new-file cromwell/fs/grub/ufs_dinode.h cromwell-ufs/fs/grub/ufs_dinode.h
--- cromwell/fs/grub/ufs_dinode.h	Thu Jan  1 01:00:00 1970
+++ cromwell-ufs/fs/grub/ufs_dinode.h	Thu Aug  4 11:58:31 2005
@@ -0,0 +1,191 @@
+/*-
+ * Copyright (c) 2002 Networks Associates Technology, Inc.
+ * All rights reserved.
+ *
+ * This software was developed for the FreeBSD Project by Marshall
+ * Kirk McKusick and Network Associates Laboratories, the Security
+ * Research Division of Network Associates, Inc. under DARPA/SPAWAR
+ * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
+ * research program
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * Copyright (c) 1982, 1989, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The names of the authors may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)dinode.h	8.3 (Berkeley) 1/21/94
+ * $FreeBSD: src/sys/ufs/ufs/dinode.h,v 1.13.2.1 2005/01/31 23:27:01 imp Exp $
+ */
+
+#ifndef _UFS_UFS_DINODE_H_
+#define	_UFS_UFS_DINODE_H_
+
+/*
+ * The root inode is the root of the filesystem.  Inode 0 can't be used for
+ * normal purposes and historically bad blocks were linked to inode 1, thus
+ * the root inode is 2.  (Inode 1 is no longer used for this purpose, however
+ * numerous dump tapes make this assumption, so we are stuck with it).
+ */
+#define	ROOTINO	((ino_t)2)
+
+/*
+ * The Whiteout inode# is a dummy non-zero inode number which will
+ * never be allocated to a real file.  It is used as a place holder
+ * in the directory entry which has been tagged as a DT_W entry.
+ * See the comments about ROOTINO above.
+ */
+#define	WINO	((ino_t)1)
+
+/*
+ * The size of physical and logical block numbers and time fields in UFS.
+ */
+typedef	int32_t	ufs1_daddr_t;
+typedef	int64_t	ufs2_daddr_t;
+typedef int64_t ufs_lbn_t;
+typedef int64_t ufs_time_t;
+
+/* File permissions. */
+#define	IEXEC		0000100		/* Executable. */
+#define	IWRITE		0000200		/* Writeable. */
+#define	IREAD		0000400		/* Readable. */
+#define	ISVTX		0001000		/* Sticky bit. */
+#define	ISGID		0002000		/* Set-gid. */
+#define	ISUID		0004000		/* Set-uid. */
+
+/* File types. */
+#define	IFMT		0170000		/* Mask of file type. */
+#define	IFIFO		0010000		/* Named pipe (fifo). */
+#define	IFCHR		0020000		/* Character device. */
+#define	IFDIR		0040000		/* Directory file. */
+#define	IFBLK		0060000		/* Block device. */
+#define	IFREG		0100000		/* Regular file. */
+#define	IFLNK		0120000		/* Symbolic link. */
+#define	IFSOCK		0140000		/* UNIX domain socket. */
+#define	IFWHT		0160000		/* Whiteout. */
+
+/*
+ * A dinode contains all the meta-data associated with a UFS2 file.
+ * This structure defines the on-disk format of a dinode. Since
+ * this structure describes an on-disk structure, all its fields
+ * are defined by types with precise widths.
+ */
+
+#define	NXADDR	2			/* External addresses in inode. */
+#define	NDADDR	12			/* Direct addresses in inode. */
+#define	NIADDR	3			/* Indirect addresses in inode. */
+
+struct ufs2_dinode {
+	uint16_t	di_mode;	/*   0: IFMT, permissions; see below. */
+	int16_t		di_nlink;	/*   2: File link count. */
+	uint32_t	di_uid;		/*   4: File owner. */
+	uint32_t	di_gid;		/*   8: File group. */
+	uint32_t	di_blksize;	/*  12: Inode blocksize. */
+	uint64_t	di_size;	/*  16: File byte count. */
+	uint64_t	di_blocks;	/*  24: Bytes actually held. */
+	ufs_time_t	di_atime;	/*  32: Last access time. */
+	ufs_time_t	di_mtime;	/*  40: Last modified time. */
+	ufs_time_t	di_ctime;	/*  48: Last inode change time. */
+	ufs_time_t	di_birthtime;	/*  56: Inode creation time. */
+	int32_t		di_mtimensec;	/*  64: Last modified time. */
+	int32_t		di_atimensec;	/*  68: Last access time. */
+	int32_t		di_ctimensec;	/*  72: Last inode change time. */
+	int32_t		di_birthnsec;	/*  76: Inode creation time. */
+	int32_t		di_gen;		/*  80: Generation number. */
+	uint32_t	di_kernflags;	/*  84: Kernel flags. */
+	uint32_t	di_flags;	/*  88: Status flags (chflags). */
+	int32_t		di_extsize;	/*  92: External attributes block. */
+	ufs2_daddr_t	di_extb[NXADDR];/*  96: External attributes block. */
+	ufs2_daddr_t	di_db[NDADDR];	/* 112: Direct disk blocks. */
+	ufs2_daddr_t	di_ib[NIADDR];	/* 208: Indirect disk blocks. */
+	int64_t		di_spare[3];	/* 232: Reserved; currently unused */
+};
+
+/*
+ * The di_db fields may be overlaid with other information for
+ * file types that do not have associated disk storage. Block
+ * and character devices overlay the first data block with their
+ * dev_t value. Short symbolic links place their path in the
+ * di_db area.
+ */
+#define	di_rdev di_db[0]
+
+/*
+ * A UFS1 dinode contains all the meta-data associated with a UFS1 file.
+ * This structure defines the on-disk format of a UFS1 dinode. Since
+ * this structure describes an on-disk structure, all its fields
+ * are defined by types with precise widths.
+ */
+struct ufs1_dinode {
+	uint16_t	di_mode;	/*   0: IFMT, permissions; see below. */
+	int16_t		di_nlink;	/*   2: File link count. */
+	union {
+		uint16_t oldids[2];	/*   4: Ffs: old user and group ids. */
+	} di_u;
+	uint64_t	di_size;	/*   8: File byte count. */
+	int32_t		di_atime;	/*  16: Last access time. */
+	int32_t		di_atimensec;	/*  20: Last access time. */
+	int32_t		di_mtime;	/*  24: Last modified time. */
+	int32_t		di_mtimensec;	/*  28: Last modified time. */
+	int32_t		di_ctime;	/*  32: Last inode change time. */
+	int32_t		di_ctimensec;	/*  36: Last inode change time. */
+	ufs1_daddr_t	di_db[NDADDR];	/*  40: Direct disk blocks. */
+	ufs1_daddr_t	di_ib[NIADDR];	/*  88: Indirect disk blocks. */
+	uint32_t	di_flags;	/* 100: Status flags (chflags). */
+	int32_t		di_blocks;	/* 104: Blocks actually held. */
+	int32_t		di_gen;		/* 108: Generation number. */
+	uint32_t	di_uid;		/* 112: File owner. */
+	uint32_t	di_gid;		/* 116: File group. */
+	int32_t		di_spare[2];	/* 120: Reserved; currently unused */
+};
+#define	di_ogid		di_u.oldids[1]
+#define	di_ouid		di_u.oldids[0]
+
+#endif /* _UFS_UFS_DINODE_H_ */
diff -rubB --new-file cromwell/fs/grub/ufs_fs.h cromwell-ufs/fs/grub/ufs_fs.h
--- cromwell/fs/grub/ufs_fs.h	Thu Jan  1 01:00:00 1970
+++ cromwell-ufs/fs/grub/ufs_fs.h	Thu Aug  4 12:03:42 2005
@@ -0,0 +1,635 @@
+/*-
+ * Copyright (c) 1982, 1986, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)fs.h	8.13 (Berkeley) 3/21/95
+ * $FreeBSD: src/sys/ufs/ffs/fs.h,v 1.43.2.3 2005/02/28 16:04:53 delphij Exp $
+ */
+
+#ifndef _UFS_FFS_FS_H_
+#define _UFS_FFS_FS_H_
+
+/*
+ * Each disk drive contains some number of filesystems.
+ * A filesystem consists of a number of cylinder groups.
+ * Each cylinder group has inodes and data.
+ *
+ * A filesystem is described by its super-block, which in turn
+ * describes the cylinder groups.  The super-block is critical
+ * data and is replicated in each cylinder group to protect against
+ * catastrophic loss.  This is done at `newfs' time and the critical
+ * super-block data does not change, so the copies need not be
+ * referenced further unless disaster strikes.
+ *
+ * For filesystem fs, the offsets of the various blocks of interest
+ * are given in the super block as:
+ *	[fs->fs_sblkno]		Super-block
+ *	[fs->fs_cblkno]		Cylinder group block
+ *	[fs->fs_iblkno]		Inode blocks
+ *	[fs->fs_dblkno]		Data blocks
+ * The beginning of cylinder group cg in fs, is given by
+ * the ``cgbase(fs, cg)'' macro.
+ *
+ * Depending on the architecture and the media, the superblock may
+ * reside in any one of four places. For tiny media where every block 
+ * counts, it is placed at the very front of the partition. Historically,
+ * UFS1 placed it 8K from the front to leave room for the disk label and
+ * a small bootstrap. For UFS2 it got moved to 64K from the front to leave
+ * room for the disk label and a bigger bootstrap, and for really piggy
+ * systems we check at 256K from the front if the first three fail. In
+ * all cases the size of the superblock will be SBLOCKSIZE. All values are
+ * given in byte-offset form, so they do not imply a sector size. The
+ * SBLOCKSEARCH specifies the order in which the locations should be searched.
+ */
+#define SBLOCK_FLOPPY	     0
+#define SBLOCK_UFS1	  8192
+#define SBLOCK_UFS2	 65536
+#define SBLOCK_PIGGY	262144
+#define SBLOCKSIZE	  8192
+#define SBLOCKSEARCH \
+	{ SBLOCK_UFS2, SBLOCK_UFS1, SBLOCK_FLOPPY, SBLOCK_PIGGY, -1 }
+
+/*
+ * Max number of fragments per block. This value is NOT tweakable.
+ */
+#define MAXFRAG 	8
+
+/*
+ * Addresses stored in inodes are capable of addressing fragments
+ * of `blocks'. File system blocks of at most size MAXBSIZE can
+ * be optionally broken into 2, 4, or 8 pieces, each of which is
+ * addressable; these pieces may be DEV_BSIZE, or some multiple of
+ * a DEV_BSIZE unit.
+ *
+ * Large files consist of exclusively large data blocks.  To avoid
+ * undue wasted disk space, the last data block of a small file may be
+ * allocated as only as many fragments of a large block as are
+ * necessary.  The filesystem format retains only a single pointer
+ * to such a fragment, which is a piece of a single large block that
+ * has been divided.  The size of such a fragment is determinable from
+ * information in the inode, using the ``blksize(fs, ip, lbn)'' macro.
+ *
+ * The filesystem records space availability at the fragment level;
+ * to determine block availability, aligned fragments are examined.
+ */
+
+/*
+ * MINBSIZE is the smallest allowable block size.
+ * In order to insure that it is possible to create files of size
+ * 2^32 with only two levels of indirection, MINBSIZE is set to 4096.
+ * MINBSIZE must be big enough to hold a cylinder group block,
+ * thus changes to (struct cg) must keep its size within MINBSIZE.
+ * Note that super blocks are always of size SBSIZE,
+ * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE.
+ */
+#define MINBSIZE	4096
+
+/*
+ * The path name on which the filesystem is mounted is maintained
+ * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in
+ * the super block for this name.
+ */
+#define MAXMNTLEN	468
+
+/*
+ * The volume name for this filesystem is maintained in fs_volname.
+ * MAXVOLLEN defines the length of the buffer allocated.
+ */
+#define MAXVOLLEN	32
+
+/*
+ * There is a 128-byte region in the superblock reserved for in-core
+ * pointers to summary information. Originally this included an array
+ * of pointers to blocks of struct csum; now there are just a few
+ * pointers and the remaining space is padded with fs_ocsp[].
+ *
+ * NOCSPTRS determines the size of this padding. One pointer (fs_csp)
+ * is taken away to point to a contiguous array of struct csum for
+ * all cylinder groups; a second (fs_maxcluster) points to an array
+ * of cluster sizes that is computed as cylinder groups are inspected,
+ * and the third points to an array that tracks the creation of new
+ * directories. A fourth pointer, fs_active, is used when creating
+ * snapshots; it points to a bitmap of cylinder groups for which the
+ * free-block bitmap has changed since the snapshot operation began.
+ */
+#define	NOCSPTRS	((128 / sizeof(void *)) - 4)
+
+/*
+ * A summary of contiguous blocks of various sizes is maintained
+ * in each cylinder group. Normally this is set by the initial
+ * value of fs_maxcontig. To conserve space, a maximum summary size
+ * is set by FS_MAXCONTIG.
+ */
+#define FS_MAXCONTIG	16
+
+/*
+ * MINFREE gives the minimum acceptable percentage of filesystem
+ * blocks which may be free. If the freelist drops below this level
+ * only the superuser may continue to allocate blocks. This may
+ * be set to 0 if no reserve of free blocks is deemed necessary,
+ * however throughput drops by fifty percent if the filesystem
+ * is run at between 95% and 100% full; thus the minimum default
+ * value of fs_minfree is 5%. However, to get good clustering
+ * performance, 10% is a better choice. hence we use 10% as our
+ * default value. With 10% free space, fragmentation is not a
+ * problem, so we choose to optimize for time.
+ */
+#define MINFREE		8
+#define DEFAULTOPT	FS_OPTTIME
+
+/*
+ * Grigoriy Orlov <gluk@ptci.ru> has done some extensive work to fine
+ * tune the layout preferences for directories within a filesystem.
+ * His algorithm can be tuned by adjusting the following parameters
+ * which tell the system the average file size and the average number
+ * of files per directory. These defaults are well selected for typical
+ * filesystems, but may need to be tuned for odd cases like filesystems
+ * being used for squid caches or news spools.
+ */
+#define AVFILESIZ	16384	/* expected average file size */
+#define AFPDIR		64	/* expected number of files per directory */
+
+/*
+ * The maximum number of snapshot nodes that can be associated
+ * with each filesystem. This limit affects only the number of
+ * snapshot files that can be recorded within the superblock so
+ * that they can be found when the filesystem is mounted. However,
+ * maintaining too many will slow the filesystem performance, so
+ * having this limit is a good idea.
+ */
+#define FSMAXSNAP 20
+
+/*
+ * Used to identify special blocks in snapshots:
+ *
+ * BLK_NOCOPY - A block that was unallocated at the time the snapshot
+ *	was taken, hence does not need to be copied when written.
+ * BLK_SNAP - A block held by another snapshot that is not needed by this
+ *	snapshot. When the other snapshot is freed, the BLK_SNAP entries
+ *	are converted to BLK_NOCOPY. These are needed to allow fsck to
+ *	identify blocks that are in use by other snapshots (which are
+ *	expunged from this snapshot).
+ */
+#define BLK_NOCOPY ((ufs2_daddr_t)(1))
+#define BLK_SNAP ((ufs2_daddr_t)(2))
+
+/*
+ * Sysctl values for the fast filesystem.
+ */
+#define	FFS_ADJ_REFCNT		 1	/* adjust inode reference count */
+#define	FFS_ADJ_BLKCNT		 2	/* adjust inode used block count */
+#define	FFS_BLK_FREE		 3	/* free range of blocks in map */
+#define	FFS_DIR_FREE		 4	/* free specified dir inodes in map */
+#define	FFS_FILE_FREE		 5	/* free specified file inodes in map */
+#define	FFS_SET_FLAGS		 6	/* set filesystem flags */
+#define	FFS_ADJ_NDIR		 7	/* adjust number of directories */
+#define	FFS_ADJ_NBFREE		 8	/* adjust number of free blocks */
+#define	FFS_ADJ_NIFREE		 9	/* adjust number of free inodes */
+#define	FFS_ADJ_NFFREE		10 	/* adjust number of free frags */
+#define	FFS_ADJ_NUMCLUSTERS	11	/* adjust number of free clusters */
+#define	FFS_MAXID		12	/* number of valid ffs ids */
+
+/*
+ * Command structure passed in to the filesystem to adjust filesystem values.
+ */
+#define	FFS_CMD_VERSION		0x19790518	/* version ID */
+struct fsck_cmd {
+	int32_t	version;	/* version of command structure */
+	int32_t	handle;		/* reference to filesystem to be changed */
+	int64_t	value;		/* inode or block number to be affected */
+	int64_t	size;		/* amount or range to be adjusted */
+	int64_t	spare;		/* reserved for future use */
+};
+
+/*
+ * Per cylinder group information; summarized in blocks allocated
+ * from first cylinder group data blocks.  These blocks have to be
+ * read in from fs_csaddr (size fs_cssize) in addition to the
+ * super block.
+ */
+struct csum {
+	int32_t	cs_ndir;		/* number of directories */
+	int32_t	cs_nbfree;		/* number of free blocks */
+	int32_t	cs_nifree;		/* number of free inodes */
+	int32_t	cs_nffree;		/* number of free frags */
+};
+struct csum_total {
+	int64_t	cs_ndir;		/* number of directories */
+	int64_t	cs_nbfree;		/* number of free blocks */
+	int64_t	cs_nifree;		/* number of free inodes */
+	int64_t	cs_nffree;		/* number of free frags */
+	int64_t	cs_numclusters;		/* number of free clusters */
+	int64_t	cs_spare[3];		/* future expansion */
+};
+
+/*
+ * Super block for an FFS filesystem.
+ */
+struct fs {
+	int32_t	 fs_firstfield;		/* historic filesystem linked list, */
+	int32_t	 fs_unused_1;		/*     used for incore super blocks */
+	int32_t	 fs_sblkno;		/* offset of super-block in filesys */
+	int32_t	 fs_cblkno;		/* offset of cyl-block in filesys */
+	int32_t	 fs_iblkno;		/* offset of inode-blocks in filesys */
+	int32_t	 fs_dblkno;		/* offset of first data after cg */
+	int32_t	 fs_old_cgoffset;	/* cylinder group offset in cylinder */
+	int32_t	 fs_old_cgmask;		/* used to calc mod fs_ntrak */
+	int32_t  fs_old_time;		/* last time written */
+	int32_t	 fs_old_size;		/* number of blocks in fs */
+	int32_t	 fs_old_dsize;		/* number of data blocks in fs */
+	int32_t	 fs_ncg;		/* number of cylinder groups */
+	int32_t	 fs_bsize;		/* size of basic blocks in fs */
+	int32_t	 fs_fsize;		/* size of frag blocks in fs */
+	int32_t	 fs_frag;		/* number of frags in a block in fs */
+/* these are configuration parameters */
+	int32_t	 fs_minfree;		/* minimum percentage of free blocks */
+	int32_t	 fs_old_rotdelay;	/* num of ms for optimal next block */
+	int32_t	 fs_old_rps;		/* disk revolutions per second */
+/* these fields can be computed from the others */
+	int32_t	 fs_bmask;		/* ``blkoff'' calc of blk offsets */
+	int32_t	 fs_fmask;		/* ``fragoff'' calc of frag offsets */
+	int32_t	 fs_bshift;		/* ``lblkno'' calc of logical blkno */
+	int32_t	 fs_fshift;		/* ``numfrags'' calc number of frags */
+/* these are configuration parameters */
+	int32_t	 fs_maxcontig;		/* max number of contiguous blks */
+	int32_t	 fs_maxbpg;		/* max number of blks per cyl group */
+/* these fields can be computed from the others */
+	int32_t	 fs_fragshift;		/* block to frag shift */
+	int32_t	 fs_fsbtodb;		/* fsbtodb and dbtofsb shift constant */
+	int32_t	 fs_sbsize;		/* actual size of super block */
+	int32_t	 fs_spare1[2];		/* old fs_csmask */
+					/* old fs_csshift */
+	int32_t	 fs_nindir;		/* value of NINDIR */
+	int32_t	 fs_inopb;		/* value of INOPB */
+	int32_t	 fs_old_nspf;		/* value of NSPF */
+/* yet another configuration parameter */
+	int32_t	 fs_optim;		/* optimization preference, see below */
+	int32_t	 fs_old_npsect;		/* # sectors/track including spares */
+	int32_t	 fs_old_interleave;	/* hardware sector interleave */
+	int32_t	 fs_old_trackskew;	/* sector 0 skew, per track */
+	int32_t	 fs_id[2];		/* unique filesystem id */
+/* sizes determined by number of cylinder groups and their sizes */
+	int32_t	 fs_old_csaddr;		/* blk addr of cyl grp summary area */
+	int32_t	 fs_cssize;		/* size of cyl grp summary area */
+	int32_t	 fs_cgsize;		/* cylinder group size */
+	int32_t	 fs_spare2;		/* old fs_ntrak */
+	int32_t	 fs_old_nsect;		/* sectors per track */
+	int32_t  fs_old_spc;		/* sectors per cylinder */
+	int32_t	 fs_old_ncyl;		/* cylinders in filesystem */
+	int32_t	 fs_old_cpg;		/* cylinders per group */
+	int32_t	 fs_ipg;		/* inodes per group */
+	int32_t	 fs_fpg;		/* blocks per group * fs_frag */
+/* this data must be re-computed after crashes */
+	struct	csum fs_old_cstotal;	/* cylinder summary information */
+/* these fields are cleared at mount time */
+	int8_t   fs_fmod;		/* super block modified flag */
+	int8_t   fs_clean;		/* filesystem is clean flag */
+	int8_t 	 fs_ronly;		/* mounted read-only flag */
+	int8_t   fs_old_flags;		/* old FS_ flags */
+	char	 fs_fsmnt[MAXMNTLEN];	/* name mounted on */
+	char	 fs_volname[MAXVOLLEN];	/* volume name */
+	uint64_t fs_swuid;		/* system-wide uid */
+	int32_t  fs_pad;		/* due to alignment of fs_swuid */
+/* these fields retain the current block allocation info */
+	int32_t	 fs_cgrotor;		/* last cg searched */
+	void 	*fs_ocsp[NOCSPTRS];	/* padding; was list of fs_cs buffers */
+	uint8_t *fs_contigdirs;	/* # of contiguously allocated dirs */
+	struct	csum *fs_csp;		/* cg summary info buffer for fs_cs */
+	int32_t	*fs_maxcluster;		/* max cluster in each cyl group */
+	unsigned int *fs_active;	/* used by snapshots to track fs */
+	int32_t	 fs_old_cpc;		/* cyl per cycle in postbl */
+	int32_t	 fs_maxbsize;		/* maximum blocking factor permitted */
+	int64_t	 fs_sparecon64[17];	/* old rotation block list head */
+	int64_t	 fs_sblockloc;		/* byte offset of standard superblock */
+	struct	csum_total fs_cstotal;	/* cylinder summary information */
+	ufs_time_t fs_time;		/* last time written */
+	int64_t	 fs_size;		/* number of blocks in fs */
+	int64_t	 fs_dsize;		/* number of data blocks in fs */
+	ufs2_daddr_t fs_csaddr;		/* blk addr of cyl grp summary area */
+	int64_t	 fs_pendingblocks;	/* blocks in process of being freed */
+	int32_t	 fs_pendinginodes;	/* inodes in process of being freed */
+	int32_t	 fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */
+	int32_t	 fs_avgfilesize;	/* expected average file size */
+	int32_t	 fs_avgfpdir;		/* expected # of files per directory */
+	int32_t	 fs_save_cgsize;	/* save real cg size to use fs_bsize */
+	int32_t	 fs_sparecon32[26];	/* reserved for future constants */
+	int32_t  fs_flags;		/* see FS_ flags below */
+	int32_t	 fs_contigsumsize;	/* size of cluster summary array */ 
+	int32_t	 fs_maxsymlinklen;	/* max length of an internal symlink */
+	int32_t	 fs_old_inodefmt;	/* format of on-disk inodes */
+	uint64_t fs_maxfilesize;	/* maximum representable file size */
+	int64_t	 fs_qbmask;		/* ~fs_bmask for use with 64-bit size */
+	int64_t	 fs_qfmask;		/* ~fs_fmask for use with 64-bit size */
+	int32_t	 fs_state;		/* validate fs_clean field */
+	int32_t	 fs_old_postblformat;	/* format of positional layout tables */
+	int32_t	 fs_old_nrpos;		/* number of rotational positions */
+	int32_t	 fs_spare5[2];		/* old fs_postbloff */
+					/* old fs_rotbloff */
+	int32_t	 fs_magic;		/* magic number */
+};
+
+/* Sanity checking. */
+#ifdef CTASSERT
+CTASSERT(sizeof(struct fs) == 1376);
+#endif
+
+/*
+ * Filesystem identification
+ */
+#define	FS_UFS1_MAGIC	0x011954	/* UFS1 fast filesystem magic number */
+#define	FS_UFS2_MAGIC	0x19540119	/* UFS2 fast filesystem magic number */
+#define	FS_BAD_MAGIC	0x19960408	/* UFS incomplete newfs magic number */
+#define	FS_OKAY		0x7c269d38	/* superblock checksum */
+#define FS_42INODEFMT	-1		/* 4.2BSD inode format */
+#define FS_44INODEFMT	2		/* 4.4BSD inode format */
+
+/*
+ * Preference for optimization.
+ */
+#define FS_OPTTIME	0	/* minimize allocation time */
+#define FS_OPTSPACE	1	/* minimize disk fragmentation */
+
+/*
+ * Filesystem flags.
+ *
+ * The FS_UNCLEAN flag is set by the kernel when the filesystem was
+ * mounted with fs_clean set to zero. The FS_DOSOFTDEP flag indicates
+ * that the filesystem should be managed by the soft updates code.
+ * Note that the FS_NEEDSFSCK flag is set and cleared only by the
+ * fsck utility. It is set when background fsck finds an unexpected
+ * inconsistency which requires a traditional foreground fsck to be
+ * run. Such inconsistencies should only be found after an uncorrectable
+ * disk error. A foreground fsck will clear the FS_NEEDSFSCK flag when
+ * it has successfully cleaned up the filesystem. The kernel uses this
+ * flag to enforce that inconsistent filesystems be mounted read-only.
+ * The FS_INDEXDIRS flag when set indicates that the kernel maintains
+ * on-disk auxiliary indexes (such as B-trees) for speeding directory
+ * accesses. Kernels that do not support auxiliary indicies clear the
+ * flag to indicate that the indicies need to be rebuilt (by fsck) before
+ * they can be used.
+ *
+ * FS_ACLS indicates that ACLs are administratively enabled for the
+ * file system, so they should be loaded from extended attributes,
+ * observed for access control purposes, and be administered by object
+ * owners.  FS_MULTILABEL indicates that the TrustedBSD MAC Framework
+ * should attempt to back MAC labels into extended attributes on the
+ * file system rather than maintain a single mount label for all
+ * objects.
+ */
+#define FS_UNCLEAN    0x01	/* filesystem not clean at mount */
+#define FS_DOSOFTDEP  0x02	/* filesystem using soft dependencies */
+#define FS_NEEDSFSCK  0x04	/* filesystem needs sync fsck before mount */
+#define FS_INDEXDIRS  0x08	/* kernel supports indexed directories */
+#define FS_ACLS       0x10	/* file system has ACLs enabled */
+#define FS_MULTILABEL 0x20	/* file system is MAC multi-label */
+#define FS_FLAGS_UPDATED 0x80	/* flags have been moved to new location */
+
+/*
+ * Macros to access bits in the fs_active array.
+ */
+#define	ACTIVECGNUM(fs, cg)	((fs)->fs_active[(cg) / (NBBY * sizeof(int))])
+#define	ACTIVECGOFF(cg)		(1 << ((cg) % (NBBY * sizeof(int))))
+
+/*
+ * The size of a cylinder group is calculated by CGSIZE. The maximum size
+ * is limited by the fact that cylinder groups are at most one block.
+ * Its size is derived from the size of the maps maintained in the
+ * cylinder group and the (struct cg) size.
+ */
+#define CGSIZE(fs) \
+    /* base cg */	(sizeof(struct cg) + sizeof(int32_t) + \
+    /* old btotoff */	(fs)->fs_old_cpg * sizeof(int32_t) + \
+    /* old boff */	(fs)->fs_old_cpg * sizeof(uint16_t) + \
+    /* inode map */	howmany((fs)->fs_ipg, NBBY) + \
+    /* block map */	howmany((fs)->fs_fpg, NBBY) +\
+    /* if present */	((fs)->fs_contigsumsize <= 0 ? 0 : \
+    /* cluster sum */	(fs)->fs_contigsumsize * sizeof(int32_t) + \
+    /* cluster map */	howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))
+
+/*
+ * The minimal number of cylinder groups that should be created.
+ */
+#define MINCYLGRPS	4
+
+/*
+ * Convert cylinder group to base address of its global summary info.
+ */
+#define fs_cs(fs, indx) fs_csp[indx]
+
+/*
+ * Cylinder group block for a filesystem.
+ */
+#define	CG_MAGIC	0x090255
+struct cg {
+	int32_t	 cg_firstfield;		/* historic cyl groups linked list */
+	int32_t	 cg_magic;		/* magic number */
+	int32_t  cg_old_time;		/* time last written */
+	int32_t	 cg_cgx;		/* we are the cgx'th cylinder group */
+	int16_t	 cg_old_ncyl;		/* number of cyl's this cg */
+	int16_t  cg_old_niblk;		/* number of inode blocks this cg */
+	int32_t	 cg_ndblk;		/* number of data blocks this cg */
+	struct	csum cg_cs;		/* cylinder summary information */
+	int32_t	 cg_rotor;		/* position of last used block */
+	int32_t	 cg_frotor;		/* position of last used frag */
+	int32_t	 cg_irotor;		/* position of last used inode */
+	int32_t	 cg_frsum[MAXFRAG];	/* counts of available frags */
+	int32_t	 cg_old_btotoff;	/* (int32) block totals per cylinder */
+	int32_t	 cg_old_boff;		/* (uint16) free block positions */
+	int32_t	 cg_iusedoff;		/* (uint8) used inode map */
+	int32_t	 cg_freeoff;		/* (uint8) free block map */
+	int32_t	 cg_nextfreeoff;	/* (uint8) next available space */
+	int32_t	 cg_clustersumoff;	/* (uint32) counts of avail clusters */
+	int32_t	 cg_clusteroff;		/* (uint8) free cluster map */
+	int32_t	 cg_nclusterblks;	/* number of clusters this cg */
+	int32_t  cg_niblk;		/* number of inode blocks this cg */
+	int32_t	 cg_initediblk;		/* last initialized inode */
+	int32_t	 cg_sparecon32[3];	/* reserved for future use */
+	ufs_time_t cg_time;		/* time last written */
+	int64_t	 cg_sparecon64[3];	/* reserved for future use */
+	uint8_t cg_space[1];		/* space for cylinder group maps */
+/* actually longer */
+};
+
+/*
+ * Macros for access to cylinder group array structures
+ */
+#define cg_chkmagic(cgp) ((cgp)->cg_magic == CG_MAGIC)
+#define cg_inosused(cgp) \
+    ((uint8_t *)((uint8_t *)(cgp) + (cgp)->cg_iusedoff))
+#define cg_blksfree(cgp) \
+    ((uint8_t *)((uint8_t *)(cgp) + (cgp)->cg_freeoff))
+#define cg_clustersfree(cgp) \
+    ((uint8_t *)((uint8_t *)(cgp) + (cgp)->cg_clusteroff))
+#define cg_clustersum(cgp) \
+    ((int32_t *)((uintptr_t)(cgp) + (cgp)->cg_clustersumoff))
+
+/*
+ * Turn filesystem block numbers into disk block addresses.
+ * This maps filesystem blocks to device size blocks.
+ */
+#define fsbtodb(fs, b)	((b) << (fs)->fs_fsbtodb)
+#define	dbtofsb(fs, b)	((b) >> (fs)->fs_fsbtodb)
+
+/*
+ * Cylinder group macros to locate things in cylinder groups.
+ * They calc filesystem addresses of cylinder group data structures.
+ */
+#define	cgbase(fs, c)	(((ufs2_daddr_t)(fs)->fs_fpg) * (c))
+#define	cgdmin(fs, c)	(cgstart(fs, c) + (fs)->fs_dblkno)	/* 1st data */
+#define	cgimin(fs, c)	(cgstart(fs, c) + (fs)->fs_iblkno)	/* inode blk */
+#define	cgsblock(fs, c)	(cgstart(fs, c) + (fs)->fs_sblkno)	/* super blk */
+#define	cgtod(fs, c)	(cgstart(fs, c) + (fs)->fs_cblkno)	/* cg block */
+#define cgstart(fs, c)							\
+       ((fs)->fs_magic == FS_UFS2_MAGIC ? cgbase(fs, c) :		\
+       (cgbase(fs, c) + (fs)->fs_old_cgoffset * ((c) & ~((fs)->fs_old_cgmask))))
+
+/*
+ * Macros for handling inode numbers:
+ *     inode number to filesystem block offset.
+ *     inode number to cylinder group number.
+ *     inode number to filesystem block address.
+ */
+#define	ino_to_cg(fs, x)	((x) / (fs)->fs_ipg)
+#define	ino_to_fsba(fs, x)						\
+	((ufs2_daddr_t)(cgimin(fs, ino_to_cg(fs, x)) +			\
+	    (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
+#define	ino_to_fsbo(fs, x)	((x) % INOPB(fs))
+
+/*
+ * Give cylinder group number for a filesystem block.
+ * Give cylinder group block number for a filesystem block.
+ */
+#define	dtog(fs, d)	((d) / (fs)->fs_fpg)
+#define	dtogd(fs, d)	((d) % (fs)->fs_fpg)
+
+/*
+ * Extract the bits for a block from a map.
+ * Compute the cylinder and rotational position of a cyl block addr.
+ */
+#define blkmap(fs, map, loc) \
+    (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
+
+/*
+ * The following macros optimize certain frequently calculated
+ * quantities by using shifts and masks in place of divisions
+ * modulos and multiplications.
+ */
+#define blkoff(fs, loc)		/* calculates (loc % fs->fs_bsize) */ \
+	((loc) & (fs)->fs_qbmask)
+#define fragoff(fs, loc)	/* calculates (loc % fs->fs_fsize) */ \
+	((loc) & (fs)->fs_qfmask)
+#define lfragtosize(fs, frag)	/* calculates ((off_t)frag * fs->fs_fsize) */ \
+	(((off_t)(frag)) << (fs)->fs_fshift)
+#define lblktosize(fs, blk)	/* calculates ((off_t)blk * fs->fs_bsize) */ \
+	(((off_t)(blk)) << (fs)->fs_bshift)
+/* Use this only when `blk' is known to be small, e.g., < NDADDR. */
+#define smalllblktosize(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
+	((blk) << (fs)->fs_bshift)
+#define lblkno(fs, loc)		/* calculates (loc / fs->fs_bsize) */ \
+	((loc) >> (fs)->fs_bshift)
+#define numfrags(fs, loc)	/* calculates (loc / fs->fs_fsize) */ \
+	((loc) >> (fs)->fs_fshift)
+#define blkroundup(fs, size)	/* calculates roundup(size, fs->fs_bsize) */ \
+	(((size) + (fs)->fs_qbmask) & (fs)->fs_bmask)
+#define fragroundup(fs, size)	/* calculates roundup(size, fs->fs_fsize) */ \
+	(((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)
+#define fragstoblks(fs, frags)	/* calculates (frags / fs->fs_frag) */ \
+	((frags) >> (fs)->fs_fragshift)
+#define blkstofrags(fs, blks)	/* calculates (blks * fs->fs_frag) */ \
+	((blks) << (fs)->fs_fragshift)
+#define fragnum(fs, fsb)	/* calculates (fsb % fs->fs_frag) */ \
+	((fsb) & ((fs)->fs_frag - 1))
+#define blknum(fs, fsb)		/* calculates rounddown(fsb, fs->fs_frag) */ \
+	((fsb) &~ ((fs)->fs_frag - 1))
+
+/*
+ * Determine the number of available frags given a
+ * percentage to hold in reserve.
+ */
+#define freespace(fs, percentreserved) \
+	(blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \
+	(fs)->fs_cstotal.cs_nffree - \
+	(((off_t)((fs)->fs_dsize)) * (percentreserved) / 100))
+
+/*
+ * Determining the size of a file block in the filesystem.
+ */
+#define blksize(fs, ip, lbn) \
+	(((lbn) >= NDADDR || (ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \
+	    ? (fs)->fs_bsize \
+	    : (fragroundup(fs, blkoff(fs, (ip)->i_size))))
+#define sblksize(fs, size, lbn) \
+	(((lbn) >= NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \
+	  ? (fs)->fs_bsize \
+	  : (fragroundup(fs, blkoff(fs, (size)))))
+
+
+/*
+ * Number of inodes in a secondary storage block/fragment.
+ */
+#define	INOPB(fs)	((fs)->fs_inopb)
+#define	INOPF(fs)	((fs)->fs_inopb >> (fs)->fs_fragshift)
+
+/*
+ * Number of indirects in a filesystem block.
+ */
+#define	NINDIR(fs)	((fs)->fs_nindir)
+
+extern int inside[], around[];
+extern char *fragtbl[];
+
+struct ufs_dirent {
+	uint32_t d_fileno;		/* file number of entry */
+	uint16_t d_reclen;		/* length of this record */
+	uint8_t  d_type; 		/* file type, see below */
+	uint8_t  d_namlen;		/* length of string in d_name */
+#define	MAXNAMLEN	255
+	char	d_name[MAXNAMLEN + 1];	/* name must be no longer than this */
+};
+
+/*
+ * File types
+ */
+#define	DT_UNKNOWN	 0
+#define	DT_FIFO		 1
+#define	DT_CHR		 2
+#define	DT_DIR		 4
+#define	DT_BLK		 6
+#define	DT_REG		 8
+#define	DT_LNK		10
+#define	DT_SOCK		12
+#define	DT_WHT		14
+
+/* XXX: We hardcode BSIZE and BSIZE_SHIFT here. fsys_ffs seems to do the same,
+ *      so we should get away with it :-) */
+#define DEV_BSIZE	512
+#define DEV_BSHIFT 	9		/* 2**9 = 512 */
+#define MAXBSIZE	65536
+
+typedef unsigned int ino_t;
+
+#endif
diff -rubB --new-file cromwell/include/linux_wrapper.h cromwell-ufs/include/linux_wrapper.h
--- cromwell/include/linux_wrapper.h	Mon Nov 22 00:48:27 2004
+++ cromwell-ufs/include/linux_wrapper.h	Thu Aug  4 12:04:08 2005
@@ -36,7 +36,7 @@
 #ifndef STANDALONE
 typedef int mode_t;
 typedef int pid_t;
-typedef int ssize_t;
+/*typedef int ssize_t;		-> this is in stdint.h now */
 
 #endif
 typedef int irqreturn_t;
diff -rubB --new-file cromwell/include/stdint.h cromwell-ufs/include/stdint.h
--- cromwell/include/stdint.h	Sat May  1 12:05:51 2004
+++ cromwell-ufs/include/stdint.h	Thu Aug  4 12:02:06 2005
@@ -2,6 +2,7 @@
 #define STDINT_H
 
 typedef unsigned           size_t;
+typedef signed             ssize_t;
 
 typedef unsigned char      uint8_t;
 typedef unsigned short     uint16_t;
