[U-Boot] [PATCH]: FFS/UFS filesystems support

Stanislav Sedov stas at FreeBSD.org
Mon Nov 3 13:54:48 CET 2008


-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On Sun, 02 Nov 2008 16:30:57 +0100
Wolfgang Denk <wd at denx.de> mentioned:
> 
> Please send plain text, no fancy MIME multipart stuff.
> 

Ok,  I was not aware of this policy.

There's a new version of the patch. I've also changed the
license to GPL where possible.
Thanks!

Signed-off-by:	Stanislav Sedov <stas at FreeBSD.org>
diff -r 83d0dd6dceee Makefile
- --- a/Makefile	Mon Nov 03 10:32:53 2008 +0300
+++ b/Makefile	Mon Nov 03 15:49:29 2008 +0300
@@ -214,8 +214,9 @@
 LIBS += cpu/ixp/npe/libnpe.a
 endif
 LIBS += lib_$(ARCH)/lib$(ARCH).a
- -LIBS += fs/cramfs/libcramfs.a fs/fat/libfat.a fs/fdos/libfdos.a fs/jffs2/libjffs2.a \
- -	fs/reiserfs/libreiserfs.a fs/ext2/libext2fs.a fs/yaffs2/libyaffs2.a
+LIBS += fs/cramfs/libcramfs.a fs/fat/libfat.a fs/fdos/libfdos.a fs/ffs/libffs.a \
+	fs/jffs2/libjffs2.a fs/reiserfs/libreiserfs.a fs/ext2/libext2fs.a \
+	fs/yaffs2/libyaffs2.a
 LIBS += net/libnet.a
 LIBS += disk/libdisk.a
 LIBS += drivers/bios_emulator/libatibiosemu.a
diff -r 83d0dd6dceee common/Makefile
- --- a/common/Makefile	Mon Nov 03 10:32:53 2008 +0300
+++ b/common/Makefile	Mon Nov 03 15:49:29 2008 +0300
@@ -88,6 +88,7 @@
 COBJS-$(CONFIG_CMD_FDC)$(CONFIG_CMD_FDOS) += cmd_fdc.o
 COBJS-$(CONFIG_OF_LIBFDT) += cmd_fdt.o fdt_support.o
 COBJS-$(CONFIG_CMD_FDOS) += cmd_fdos.o
+COBJS-$(CONFIG_CMD_FFS) += cmd_ffs.o
 COBJS-$(CONFIG_CMD_FLASH) += cmd_flash.o
 ifdef CONFIG_FPGA
 COBJS-y += fpga.o
diff -r 83d0dd6dceee common/cmd_ffs.c
- --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/common/cmd_ffs.c	Mon Nov 03 15:49:29 2008 +0300
@@ -0,0 +1,212 @@
+/*-
+ * Copyright (c) 2008 Deglitch Networks http://www.deglitch.com/
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ * FFS/UFS filesystem driver.
+ * Author: Stanislav Sedov <stas at FreeBSD.org>
+ */
+#include <common.h>
+#include <part.h>
+#include <config.h>
+#include <command.h>
+#include <image.h>
+#include <asm/byteorder.h>
+#include <ffs.h>
+#if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE)
+#include <usb.h>
+#endif
+
+#if !defined(CONFIG_DOS_PARTITION) && !defined(CONFIG_EFI_PARTITION)
+#error DOS or EFI partition support must be selected
+#endif
+
+int
+ffs_parse_device_spec(char *iface, const char *str,
+    block_dev_desc_t **desc, long *dev, long *part)
+{
+	char *ep, *p;
+
+	*dev = simple_strtoul(str, &ep, 16);
+	if ((*ep != '\0' && *ep != ':') || *str == '\0') {
+		printf("Error: invalid device number: %s\n", str);
+		return (1);
+	}
+
+	*desc = get_dev(iface, *dev);
+	if (*desc == NULL) {
+		printf("Error: block device %ld on %s is not supported\n",
+		    *dev, iface);
+		return (1);
+	}
+
+	if (*ep) {
+		p = ++ep;
+		*part = simple_strtoul(p, &ep, 16);
+		if (p == '\0' || *ep != '\0') {
+			printf("Error: invalid partition number %s\n", p);
+			return (1);
+		}
+	} else {
+		*part = 0;	/* Whole disk. */
+	}
+	return (0);
+}
+
+int
+do_ffs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+	char *filename;
+	long dev, part;
+	block_dev_desc_t *dev_desc;
+	int error;
+
+	if (argc < 3) {
+		printf("Usage:\n%s\n", cmdtp->usage);
+		return (1);
+	}
+
+	error = ffs_parse_device_spec(argv[1], argv[2], &dev_desc, &dev, &part);
+	if (error != 0)
+		return (error);
+
+	filename = argc == 4 ? argv[3] : "/";
+	error = ffs_probe(dev_desc, part);
+	if (error != 0) {
+		printf("Error: could not mount %ld dev %ld part on %s: %d\n",
+		    dev, part, argv[1], error);
+		return (1);
+	}
+
+	error = ffs_ls(dev_desc, part, filename);
+	if (error != 0) {
+		printf("Error: ffs_ls: %d\n", error);
+		return (1);
+	}
+	return (0);
+}
+
+int
+do_ffs_load(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+{
+	char *filename;
+	long dev, part;
+	unsigned long addr, length;
+	block_dev_desc_t *dev_desc;
+	char buf[12];
+	unsigned long count;
+	char *str, *ep;
+	int error;
+
+	if (argc >= 4) {	/* loadaddr is given. */
+		addr = simple_strtoul(argv[3], &ep, 16);
+		if (*ep != '\0' || *argv[3] == '\0') {
+			printf("Error: invalid load address: %s\n", argv[3]);
+			return (1);
+		}
+	} else {
+		str = getenv("loadaddr");
+		if (str != NULL) {
+			addr = simple_strtoul(str, &ep, 16);
+			if (*ep != '\0' || *argv[3] == '\0') {
+				printf("Error: invalid load address: %s\n",
+				    argv[3]);
+				return (1);
+			}
+		} else {
+			addr = CONFIG_SYS_LOAD_ADDR;
+		}
+	}
+
+	if (argc >= 5)		/* filename is given. */
+		filename = argv[4];
+	else
+		filename = getenv("bootfile");
+	if (filename == NULL || filename == '\0') {
+		printf("Error: no filename to load\n");
+		return (1);
+	}
+
+	if (argc == 6) {	/* count is given. */
+		count = simple_strtoul(argv[5], &ep, 16);
+		if (*ep != '\0' || *argv[5] == '\0') {
+			printf("Error: invalid count specification: %s\n",
+			    argv[5]);
+			return (1);
+		}
+	} else {
+		count = 0;
+	}
+
+	if (argc < 3 || argc > 6) {	/* Catch up on errors. */
+		printf("Usage:\n%s\n", cmdtp->usage);
+		return (1);
+	}
+
+	error = ffs_parse_device_spec(argv[1], argv[2], &dev_desc, &dev, &part);
+	if (error != 0)
+		return (error);
+
+	error = ffs_probe(dev_desc, part);
+	if (error != 0) {
+		printf("Error: could not mount %ld dev %ld part on %s: %d\n",
+		    dev, part, argv[1], error);
+		return (1);
+	}
+
+	error = ffs_getfilelength(dev_desc, part, filename, &length);
+	if (error != 0) {
+		printf("Error: file not found: %s\n", filename);
+		return (1);
+	}
+	if ((count < length) && (count != 0))
+		length = count;
+
+	error = ffs_read(dev_desc, part, filename, (char *)addr, length);
+	if (error != 0) {
+		printf("Error reading %ld bytes from %s", length, filename);
+		return (1);
+	}
+
+	load_addr = addr;		/* Update load address. */
+	sprintf(buf, "%lX", length);
+	setenv("filesize", buf);	/* Update filesize. */
+
+	return (length);
+}
+
+
+/*
+ * U-boot drop-in's.
+ */
+
+U_BOOT_CMD(
+	ffsls, 4, 1, do_ffs_ls,
+	"ffsls   - list files in a directory (default /)\n",
+	"<interface> <dev[:part]> [directory]\n"
+	"    - list directory of device 'dev' partition 'part' at 'interface'\n"
+);
+
+U_BOOT_CMD(
+	ffsload, 6, 0, do_ffs_load,
+	"ffsload - load binary file from a FFS filesystem\n",
+	"<interface> <dev[:part]> [addr] [filename] [bytes]\n"
+	"    - load binary file from device 'dev' partition 'part'\n"
+	"      at 'interface' to address 'addr'\n"
+);
diff -r 83d0dd6dceee fs/Makefile
- --- a/fs/Makefile	Mon Nov 03 10:32:53 2008 +0300
+++ b/fs/Makefile	Mon Nov 03 15:49:29 2008 +0300
@@ -26,6 +26,7 @@
 subdirs-$(CONFIG_CMD_EXT2) += ext2
 subdirs-$(CONFIG_CMD_FAT) += fat
 subdirs-$(CONFIG_CMD_FDOS) += fdos
+subdirs-$(CONFIG_CMD_FFS) += ffs
 subdirs-$(CONFIG_CMD_JFFS2) += jffs2
 subdirs-$(CONFIG_CMD_REISER) += reiserfs
 subdirs-$(CONFIG_YAFFS2) += yaffs2
diff -r 83d0dd6dceee fs/ffs/Makefile
- --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fs/ffs/Makefile	Mon Nov 03 15:49:29 2008 +0300
@@ -0,0 +1,52 @@
+#
+# (C) Copyright 2006
+# Wolfgang Denk, DENX Software Engineering, wd at denx.de.
+#
+# (C) Copyright 2003
+# Pavel Bartusek, Sysgo Real-Time Solutions AG, pba at sysgo.de
+#
+#
+# See file CREDITS for list of people who contributed to this
+# project.
+#
+# 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., 59 Temple Place, Suite 330, Boston,
+# MA 02111-1307 USA
+#
+
+include $(TOPDIR)/config.mk
+
+LIB	= $(obj)libffs.a
+
+AOBJS	=
+COBJS	= ffs.o
+
+SRCS	:= $(AOBJS:.o=.S) $(COBJS:.o=.c)
+OBJS	:= $(addprefix $(obj),$(AOBJS) $(COBJS))
+
+#CPPFLAGS +=
+
+all:	$(LIB) $(AOBJS)
+
+$(LIB):	$(obj).depend $(OBJS)
+	$(AR) $(ARFLAGS) $@ $(OBJS)
+
+#########################################################################
+
+# defines $(obj).depend target
+include $(SRCTREE)/rules.mk
+
+sinclude $(obj).depend
+
+#########################################################################
diff -r 83d0dd6dceee fs/ffs/ffs.c
- --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fs/ffs/ffs.c	Mon Nov 03 15:49:29 2008 +0300
@@ -0,0 +1,670 @@
+/*-
+ * Copyright (c) 2008 Stanislav Sedov <stas at FreeBSD.org>.
+ * All rights reserved.
+ * 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.
+ */
+
+#include <common.h>
+#include <config.h>
+
+#if defined(CONFIG_CMD_FFS)
+#include <ffs_dinode.h>
+#include <ffs_fs.h>
+#include <ffs.h>
+#include <malloc.h>
+
+/*
+ * We use 4k `virtual' blocks for filesystem data, whatever the actual
+ * filesystem block size. FFS blocks are always a multiple of 4k.
+ */
+#define	DEV_BSHIFT	9	/* log2(DEV_BSIZE) */
+#define	DEV_BSIZE	(1<<DEV_BSHIFT)
+#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)
+#define	DIP(node, field)	((node)->ver == 1 ? (node)->inode1.field : \
+				    (node)->inode2.field)
+
+
+/*
+ * 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
+
+#define	MAXBSIZE	65536
+
+struct 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 */
+};
+typedef struct {
+	struct fs		fs;
+	block_dev_desc_t	*dev;
+	long			part;
+	uint8_t			ver;
+} ffs_mount_t;
+typedef struct {
+	union {
+		struct ufs1_dinode	inode1;
+		struct ufs2_dinode	inode2;
+	};
+	ffs_mount_t	*mount;
+	uint8_t		ver;
+} ffs_node_t;
+
+/*
+ * Convert between stat structure types and directory types.
+ */
+#define IFTODT(mode)    (((mode) & 0170000) >> 12)
+#define DTTOIF(dirtype) ((dirtype) << 12)
+
+static ino_t	lookup(ffs_mount_t *mount, const char *path);
+static ssize_t	fsread(ffs_mount_t *mount, ffs_node_t *node, void *buf,
+    size_t len, uint32_t off);
+static int	ffs_open(ffs_mount_t *mount, ino_t ino, ffs_node_t *node);
+
+static int
+dskread(block_dev_desc_t *desc, long part, void *buf, unsigned lba,
+    unsigned int nblk)
+{
+	disk_partition_t pinfo;
+	int error;
+
+	if (part == 0) {
+		pinfo.start = 0;
+		pinfo.size = desc->lba;
+		pinfo.blksz = desc->blksz;
+	} else {
+		error = get_partition_info(desc, part, &pinfo);
+		if (error != 0)
+			return (error);
+	}
+	if (lba >= pinfo.size) {
+		printf("Error: reading outside the partition size\n");
+		return (1);
+	}
+	error = desc->block_read(desc->dev, pinfo.start + lba, nblk, buf);
+	if (error != nblk) {
+		printf("Error: not all blocks read: wanted %d got %d\n", nblk,
+		    error);
+		return (1);
+	}
+	return (0);
+}
+
+static int
+fsfind(ffs_mount_t *mount, const char *name, ino_t *ino)
+{
+	char buf[DEV_BSIZE];
+	struct dirent *d;
+	char *s;
+	ssize_t n;
+	uint32_t off;
+	ffs_node_t *node = NULL;
+	int error;
+
+	node = (ffs_node_t *)malloc(sizeof(*node));
+	if (node == NULL) {
+		printf("Error: allocating %ld bytes failed.\n", sizeof(*node));
+		return (0);
+	}
+	error = ffs_open(mount, *ino, node);
+	if (error != 0) {
+		printf("Error: could not read inode.\n");
+		free(node);
+		return (0);
+	}
+	off = 0;
+	while ((n = fsread(mount, node, buf, DEV_BSIZE, off)) > 0) {
+		for (s = buf; s < buf + DEV_BSIZE;) {
+			d = (void *)s;
+			if (!strcmp(name, d->d_name)) {
+				*ino = d->d_fileno;
+				free(node);
+				return (d->d_type);
+			}
+			s += d->d_reclen;
+		}
+		off += n;
+	}
+	free(node);
+	return (0);
+}
+
+static ino_t
+lookup(ffs_mount_t *mount, 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++);
+		n = s - path;
+		if (n > MAXNAMLEN)
+			return (0);
+		memcpy(name, path, n);
+		name[n] = 0;
+		if (dt != DT_DIR) {
+			printf("%s: not a directory.\n", name);
+			return (0);
+		}
+		if ((dt = fsfind(mount, name, &ino)) <= 0)
+			break;
+		path = s;
+	}
+	return (ino);
+}
+
+/*
+ * Possible superblock locations ordered from most to least likely.
+ */
+static int sblocksearch[] = SBLOCKSEARCH;
+
+static int
+ffs_mount(block_dev_desc_t *desc, long part, ffs_mount_t *mount)
+{
+	int i;
+	struct fs *buf;
+	int error;
+
+	assert(mount != NULL);
+	buf = (struct fs *)malloc(SBLOCKSIZE);
+	if (buf == NULL) {
+		printf("Error: allocating buffer of size %d failed.\n",
+		    SBLOCKSIZE);
+		return (-1);
+	}
+
+	/*
+	 * Try to read the superblock.
+	 */
+	for (i = 0; sblocksearch[i] != -1; i++) {
+		error = dskread(desc, part, buf, sblocksearch[i] / DEV_BSIZE,
+		    SBLOCKSIZE / DEV_BSIZE);
+		if (error != 0) {
+			printf("Error reading superblock.\n");
+			free(buf);
+			return (-1);
+		}
+		/* Check for correct block size. */
+		if (buf->fs_bsize > MAXBSIZE ||
+		    buf->fs_bsize < sizeof(struct fs))
+			continue;
+		/* Check for magic. */
+		if (buf->fs_magic == FS_UFS1_MAGIC) {
+			mount->ver = 1;
+			break;
+		}
+		if (buf->fs_magic == FS_UFS2_MAGIC &&
+		    buf->fs_sblockloc == sblocksearch[i]) {
+			mount->ver = 2;
+			break;
+		}
+	}
+	if (sblocksearch[i] == -1) {
+		printf("UFS superblock was not found.\n");
+		free(buf);
+		return(-1);
+	}
+	mount->dev = desc;
+	mount->part = part;
+	memcpy(&mount->fs, buf, sizeof(struct fs));
+	free(buf);
+	return (0);
+}
+
+static int
+ffs_open(ffs_mount_t *mount, ino_t ino, ffs_node_t *node)
+{
+	size_t ipervblk, i_off, len;
+	struct fs *fs;
+	char *blkbuf;
+	int error;
+
+	assert(node != NULL);
+	assert(ino != 0);
+	fs = &mount->fs;
+
+	blkbuf = (char *)malloc(VBLKSIZE);
+	if (blkbuf == NULL) {
+		printf("Error: allocating buffer of size %d failed.\n",
+		    VBLKSIZE);
+		return (-1);
+	}
+
+	/*
+	 * Read the inode requested.
+	 */
+	ipervblk = IPERVBLK(fs);
+	error = dskread(mount->dev, mount->part, blkbuf,
+	    INO_TO_VBA(fs, ipervblk, ino), DBPERVBLK);
+	if (error != 0) {
+		printf("Error reading inode.\n");
+		free(blkbuf);
+		return (-1);
+	}
+	node->mount = mount;
+	node->ver = mount->ver;
+	i_off = INO_TO_VBO(ipervblk, ino);
+	if (mount->ver == 1) {
+		len = sizeof(struct ufs1_dinode);
+		memcpy(&node->inode1, blkbuf + i_off * len, len);
+	} else {
+		len = sizeof(struct ufs2_dinode);
+		memcpy(&node->inode2, blkbuf + i_off * len, len);
+	}
+	free(blkbuf);
+	return (0);
+}
+
+static ssize_t
+fsread(ffs_mount_t *mount, ffs_node_t *node, void *buf, size_t len,
+    uint32_t off)
+{
+	char *blkbuf = NULL;
+	void *indbuf = NULL;
+	size_t left, size, f_off, vboff;
+	ufs_lbn_t f_lbn;
+	ufs2_daddr_t addr, vbaddr;
+	int i, n;
+	int error;
+	int indirpervblk;
+	struct fs *fs;
+
+	assert(mount != NULL);
+	assert(node != NULL);
+
+	/*
+	 * Allocate work memory.
+	 */
+	blkbuf = (char *)malloc(VBLKSIZE);
+	indbuf = malloc(VBLKSIZE);
+	if (blkbuf == NULL || indbuf == NULL) {
+		printf("Error: allocating buffers of size %d failed.\n",
+		    VBLKSIZE);
+		error = -1;
+		goto fail;
+	}
+
+	fs = &mount->fs;
+	size = DIP(node, di_size);
+	n = size - off;
+	if (len > n)
+		len = n;
+	left = len;
+	while (left > 0) {
+		f_lbn = lblkno(fs, off);	/* Block number of the file. */
+		f_off = blkoff(fs, off);	/* Offset in the file block. */
+
+		/*
+		 * Get the address of the block requested.
+		 */
+		if (f_lbn < NDADDR) {
+			addr = DIP(node, di_db[f_lbn]);
+		} else if (f_lbn < NDADDR + NINDIR(fs)) {
+			/*
+			 * Try to read the block map table.
+			 */
+			indirpervblk = INDIRPERVBLK(fs);
+			addr = DIP(node, di_ib[0]);
+			vbaddr = fsbtodb(fs, addr) +	/* Block map address. */
+			    (f_lbn - NDADDR) / (indirpervblk * DBPERVBLK);
+			error = dskread(mount->dev, mount->part, indbuf,
+			    vbaddr, DBPERVBLK);
+			if (error != 0) {
+				printf("Error reading indirect block map.\n");
+				error = -1;
+				goto fail;
+			}
+			/* Offset in the table. */
+			i = (f_lbn - NDADDR) & (indirpervblk - 1);
+			if (fs->fs_magic == FS_UFS1_MAGIC)
+				addr = ((ufs1_daddr_t *)indbuf)[i];
+			else
+				addr = ((ufs2_daddr_t *)indbuf)[i];
+		} else {
+			printf("Error: double-indirect blocks are not"
+			    " supported (yet).");
+			goto fail;
+		}
+
+		/*
+		 * Read the block itself.
+		 */
+		vbaddr = fsbtodb(fs, addr) + (f_off >> VBLKSHIFT) * DBPERVBLK;
+		vboff = f_off & VBLKMASK;
+		i = sblksize(fs, size, f_lbn) - (f_off & ~VBLKMASK);
+		if (i > VBLKSIZE)
+			i = VBLKSIZE;
+		error = dskread(mount->dev, mount->part, blkbuf, vbaddr,
+		    i >> DEV_BSHIFT);
+		if (error != 0) {
+			printf("Error reading data block.\n");
+			error = -1;
+			goto fail;
+		}
+		i -= vboff;
+		if (i > left)
+			i = left;
+		memcpy(buf, blkbuf + vboff, i);
+		buf += i;
+		off += i;
+		left -= i;
+	}
+	error = len;
+
+fail:
+	if (blkbuf != NULL)
+		free(blkbuf);
+	if (indbuf != NULL)
+		free(indbuf);
+	return (error);
+}
+
+int
+ffs_probe(block_dev_desc_t *desc, long part)
+{
+	ffs_mount_t *mount = NULL;
+	int error;
+
+	mount = (ffs_mount_t *)malloc(sizeof(*mount));
+	if (mount == NULL) {
+		printf("Error: allocating %ld bytes failed.\n", sizeof(*mount));
+		return (1);
+	}
+
+	/*
+	 * Try to mount the fs.
+	 */
+	error = ffs_mount(desc, part, mount);
+	free(mount);
+	return (error);
+}
+
+int
+ffs_getfilelength(block_dev_desc_t *desc, long part, const char *filename,
+    unsigned long *len)
+{
+	ffs_mount_t *mount = NULL;
+	ffs_node_t *node = NULL;
+	ino_t ino;
+	int error;
+
+	mount = (ffs_mount_t *)malloc(sizeof(*mount));
+	if (mount == NULL) {
+		printf("Error: allocating %ld bytes failed.\n", sizeof(*mount));
+		return (1);
+	}
+
+	/*
+	 * Try to mount the fs.
+	 */
+	error = ffs_mount(desc, part, mount);
+	if (error != 0) {
+		printf("Error: could not mount the filesystem.\n");
+		goto fail;
+	}
+
+	ino = lookup(mount, filename);
+	if (ino == 0) {
+		error = 1;
+		goto fail;
+	}
+
+	/*
+	 * Open the file.
+	 */
+	node = (ffs_node_t *)malloc(sizeof(*node));
+	if (node == NULL) {
+		printf("Error: allocating %ld bytes failed.\n", sizeof(*node));
+		error = 1;
+		goto fail;
+	}
+	error = ffs_open(mount, ino, node);
+	if (error != 0)
+		printf("Error: could not read inode.\n");
+	else
+		*len = DIP(node, di_size);
+fail:
+	if (mount != NULL)
+		free(mount);
+	return (error);
+}
+
+int
+ffs_ls(block_dev_desc_t *desc, long part, const char *filename)
+{
+	char buf[DEV_BSIZE];
+	struct dirent *d;
+	char *s;
+	ssize_t n;
+	ino_t ino;
+	uint32_t off;
+	ffs_mount_t *mount = NULL;
+	ffs_node_t *node = NULL, *fnode = NULL;
+	int error;
+
+	if (*filename == '\0') {
+		printf("Error: empty filename\n");
+		return (1);
+	}
+
+	mount = (ffs_mount_t *)malloc(sizeof(*mount));
+	if (mount == NULL) {
+		printf("Error: allocating %ld bytes failed.\n", sizeof(*mount));
+		return (1);
+	}
+
+	/*
+	 * Try to mount the fs.
+	 */
+	error = ffs_mount(desc, part, mount);
+	if (error != 0) {
+		printf("Error: could not mount the filesystem.\n");
+		error = 1;
+		goto fail;
+	}
+
+	/*
+	 * Try to locate the file.
+	 */
+	ino = lookup(mount, filename);
+	if (ino == 0) {
+		printf("Error: not found\n");
+		error = 1;
+		goto fail;
+	}
+
+	/*
+	 * Open the directory file and read it.
+	 */
+	node = (ffs_node_t *)malloc(sizeof(*node));
+	fnode = (ffs_node_t *)malloc(sizeof(*fnode));
+	if (node == NULL || fnode == NULL) {
+		printf("Error: allocating %ld bytes failed.\n",
+		    2 * sizeof(*node));
+		error = 1;
+		goto fail;
+	}
+	error = ffs_open(mount, ino, node);
+	if (error != 0) {
+		printf("Error: could not read inode.\n");
+		error = 1;
+		goto fail;
+	}
+
+	off = 0;
+	printf("%-8s%-15s%s\n", "INODE", "SIZE", "NAME");
+	while ((n = fsread(mount, node, buf, DEV_BSIZE, off)) > 0) {
+		for (s = buf; s < buf + DEV_BSIZE;) {
+			d = (void *)s;
+			s += d->d_reclen;
+			error = ffs_open(mount, d->d_fileno, fnode);
+			if (error != 0) {
+				printf("Error: could not open file %s\n",
+				    d->d_name);
+				continue;
+			}
+			printf("%-8d%-15d%s", d->d_fileno,
+			    (int)DIP(fnode, di_size), d->d_name);
+			if (d->d_type == DT_DIR)
+				printf("/");
+			printf("\n");
+		}
+		off += n;
+	}
+	printf("\n");
+	error = 0;
+fail:
+	if (node != NULL)
+		free(node);
+	if (fnode != NULL)
+		free(fnode);
+	if (mount != NULL)
+		free(mount);
+	return (error);
+}
+
+int
+ffs_read(block_dev_desc_t *desc, long part, const char *filename, char *addr,
+    unsigned long len)
+{
+	ino_t ino;
+	int error;
+	ffs_mount_t *mount = NULL;
+	ffs_node_t *node = NULL;
+
+	if (*filename == '\0') {
+		printf("Error: empty filename\n");
+		return (1);
+	}
+
+	mount = (ffs_mount_t *)malloc(sizeof(*mount));
+	if (mount == NULL) {
+		printf("Error: allocating %ld bytes failed.\n", sizeof(*mount));
+		return (1);
+	}
+
+	/*
+	 * Try to mount the fs.
+	 */
+	error = ffs_mount(desc, part, mount);
+	if (error != 0) {
+		printf("Error: could not mount the filesystem.\n");
+		error = 1;
+		goto fail;
+	}
+
+	/*
+	 * Try to locate the file.
+	 */
+	ino = lookup(mount, filename);
+	if (ino == 0) {
+		printf("Error: not found\n");
+		error = 1;
+		goto fail;
+	}
+
+	/*
+	 * Open the file and read it.
+	 */
+	node = (ffs_node_t *)malloc(sizeof(*node));
+	if (node == NULL) {
+		printf("Error: allocating %ld bytes failed.\n", sizeof(*node));
+		error = 1;
+		goto fail;
+	}
+	error = ffs_open(mount, ino, node);
+	if (error != 0) {
+		printf("Error: could not read inode.\n");
+		error = 1;
+		goto fail;
+	}
+	error = fsread(mount, node, addr, len, 0);
+	if (error != len) {
+		printf("Error: not all data read: wanted %ld got %d\n", len,
+		    error);
+		error = 1;
+	} else
+		error = 0;
+fail:
+	if (node != NULL)
+		free(node);
+	if (mount != NULL)
+		free(mount);
+	return (error);
+}
+#endif
diff -r 83d0dd6dceee include/ffs.h
- --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/ffs.h	Mon Nov 03 15:49:29 2008 +0300
@@ -0,0 +1,32 @@
+/*-
+ * Copyright (c) 2008 Deglitch Networks http://www.deglitch.com/
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ * Author: Stanislav Sedov <stas at FreeBSD.org>
+ */
+#ifndef _FFS_H_
+#define	_FFS_H_
+int	ffs_probe(block_dev_desc_t *desc, long part);
+int	ffs_ls(block_dev_desc_t *desc, long part, const char *filename);
+int	ffs_read(block_dev_desc_t *desc, long part, const char *filename,
+    char *addr, unsigned long len);
+int	ffs_getfilelength(block_dev_desc_t *desc, long part,
+    const char *filename, unsigned long *len);
+#endif	/* !_FFS_H_ */
diff -r 83d0dd6dceee include/ffs_dinode.h
- --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/ffs_dinode.h	Mon Nov 03 15:49:29 2008 +0300
@@ -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.17 2006/05/21 21:55:29 maxim 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_WHT 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 {
+	u_int16_t	di_mode;	/*   0: IFMT, permissions; see below. */
+	int16_t		di_nlink;	/*   2: File link count. */
+	u_int32_t	di_uid;		/*   4: File owner. */
+	u_int32_t	di_gid;		/*   8: File group. */
+	u_int32_t	di_blksize;	/*  12: Inode blocksize. */
+	u_int64_t	di_size;	/*  16: File byte count. */
+	u_int64_t	di_blocks;	/*  24: Blocks 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. */
+	u_int32_t	di_kernflags;	/*  84: Kernel flags. */
+	u_int32_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 {
+	u_int16_t	di_mode;	/*   0: IFMT, permissions; see below. */
+	int16_t		di_nlink;	/*   2: File link count. */
+	union {
+		u_int16_t oldids[2];	/*   4: Ffs: old user and group ids. */
+	} di_u;
+	u_int64_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. */
+	u_int32_t	di_flags;	/* 100: Status flags (chflags). */
+	int32_t		di_blocks;	/* 104: Blocks actually held. */
+	int32_t		di_gen;		/* 108: Generation number. */
+	u_int32_t	di_uid;		/* 112: File owner. */
+	u_int32_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 -r 83d0dd6dceee include/ffs_fs.h
- --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/include/ffs_fs.h	Mon Nov 03 15:49:29 2008 +0300
@@ -0,0 +1,616 @@
+/*-
+ * 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.49 2006/10/31 21:48:53 pjd 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 at 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 */
+	u_char	 fs_fsmnt[MAXMNTLEN];	/* name mounted on */
+	u_char	 fs_volname[MAXVOLLEN];	/* volume name */
+	u_int64_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 */
+	u_int8_t *fs_contigdirs;	/* (u) # of contig. allocated dirs */
+	struct	csum *fs_csp;		/* (u) cg summary info buffer */
+	int32_t	*fs_maxcluster;		/* (u) max cluster in each cyl group */
+	u_int	*fs_active;		/* (u) 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_unrefs;		/* number of unreferenced inodes */
+	int64_t	 fs_sparecon64[16];	/* old rotation block list head */
+	int64_t	 fs_sblockloc;		/* byte offset of standard superblock */
+	struct	csum_total fs_cstotal;	/* (u) 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;	/* (u) blocks being freed */
+	int32_t	 fs_pendinginodes;	/* (u) inodes 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 */
+	u_int64_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_GJOURNAL   0x40	/* gjournaled file system */
+#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))))
+#define	ACTIVESET(fs, cg)	do {					\
+	if ((fs)->fs_active)						\
+		ACTIVECGNUM((fs), (cg)) |= ACTIVECGOFF((cg));		\
+} while (0)
+#define	ACTIVECLEAR(fs, cg)	do {					\
+	if ((fs)->fs_active)						\
+		ACTIVECGNUM((fs), (cg)) &= ~ACTIVECGOFF((cg));		\
+} while (0)
+
+/*
+ * 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(u_int16_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;		/* (u_int16) free block positions */
+	int32_t	 cg_iusedoff;		/* (u_int8) used inode map */
+	int32_t	 cg_freeoff;		/* (u_int8) free block map */
+	int32_t	 cg_nextfreeoff;	/* (u_int8) next available space */
+	int32_t	 cg_clustersumoff;	/* (u_int32) counts of avail clusters */
+	int32_t	 cg_clusteroff;		/* (u_int8) 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_unrefs;		/* number of unreferenced inodes */
+	int32_t	 cg_sparecon32[2];	/* reserved for future use */
+	ufs_time_t cg_time;		/* time last written */
+	int64_t	 cg_sparecon64[3];	/* reserved for future use */
+	u_int8_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) \
+    ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_iusedoff))
+#define cg_blksfree(cgp) \
+    ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_freeoff))
+#define cg_clustersfree(cgp) \
+    ((u_int8_t *)((u_int8_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)	((daddr_t)(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 u_char *fragtbl[];
+
+#endif

- -- 
Stanislav Sedov
ST4096-RIPE
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.9 (FreeBSD)

iEYEARECAAYFAkkO9J0ACgkQK/VZk+smlYERMACdEOzbU0oppENNTax/R2hHs95q
eOMAoIPoUa3EnHCHtzG58M+WDUcJ3Y0J
=2FXJ
-----END PGP SIGNATURE-----


More information about the U-Boot mailing list