A GEOM cache can speed up read performance by sending fixed size

read requests to its consumer.  It has been developed to address
the problem of a horrible read performance of a 64k blocksize FS
residing on a RAID3 array with 8 data components, where a single
disk component would only get 8k read requests, thus effectively
killing disk performance under high load.  Documentation will be
provided later.  I'd like to thank Vsevolod Lobko for his bright
ideas, and Pawel Jakub Dawidek for helping me fix the nasty bug.

etc/mtree/BSD.include.dist

@@ -100,6 +100,8 @@
         ..
     ..
     geom
+        cache
+        ..
         concat
         ..
         eli

include/Makefile

@@ -45,8 +45,8 @@ LSUBDIRS=	cam/scsi \
 	fs/devfs fs/fdescfs fs/fifofs fs/msdosfs fs/ntfs fs/nullfs \
 	${_fs_nwfs} fs/portalfs fs/procfs fs/smbfs fs/udf fs/umapfs \
 	fs/unionfs \
-	geom/concat geom/eli geom/gate geom/label geom/mirror geom/nop \
-	geom/raid3 geom/shsec geom/stripe \
+	geom/cache geom/concat geom/eli geom/gate geom/label geom/mirror \
+	geom/nop geom/raid3 geom/shsec geom/stripe \
 	isofs/cd9660 \
 	netatm/ipatm netatm/sigpvc netatm/spans netatm/uni \
 	netgraph/atm netgraph/netflow \

sbin/geom/class/Makefile

@@ -2,7 +2,8 @@
 
 .include <bsd.own.mk>
 
-SUBDIR=	concat
+SUBDIR=	cache
+SUBDIR+=concat
 .if ${MK_OPENSSL} != "no"
 SUBDIR+=eli
 .endif

sbin/geom/class/cache/Makefile

@@ -0,0 +1,8 @@
+# $FreeBSD$
+
+.PATH: ${.CURDIR}/../../misc
+
+CLASS=	cache
+NO_MAN=	# notyet
+
+.include <bsd.lib.mk>

sbin/geom/class/cache/geom_cache.c

@@ -0,0 +1,241 @@
+/*-
+ * Copyright (c) 2006 Ruslan Ermilov <ru@FreeBSD.org>
+ * 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.
+ *
+ * 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.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+#include <libgeom.h>
+#include <geom/cache/g_cache.h>
+
+#include "core/geom.h"
+#include "misc/subr.h"
+
+
+uint32_t lib_version = G_LIB_VERSION;
+uint32_t version = G_CACHE_VERSION;
+
+static intmax_t blocksize_label = 65536;
+static intmax_t size_label = 100;
+static intmax_t blocksize_configure = 0;
+static intmax_t size_configure = 0;
+
+static void cache_main(struct gctl_req *req, unsigned flags);
+static void cache_clear(struct gctl_req *req);
+static void cache_dump(struct gctl_req *req);
+static void cache_label(struct gctl_req *req);
+
+struct g_command class_commands[] = {
+	{ "clear", G_FLAG_VERBOSE, cache_main, G_NULL_OPTS,
+	    "[-v] prov ..."
+	},
+	{ "configure", G_FLAG_VERBOSE, NULL,
+	    {
+		{ 'b', "blocksize", &blocksize_configure, G_TYPE_NUMBER },
+		{ 's', "size", &size_configure, G_TYPE_NUMBER },
+		G_OPT_SENTINEL
+	    },
+	    "[-v] [-b blocksize] [-s size] name"
+	},
+	{ "create", G_FLAG_VERBOSE | G_FLAG_LOADKLD, NULL,
+	    {
+		{ 'b', "blocksize", &blocksize_label, G_TYPE_NUMBER },
+		{ 's', "size", &size_label, G_TYPE_NUMBER },
+		G_OPT_SENTINEL
+	    },
+	    "[-v] [-b blocksize] [-s size] name prov"
+	},
+	{ "destroy", G_FLAG_VERBOSE, NULL,
+	    {
+		{ 'f', "force", NULL, G_TYPE_NONE },
+		G_OPT_SENTINEL
+	    },
+	    "[-fv] name ..."
+	},
+	{ "dump", 0, cache_main, G_NULL_OPTS,
+	    "prov ..."
+	},
+	{ "label", G_FLAG_VERBOSE | G_FLAG_LOADKLD, cache_main,
+	    {
+		{ 'b', "blocksize", &blocksize_label, G_TYPE_NUMBER },
+		{ 's', "size", &size_label, G_TYPE_NUMBER },
+		G_OPT_SENTINEL
+	    },
+	    "[-v] [-b blocksize] [-s size] name prov"
+	},
+	{ "reset", G_FLAG_VERBOSE, NULL, G_NULL_OPTS,
+	    "[-v] name ..."
+	},
+	{ "stop", G_FLAG_VERBOSE, NULL,
+	    {
+		{ 'f', "force", NULL, G_TYPE_NONE },
+		G_OPT_SENTINEL
+	    },
+	    "[-fv] name ..."
+	},
+	G_CMD_SENTINEL
+};
+
+static int verbose = 0;
+
+static void
+cache_main(struct gctl_req *req, unsigned flags)
+{
+	const char *name;
+
+	if ((flags & G_FLAG_VERBOSE) != 0)
+		verbose = 1;
+
+	name = gctl_get_ascii(req, "verb");
+	if (name == NULL) {
+		gctl_error(req, "No '%s' argument.", "verb");
+		return;
+	}
+	if (strcmp(name, "label") == 0)
+		cache_label(req);
+	else if (strcmp(name, "clear") == 0)
+		cache_clear(req);
+	else if (strcmp(name, "dump") == 0)
+		cache_dump(req);
+	else
+		gctl_error(req, "Unknown command: %s.", name);
+}
+
+static void
+cache_label(struct gctl_req *req)
+{
+	struct g_cache_metadata md;
+	u_char sector[512];
+	const char *name;
+	int error, nargs;
+	intmax_t val;
+
+	nargs = gctl_get_int(req, "nargs");
+	if (nargs != 2) {
+		gctl_error(req, "Invalid number of arguments.");
+		return;
+	}
+
+	strlcpy(md.md_magic, G_CACHE_MAGIC, sizeof(md.md_magic));
+	md.md_version = G_CACHE_VERSION;
+	name = gctl_get_ascii(req, "arg0");
+	strlcpy(md.md_name, name, sizeof(md.md_name));
+	val = gctl_get_intmax(req, "blocksize");
+	md.md_bsize = val;
+	val = gctl_get_intmax(req, "size");
+	md.md_size = val;
+
+	name = gctl_get_ascii(req, "arg1");
+	md.md_provsize = g_get_mediasize(name);
+	if (md.md_provsize == 0) {
+		fprintf(stderr, "Can't get mediasize of %s: %s.\n",
+		    name, strerror(errno));
+		gctl_error(req, "Not fully done.");
+		return;
+	}
+	cache_metadata_encode(&md, sector);
+	error = g_metadata_store(name, sector, sizeof(sector));
+	if (error != 0) {
+		fprintf(stderr, "Can't store metadata on %s: %s.\n",
+		    name, strerror(error));
+		gctl_error(req, "Not fully done.");
+		return;
+	}
+	if (verbose)
+		printf("Metadata value stored on %s.\n", name);
+}
+
+static void
+cache_clear(struct gctl_req *req)
+{
+	const char *name;
+	int error, i, nargs;
+
+	nargs = gctl_get_int(req, "nargs");
+	if (nargs < 1) {
+		gctl_error(req, "Too few arguments.");
+		return;
+	}
+
+	for (i = 0; i < nargs; i++) {
+		name = gctl_get_ascii(req, "arg%d", i);
+		error = g_metadata_clear(name, G_CACHE_MAGIC);
+		if (error != 0) {
+			fprintf(stderr, "Can't clear metadata on %s: %s.\n",
+			    name, strerror(error));
+			gctl_error(req, "Not fully done.");
+			continue;
+		}
+		if (verbose)
+			printf("Metadata cleared on %s.\n", name);
+	}
+}
+
+static void
+cache_metadata_dump(const struct g_cache_metadata *md)
+{
+
+	printf("         Magic string: %s\n", md->md_magic);
+	printf("     Metadata version: %u\n", (u_int)md->md_version);
+	printf("          Device name: %s\n", md->md_name);
+	printf("           Block size: %u\n", (u_int)md->md_bsize);
+	printf("           Cache size: %u\n", (u_int)md->md_size);
+	printf("        Provider size: %ju\n", (uintmax_t)md->md_provsize);
+}
+
+static void
+cache_dump(struct gctl_req *req)
+{
+	struct g_cache_metadata md, tmpmd;
+	const char *name;
+	int error, i, nargs;
+
+	nargs = gctl_get_int(req, "nargs");
+	if (nargs < 1) {
+		gctl_error(req, "Too few arguments.");
+		return;
+	}
+
+	for (i = 0; i < nargs; i++) {
+		name = gctl_get_ascii(req, "arg%d", i);
+		error = g_metadata_read(name, (u_char *)&tmpmd, sizeof(tmpmd),
+		    G_CACHE_MAGIC);
+		if (error != 0) {
+			fprintf(stderr, "Can't read metadata from %s: %s.\n",
+			    name, strerror(error));
+			gctl_error(req, "Not fully done.");
+			continue;
+		}
+		cache_metadata_decode((u_char *)&tmpmd, &md);
+		printf("Metadata on %s:\n", name);
+		cache_metadata_dump(&md);
+		printf("\n");
+	}
+}

sys/geom/cache/g_cache.h

@@ -0,0 +1,146 @@
+/*-
+ * Copyright (c) 2006 Ruslan Ermilov <ru@FreeBSD.org>
+ * 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.
+ *
+ * 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.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef	_G_CACHE_H_
+#define	_G_CACHE_H_
+
+#include <sys/endian.h>
+
+#define	G_CACHE_CLASS_NAME	"CACHE"
+#define	G_CACHE_MAGIC		"GEOM::CACHE"
+#define	G_CACHE_VERSION		1
+
+#ifdef _KERNEL
+#define	G_CACHE_TYPE_MANUAL	0
+#define	G_CACHE_TYPE_AUTOMATIC	1
+
+#define	G_CACHE_DEBUG(lvl, ...)	do {					\
+	if (g_cache_debug >= (lvl)) {					\
+		printf("GEOM_CACHE");					\
+		if (g_cache_debug > 0)					\
+			printf("[%u]", lvl);				\
+		printf(": ");						\
+		printf(__VA_ARGS__);					\
+		printf("\n");						\
+	}								\
+} while (0)
+#define	G_CACHE_LOGREQ(bp, ...)	do {					\
+	if (g_cache_debug >= 2) {					\
+		printf("GEOM_CACHE[2]: ");				\
+		printf(__VA_ARGS__);					\
+		printf(" ");						\
+		g_print_bio(bp);					\
+		printf("\n");						\
+	}								\
+} while (0)
+
+#define	G_CACHE_BUCKETS		(1 << 3)
+#define	G_CACHE_BUCKET(bno)	((bno) & (G_CACHE_BUCKETS - 1))
+
+struct g_cache_softc {
+	struct g_geom	*sc_geom;
+	int		sc_type;
+	u_int		sc_bshift;
+	u_int		sc_bsize;
+	off_t		sc_tail;
+	struct mtx	sc_mtx;
+	struct callout	sc_callout;
+	LIST_HEAD(, g_cache_desc) sc_desclist[G_CACHE_BUCKETS];
+	TAILQ_HEAD(, g_cache_desc) sc_usedlist;
+	uma_zone_t	sc_zone;
+
+	u_int		sc_maxent;		/* max entries */
+	u_int		sc_nent;		/* allocated entries */
+	u_int		sc_nused;		/* re-useable entries */
+	u_int		sc_invalid;		/* invalid entries */
+
+	uintmax_t	sc_reads;		/* #reads */
+	uintmax_t	sc_readbytes;		/* bytes read */
+	uintmax_t	sc_cachereads;		/* #reads from cache */
+	uintmax_t	sc_cachereadbytes;	/* bytes read from cache */
+	uintmax_t	sc_cachehits;		/* cache hits */
+	uintmax_t	sc_cachemisses;		/* cache misses */
+	uintmax_t	sc_cachefull;		/* #times a cache was full */
+	uintmax_t	sc_writes;		/* #writes */
+	uintmax_t	sc_wrotebytes;		/* bytes written */
+};
+#define	sc_name	sc_geom->name
+
+struct g_cache_desc {
+	off_t		d_bno;			/* block number */
+	caddr_t		d_data;			/* data area */
+	struct bio	*d_biolist;		/* waiters */
+	time_t		d_atime;		/* access time */
+	int		d_flags;		/* flags */
+#define	D_FLAG_USED	(1 << 0)			/* can be reused */
+#define	D_FLAG_INVALID	(1 << 1)			/* invalid */
+	LIST_ENTRY(g_cache_desc) d_next;	/* list */
+	TAILQ_ENTRY(g_cache_desc) d_used;	/* used list */
+};
+
+#define	G_CACHE_NEXT_BIO1(bp)	(bp)->bio_driver1
+#define	G_CACHE_NEXT_BIO2(bp)	(bp)->bio_driver2
+#define	G_CACHE_DESC1(bp)	(bp)->bio_caller1
+#define	G_CACHE_DESC2(bp)	(bp)->bio_caller2
+
+#endif	/* _KERNEL */
+
+struct g_cache_metadata {
+	char		md_magic[16];		/* Magic value. */
+	uint32_t	md_version;		/* Version number. */
+	char		md_name[16];		/* Cache value. */
+	uint32_t	md_bsize;		/* Cache block size. */
+	uint32_t	md_size;		/* Cache size. */
+	uint64_t	md_provsize;		/* Provider's size. */
+};
+
+static __inline void
+cache_metadata_encode(const struct g_cache_metadata *md, u_char *data)
+{
+
+	bcopy(md->md_magic, data, sizeof(md->md_magic));
+	le32enc(data + 16, md->md_version);
+	bcopy(md->md_name, data + 20, sizeof(md->md_name));
+	le32enc(data + 36, md->md_bsize);
+	le32enc(data + 40, md->md_size);
+	le64enc(data + 44, md->md_provsize);
+}
+
+static __inline void
+cache_metadata_decode(const u_char *data, struct g_cache_metadata *md)
+{
+
+	bcopy(data, md->md_magic, sizeof(md->md_magic));
+	md->md_version = le32dec(data + 16);
+	bcopy(data + 20, md->md_name, sizeof(md->md_name));
+	md->md_bsize = le32dec(data + 36);
+	md->md_size = le16dec(data + 40);
+	md->md_provsize = le64dec(data + 44);
+}
+
+#endif	/* _G_CACHE_H_ */

sys/modules/geom/Makefile

@@ -3,6 +3,7 @@
 SUBDIR=	geom_apple \
 	geom_bde \
 	geom_bsd \
+	geom_cache \
 	geom_ccd \
 	geom_concat \
 	geom_eli \

sys/modules/geom/geom_cache/Makefile

@@ -0,0 +1,8 @@
+# $FreeBSD$
+
+.PATH: ${.CURDIR}/../../../geom/cache
+
+KMOD=	geom_cache
+SRCS=	g_cache.c
+
+.include <bsd.kmod.mk>