diff --git a/pkgs/os-specific/linux/e3cfsprogs/builder.sh b/pkgs/os-specific/linux/e3cfsprogs/builder.sh
new file mode 100755
index 00000000000..6d9c0d6ddaa
--- /dev/null
+++ b/pkgs/os-specific/linux/e3cfsprogs/builder.sh
@@ -0,0 +1,12 @@
+source $stdenv/setup
+
+tar -zxvf $src
+cd e3cfsprogs*/
+
+mkdir build;
+cd build;
+../configure --prefix=$out
+make
+#make check #almost all checks fail... maybe they have to be done on a ext3cow fs ???
+make install
+
diff --git a/pkgs/os-specific/linux/e3cfsprogs/default.nix b/pkgs/os-specific/linux/e3cfsprogs/default.nix
new file mode 100644
index 00000000000..8db3317a230
--- /dev/null
+++ b/pkgs/os-specific/linux/e3cfsprogs/default.nix
@@ -0,0 +1,30 @@
+{stdenv, fetchurl, gettext}:
+
+stdenv.mkDerivation {
+ name = "e3cfsprogs-1.39";
+ builder = ./builder.sh;
+
+ patches = [ ./e3cfsprogs-1.39_bin_links.patch ./e3cfsprogs-1.39_etc.patch ];
+
+ src = fetchurl {
+ url = http://www.ext3cow.com/Download_files/e3cfsprogs-1.39.tgz;
+ sha256 = "26f535007a497d91c85d337ac67d62d42e3c8fde2ee02c5cb6b6e3e884a5d58f";
+ };
+
+ configureFlags =
+ if stdenv ? isDietLibC
+ then ""
+ else "--enable-dynamic-e2fsck --enable-elf-shlibs";
+ buildInputs = [gettext];
+ preInstall = "installFlagsArray=('LN=ln -s')";
+ postInstall = "make install-libs";
+
+ NIX_CFLAGS_COMPILE =
+ if stdenv ? isDietLibC then
+ "-UHAVE_SYS_PRCTL_H " +
+ (if stdenv.system == "x86_64-linux" then "-DHAVE_LSEEK64_PROTOTYPE=1 -Dstat64=stat" else "")
+ else "";
+}
+
+
+#note that ext3cow requires the ext3cow kernel patch !!!!
diff --git a/pkgs/os-specific/linux/e3cfsprogs/e3cfsprogs-1.39_bin_links.patch b/pkgs/os-specific/linux/e3cfsprogs/e3cfsprogs-1.39_bin_links.patch
new file mode 100644
index 00000000000..cf8c819c97a
--- /dev/null
+++ b/pkgs/os-specific/linux/e3cfsprogs/e3cfsprogs-1.39_bin_links.patch
@@ -0,0 +1,111 @@
+diff -Naur e3cfsprogs-1.39/config/config.guess e3cfsprogs-1.39_mod/config/config.guess
+--- e3cfsprogs-1.39/config/config.guess 2006-04-10 00:34:21.000000000 +0200
++++ e3cfsprogs-1.39_mod/config/config.guess 2007-07-20 16:28:58.000000000 +0200
+@@ -319,7 +319,7 @@
+ echo sparc-icl-nx6
+ exit ;;
+ DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+- case `/usr/bin/uname -p` in
++ case `uname -p` in
+ sparc) echo sparc-icl-nx7; exit ;;
+ esac ;;
+ sun4H:SunOS:5.*:*)
+@@ -460,7 +460,7 @@
+ exit ;;
+ AViiON:dgux:*:*)
+ # DG/UX returns AViiON for all architectures
+- UNAME_PROCESSOR=`/usr/bin/uname -p`
++ UNAME_PROCESSOR=`uname -p`
+ if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+ then
+ if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+@@ -1054,7 +1054,7 @@
+ exit ;;
+ i*86:*:5:[678]*)
+ # UnixWare 7.x, OpenUNIX and OpenServer 6.
+- case `/bin/uname -X | grep "^Machine"` in
++ case `uname -X | grep "^Machine"` in
+ *486*) UNAME_MACHINE=i486 ;;
+ *Pentium) UNAME_MACHINE=i586 ;;
+ *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+@@ -1065,14 +1065,14 @@
+ if test -f /usr/options/cb.name; then
+ UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then
+- UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+- (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+- (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
++ elif uname -X 2>/dev/null >/dev/null ; then
++ UNAME_REL=`(uname -X|grep Release|sed -e 's/.*= //')`
++ (uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
++ (uname -X|grep '^Machine.*Pentium' >/dev/null) \
+ && UNAME_MACHINE=i586
+- (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
++ (uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+ && UNAME_MACHINE=i686
+- (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
++ (uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+ && UNAME_MACHINE=i686
+ echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+ else
+@@ -1114,12 +1114,12 @@
+ OS_REL=''
+ test -r /etc/.relid \
+ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+- /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
++ uname -p 2>/dev/null | grep 86 >/dev/null \
+ && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+- /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
++ uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+ 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+- /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
++ uname -p 2>/dev/null | grep 86 >/dev/null \
+ && { echo i486-ncr-sysv4; exit; } ;;
+ m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+ echo m68k-unknown-lynxos${UNAME_RELEASE}
+@@ -1471,8 +1471,8 @@
+ uname -s = `(uname -s) 2>/dev/null || echo unknown`
+ uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+-/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+-/bin/uname -X = `(/bin/uname -X) 2>/dev/null`
++uname -p = `(uname -p) 2>/dev/null`
++uname -X = `(uname -X) 2>/dev/null`
+
+ hostinfo = `(hostinfo) 2>/dev/null`
+ /bin/universe = `(/bin/universe) 2>/dev/null`
+diff -Naur e3cfsprogs-1.39/lib/blkid/test_probe.in e3cfsprogs-1.39_mod/lib/blkid/test_probe.in
+--- e3cfsprogs-1.39/lib/blkid/test_probe.in 2005-09-10 20:08:42.000000000 +0200
++++ e3cfsprogs-1.39_mod/lib/blkid/test_probe.in 2007-07-20 16:26:02.000000000 +0200
+@@ -21,7 +21,7 @@
+ fi
+ bunzip2 < $SRCDIR/tests/$i.img.bz2 > /tmp/test.img.$$
+ ./tst_probe /tmp/test.img.$$ > tests/$i.out
+- /bin/rm -f /tmp/test.img.$$ tests/$i.ok tests/$i.failed
++ rm -f /tmp/test.img.$$ tests/$i.ok tests/$i.failed
+ cmp -s tests/$i.out $SRCDIR/tests/$i.results
+ if [ $? = 0 ]; then
+ echo ok
+diff -Naur e3cfsprogs-1.39/tests/defaults/e_script e3cfsprogs-1.39_mod/tests/defaults/e_script
+--- e3cfsprogs-1.39/tests/defaults/e_script 2005-09-06 11:40:14.000000000 +0200
++++ e3cfsprogs-1.39_mod/tests/defaults/e_script 2007-07-20 16:26:26.000000000 +0200
+@@ -25,7 +25,7 @@
+ elif [ "$class" = icount ]; then
+ TEST_PROG=$TEST_ICOUNT
+ else
+- TEST_PROG=/bin/cat
++ TEST_PROG=cat
+ fi
+
+ cat $SRCDIR/progs/test_data/$instance.setup $SRCDIR/progs/test_data/test.$class \
+diff -Naur e3cfsprogs-1.39/util/gcc-wall-cleanup e3cfsprogs-1.39_mod/util/gcc-wall-cleanup
+--- e3cfsprogs-1.39/util/gcc-wall-cleanup 2005-09-06 11:40:15.000000000 +0200
++++ e3cfsprogs-1.39_mod/util/gcc-wall-cleanup 2007-07-20 16:30:04.000000000 +0200
+@@ -1,4 +1,4 @@
+-#!/bin/sed -f
++#!sed -f
+ #
+ # This script filters out gcc-wall crud that we're not interested in seeing.
+ #
diff --git a/pkgs/os-specific/linux/e3cfsprogs/e3cfsprogs-1.39_etc.patch b/pkgs/os-specific/linux/e3cfsprogs/e3cfsprogs-1.39_etc.patch
new file mode 100644
index 00000000000..5997d431f4c
--- /dev/null
+++ b/pkgs/os-specific/linux/e3cfsprogs/e3cfsprogs-1.39_etc.patch
@@ -0,0 +1,27 @@
+diff -Naur e3cfsprogs-1.39/misc/Makefile.in e3cfsprogs-1.39_path_mod/misc/Makefile.in
+--- e3cfsprogs-1.39/misc/Makefile.in 2006-03-27 07:58:10.000000000 +0200
++++ e3cfsprogs-1.39_path_mod/misc/Makefile.in 2007-07-20 16:45:04.000000000 +0200
+@@ -223,12 +223,12 @@
+ @$(SUBSTITUTE_UPTIME) $(srcdir)/filefrag.8.in filefrag.8
+
+ installdirs:
+- @echo " MKINSTALLDIRS $(sbindir) $(root_sbindir) $(bindir) $(man1dir) $(man8dir) $(libdir)"
++ @echo " MKINSTALLDIRS $(sbindir) $(root_sbindir) $(bindir) $(man1dir) $(man8dir) $(libdir) $(root_sysconfdir)"
+ @$(MKINSTALLDIRS) $(DESTDIR)$(sbindir) \
+ $(DESTDIR)$(root_sbindir) $(DESTDIR)$(bindir) \
+ $(DESTDIR)$(man1dir) $(DESTDIR)$(man8dir) \
+ $(DESTDIR)$(man1dir) $(DESTDIR)$(man5dir) \
+- $(DESTDIR)$(libdir) $(DESTDIR)/etc
++ $(DESTDIR)$(libdir) $(DESTDIR)$(root_sysconfdir)/etc
+
+ install: all $(SMANPAGES) $(UMANPAGES) installdirs
+ @for i in $(SPROGS); do \
+@@ -291,7 +291,7 @@
+ @if ! test -f $(DESTDIR)/etc/mke2fs.conf; then \
+ echo " INSTALL_DATA /etc/mke2fs.conf"; \
+ $(INSTALL_DATA) $(srcdir)/mke2fs.conf \
+- $(DESTDIR)/etc/mke2fs.conf; \
++ $(DESTDIR)$(root_sysconfdir)/mke2fs.conf; \
+ fi
+
+ install-strip: install
diff --git a/pkgs/os-specific/linux/ext3cow-tools/builder.sh b/pkgs/os-specific/linux/ext3cow-tools/builder.sh
new file mode 100755
index 00000000000..3e29ff4903b
--- /dev/null
+++ b/pkgs/os-specific/linux/ext3cow-tools/builder.sh
@@ -0,0 +1,14 @@
+source $stdenv/setup
+
+tar -zxvf $src
+cd ext3cow-tools/
+
+kernelslashed=$(echo $kernel | sed 's/\//\\\//g')
+sed -i "s/linux\/ext3cow_fs.h/$kernelslashed\/lib\/modules\/2.6.21.5-default\/build\/include\/linux\/ext3cow_fs.h/" ext3cow_tools.h #ugh dirty header rewrite....
+
+make
+
+ensureDir $out/bin/
+cp ss $out/bin/snapshot
+cp tt $out/bin/
+cp e2d $out/bin/
diff --git a/pkgs/os-specific/linux/ext3cow-tools/default.nix b/pkgs/os-specific/linux/ext3cow-tools/default.nix
new file mode 100644
index 00000000000..71f6657bffa
--- /dev/null
+++ b/pkgs/os-specific/linux/ext3cow-tools/default.nix
@@ -0,0 +1,16 @@
+{stdenv, fetchurl, kernel_ext3cowpatched }:
+
+stdenv.mkDerivation {
+ name = "ext3cow-tools";
+ builder = ./builder.sh;
+
+ src = fetchurl {
+ url = http://www.ext3cow.com/Download_files/ext3cow-tools-1.tgz;
+ sha256 = "78f55b19c8eeaa7b8abde63c7d6547b1ac0421a46d826a8d41c049719a3081f2";
+ };
+
+ kernel = kernel_ext3cowpatched;
+}
+
+
+#note that ext3cow requires the ext3cow kernel patch !!!!
diff --git a/pkgs/os-specific/linux/kernel/linux-2.6.20.3-ext3cow.patch b/pkgs/os-specific/linux/kernel/linux-2.6.20.3-ext3cow.patch
new file mode 100644
index 00000000000..5ce03fa0434
--- /dev/null
+++ b/pkgs/os-specific/linux/kernel/linux-2.6.20.3-ext3cow.patch
@@ -0,0 +1,18428 @@
+diff -ruN linux-2.6.20.3/fs/Kconfig linux-2.6.20.3-ext3cow/fs/Kconfig
+--- linux-2.6.20.3/fs/Kconfig 2007-03-13 14:27:08.000000000 -0400
++++ linux-2.6.20.3-ext3cow/fs/Kconfig 2007-04-07 14:23:46.000000000 -0400
+@@ -136,6 +136,77 @@
+ If you are not using a security module that requires using
+ extended attributes for file security labels, say N.
+
++
++
++config EXT3COW_FS
++ tristate "Ext3cow journalling and versioning file system support"
++ select JBD
++ help
++ This is the journalling version of the Second extended file system
++ (often called ext3), the de facto standard Linux file system
++ (method to organize files on a storage device) for hard disks.
++
++ The journalling code included in this driver means you do not have
++ to run e2fsck (file system checker) on your file systems after a
++ crash. The journal keeps track of any changes that were being made
++ at the time the system crashed, and can ensure that your file system
++ is consistent without the need for a lengthy check.
++
++ Other than adding the journal to the file system, the on-disk format
++ of ext3 is identical to ext2. It is possible to freely switch
++ between using the ext3 driver and the ext2 driver, as long as the
++ file system has been cleanly unmounted, or e2fsck is run on the file
++ system.
++
++ To add a journal on an existing ext2 file system or change the
++ behavior of ext3 file systems, you can use the tune2fs utility ("man
++ tune2fs"). To modify attributes of files and directories on ext3
++ file systems, use chattr ("man chattr"). You need to be using
++ e2fsprogs version 1.20 or later in order to create ext3 journals
++ (available at ).
++
++ To compile this file system support as a module, choose M here: the
++ module will be called ext3.
++
++config EXT3COW_FS_XATTR
++ bool "Ext3cow extended attributes"
++ depends on EXT3COW_FS
++ default y
++ help
++ Extended attributes are name:value pairs associated with inodes by
++ the kernel or by users (see the attr(5) manual page, or visit
++ for details).
++
++ If unsure, say N.
++
++ You need this for POSIX ACL support on ext3cow.
++
++config EXT3COW_FS_POSIX_ACL
++ bool "Ext3cow POSIX Access Control Lists"
++ depends on EXT3COW_FS_XATTR
++ select FS_POSIX_ACL
++ help
++ Posix Access Control Lists (ACLs) support permissions for users and
++ groups beyond the owner/group/world scheme.
++
++ To learn more about Access Control Lists, visit the Posix ACLs for
++ Linux website .
++
++ If you don't know what Access Control Lists are, say N
++
++config EXT3COW_FS_SECURITY
++ bool "Ext3cow Security Labels"
++ depends on EXT3COW_FS_XATTR
++ help
++ Security labels support alternative access control models
++ implemented by security modules like SELinux. This option
++ enables an extended attribute handler for file security
++ labels in the ext3cow filesystem.
++
++ If you are not using a security module that requires using
++ extended attributes for file security labels, say N.
++
++
+ config EXT4DEV_FS
+ tristate "Ext4dev/ext4 extended fs support development (EXPERIMENTAL)"
+ depends on EXPERIMENTAL
+@@ -205,23 +276,23 @@
+ tristate
+ help
+ This is a generic journalling layer for block devices. It is
+- currently used by the ext3 and OCFS2 file systems, but it could
++ currently used by the ext3, ext3cow and OCFS2 file systems, but it could
+ also be used to add journal support to other file systems or block
+ devices such as RAID or LVM.
+
+- If you are using the ext3 or OCFS2 file systems, you need to
++ If you are using the ext3, ext3cow or OCFS2 file systems, you need to
+ say Y here. If you are not using ext3 OCFS2 then you will probably
+ want to say N.
+
+ To compile this device as a module, choose M here: the module will be
+- called jbd. If you are compiling ext3 or OCFS2 into the kernel,
++ called jbd. If you are compiling ext3, ext3cow or OCFS2 into the kernel,
+ you cannot compile this code as a module.
+
+ config JBD_DEBUG
+ bool "JBD (ext3) debugging support"
+ depends on JBD
+ help
+- If you are using the ext3 journaled file system (or potentially any
++ If you are using the ext3 or ext3cow journaled file system (or potentially any
+ other file system/device using JBD), this option allows you to
+ enable debugging output while the system is running, in order to
+ help track down any problems you are having. By default the
+@@ -266,11 +337,12 @@
+ "echo 0 > /proc/sys/fs/jbd2-debug".
+
+ config FS_MBCACHE
+-# Meta block cache for Extended Attributes (ext2/ext3/ext4)
++# Meta block cache for Extended Attributes (ext2/ext3(cow)/ext4)
+ tristate
+- depends on EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4DEV_FS_XATTR
+- default y if EXT2_FS=y || EXT3_FS=y || EXT4DEV_FS=y
+- default m if EXT2_FS=m || EXT3_FS=m || EXT4DEV_FS=m
++ depends on EXT2_FS_XATTR || EXT3_FS_XATTR || EXT3COW_FS_XATTR || EXT4DEV_FS_XATTR
++ default y if EXT2_FS=y || EXT3_FS=y || EXT3COW_FS=y || EXT4DEV_FS=y
++ default m if EXT2_FS=m || EXT3_FS=m || EXT3COW_FS=m || EXT4DEV_FS=m
++
+
+ config REISERFS_FS
+ tristate "Reiserfs support"
+diff -ruN linux-2.6.20.3/fs/Makefile linux-2.6.20.3-ext3cow/fs/Makefile
+--- linux-2.6.20.3/fs/Makefile 2007-03-13 14:27:08.000000000 -0400
++++ linux-2.6.20.3-ext3cow/fs/Makefile 2007-04-07 14:23:46.000000000 -0400
+@@ -63,6 +63,7 @@
+ # Do not add any filesystems before this line
+ obj-$(CONFIG_REISERFS_FS) += reiserfs/
+ obj-$(CONFIG_EXT3_FS) += ext3/ # Before ext2 so root fs can be ext3
++obj-$(CONFIG_EXT3COW_FS) += ext3cow/ # Before ext2 so root fs can be ext3
+ obj-$(CONFIG_EXT4DEV_FS) += ext4/ # Before ext2 so root fs can be ext4dev
+ obj-$(CONFIG_JBD) += jbd/
+ obj-$(CONFIG_JBD2) += jbd2/
+diff -ruN linux-2.6.20.3/fs/ext3cow/Makefile linux-2.6.20.3-ext3cow/fs/ext3cow/Makefile
+--- linux-2.6.20.3/fs/ext3cow/Makefile 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/Makefile 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,12 @@
++#
++# Makefile for the linux ext3cow-filesystem routines.
++#
++
++obj-$(CONFIG_EXT3COW_FS) += ext3cow.o
++
++ext3cow-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
++ ioctl.o namei.o super.o symlink.o hash.o resize.o ext3cow_jbd.o
++
++ext3cow-$(CONFIG_EXT3COW_FS_XATTR) += xattr.o xattr_user.o xattr_trusted.o
++ext3cow-$(CONFIG_EXT3COW_FS_POSIX_ACL) += acl.o
++ext3cow-$(CONFIG_EXT3COW_FS_SECURITY) += xattr_security.o
+diff -ruN linux-2.6.20.3/fs/ext3cow/acl.c linux-2.6.20.3-ext3cow/fs/ext3cow/acl.c
+--- linux-2.6.20.3/fs/ext3cow/acl.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/acl.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,551 @@
++/*
++ * linux/fs/ext3cow/acl.c
++ *
++ * Copyright (C) 2001-2003 Andreas Gruenbacher,
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include "xattr.h"
++#include "acl.h"
++
++/*
++ * Convert from filesystem to in-memory representation.
++ */
++static struct posix_acl *
++ext3cow_acl_from_disk(const void *value, size_t size)
++{
++ const char *end = (char *)value + size;
++ int n, count;
++ struct posix_acl *acl;
++
++ if (!value)
++ return NULL;
++ if (size < sizeof(ext3cow_acl_header))
++ return ERR_PTR(-EINVAL);
++ if (((ext3cow_acl_header *)value)->a_version !=
++ cpu_to_le32(EXT3COW_ACL_VERSION))
++ return ERR_PTR(-EINVAL);
++ value = (char *)value + sizeof(ext3cow_acl_header);
++ count = ext3cow_acl_count(size);
++ if (count < 0)
++ return ERR_PTR(-EINVAL);
++ if (count == 0)
++ return NULL;
++ acl = posix_acl_alloc(count, GFP_KERNEL);
++ if (!acl)
++ return ERR_PTR(-ENOMEM);
++ for (n=0; n < count; n++) {
++ ext3cow_acl_entry *entry =
++ (ext3cow_acl_entry *)value;
++ if ((char *)value + sizeof(ext3cow_acl_entry_short) > end)
++ goto fail;
++ acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);
++ acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);
++ switch(acl->a_entries[n].e_tag) {
++ case ACL_USER_OBJ:
++ case ACL_GROUP_OBJ:
++ case ACL_MASK:
++ case ACL_OTHER:
++ value = (char *)value +
++ sizeof(ext3cow_acl_entry_short);
++ acl->a_entries[n].e_id = ACL_UNDEFINED_ID;
++ break;
++
++ case ACL_USER:
++ case ACL_GROUP:
++ value = (char *)value + sizeof(ext3cow_acl_entry);
++ if ((char *)value > end)
++ goto fail;
++ acl->a_entries[n].e_id =
++ le32_to_cpu(entry->e_id);
++ break;
++
++ default:
++ goto fail;
++ }
++ }
++ if (value != end)
++ goto fail;
++ return acl;
++
++fail:
++ posix_acl_release(acl);
++ return ERR_PTR(-EINVAL);
++}
++
++/*
++ * Convert from in-memory to filesystem representation.
++ */
++static void *
++ext3cow_acl_to_disk(const struct posix_acl *acl, size_t *size)
++{
++ ext3cow_acl_header *ext_acl;
++ char *e;
++ size_t n;
++
++ *size = ext3cow_acl_size(acl->a_count);
++ ext_acl = kmalloc(sizeof(ext3cow_acl_header) + acl->a_count *
++ sizeof(ext3cow_acl_entry), GFP_KERNEL);
++ if (!ext_acl)
++ return ERR_PTR(-ENOMEM);
++ ext_acl->a_version = cpu_to_le32(EXT3COW_ACL_VERSION);
++ e = (char *)ext_acl + sizeof(ext3cow_acl_header);
++ for (n=0; n < acl->a_count; n++) {
++ ext3cow_acl_entry *entry = (ext3cow_acl_entry *)e;
++ entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag);
++ entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
++ switch(acl->a_entries[n].e_tag) {
++ case ACL_USER:
++ case ACL_GROUP:
++ entry->e_id =
++ cpu_to_le32(acl->a_entries[n].e_id);
++ e += sizeof(ext3cow_acl_entry);
++ break;
++
++ case ACL_USER_OBJ:
++ case ACL_GROUP_OBJ:
++ case ACL_MASK:
++ case ACL_OTHER:
++ e += sizeof(ext3cow_acl_entry_short);
++ break;
++
++ default:
++ goto fail;
++ }
++ }
++ return (char *)ext_acl;
++
++fail:
++ kfree(ext_acl);
++ return ERR_PTR(-EINVAL);
++}
++
++static inline struct posix_acl *
++ext3cow_iget_acl(struct inode *inode, struct posix_acl **i_acl)
++{
++ struct posix_acl *acl = EXT3COW_ACL_NOT_CACHED;
++
++ spin_lock(&inode->i_lock);
++ if (*i_acl != EXT3COW_ACL_NOT_CACHED)
++ acl = posix_acl_dup(*i_acl);
++ spin_unlock(&inode->i_lock);
++
++ return acl;
++}
++
++static inline void
++ext3cow_iset_acl(struct inode *inode, struct posix_acl **i_acl,
++ struct posix_acl *acl)
++{
++ spin_lock(&inode->i_lock);
++ if (*i_acl != EXT3COW_ACL_NOT_CACHED)
++ posix_acl_release(*i_acl);
++ *i_acl = posix_acl_dup(acl);
++ spin_unlock(&inode->i_lock);
++}
++
++/*
++ * Inode operation get_posix_acl().
++ *
++ * inode->i_mutex: don't care
++ */
++static struct posix_acl *
++ext3cow_get_acl(struct inode *inode, int type)
++{
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ int name_index;
++ char *value = NULL;
++ struct posix_acl *acl;
++ int retval;
++
++ if (!test_opt(inode->i_sb, POSIX_ACL))
++ return NULL;
++
++ switch(type) {
++ case ACL_TYPE_ACCESS:
++ acl = ext3cow_iget_acl(inode, &ei->i_acl);
++ if (acl != EXT3COW_ACL_NOT_CACHED)
++ return acl;
++ name_index = EXT3COW_XATTR_INDEX_POSIX_ACL_ACCESS;
++ break;
++
++ case ACL_TYPE_DEFAULT:
++ acl = ext3cow_iget_acl(inode, &ei->i_default_acl);
++ if (acl != EXT3COW_ACL_NOT_CACHED)
++ return acl;
++ name_index = EXT3COW_XATTR_INDEX_POSIX_ACL_DEFAULT;
++ break;
++
++ default:
++ return ERR_PTR(-EINVAL);
++ }
++ retval = ext3cow_xattr_get(inode, name_index, "", NULL, 0);
++ if (retval > 0) {
++ value = kmalloc(retval, GFP_KERNEL);
++ if (!value)
++ return ERR_PTR(-ENOMEM);
++ retval = ext3cow_xattr_get(inode, name_index, "", value, retval);
++ }
++ if (retval > 0)
++ acl = ext3cow_acl_from_disk(value, retval);
++ else if (retval == -ENODATA || retval == -ENOSYS)
++ acl = NULL;
++ else
++ acl = ERR_PTR(retval);
++ kfree(value);
++
++ if (!IS_ERR(acl)) {
++ switch(type) {
++ case ACL_TYPE_ACCESS:
++ ext3cow_iset_acl(inode, &ei->i_acl, acl);
++ break;
++
++ case ACL_TYPE_DEFAULT:
++ ext3cow_iset_acl(inode, &ei->i_default_acl, acl);
++ break;
++ }
++ }
++ return acl;
++}
++
++/*
++ * Set the access or default ACL of an inode.
++ *
++ * inode->i_mutex: down unless called from ext3cow_new_inode
++ */
++static int
++ext3cow_set_acl(handle_t *handle, struct inode *inode, int type,
++ struct posix_acl *acl)
++{
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ int name_index;
++ void *value = NULL;
++ size_t size = 0;
++ int error;
++
++ if (S_ISLNK(inode->i_mode))
++ return -EOPNOTSUPP;
++
++ switch(type) {
++ case ACL_TYPE_ACCESS:
++ name_index = EXT3COW_XATTR_INDEX_POSIX_ACL_ACCESS;
++ if (acl) {
++ mode_t mode = inode->i_mode;
++ error = posix_acl_equiv_mode(acl, &mode);
++ if (error < 0)
++ return error;
++ else {
++ inode->i_mode = mode;
++ ext3cow_mark_inode_dirty(handle, inode);
++ if (error == 0)
++ acl = NULL;
++ }
++ }
++ break;
++
++ case ACL_TYPE_DEFAULT:
++ name_index = EXT3COW_XATTR_INDEX_POSIX_ACL_DEFAULT;
++ if (!S_ISDIR(inode->i_mode))
++ return acl ? -EACCES : 0;
++ break;
++
++ default:
++ return -EINVAL;
++ }
++ if (acl) {
++ value = ext3cow_acl_to_disk(acl, &size);
++ if (IS_ERR(value))
++ return (int)PTR_ERR(value);
++ }
++
++ error = ext3cow_xattr_set_handle(handle, inode, name_index, "",
++ value, size, 0);
++
++ kfree(value);
++ if (!error) {
++ switch(type) {
++ case ACL_TYPE_ACCESS:
++ ext3cow_iset_acl(inode, &ei->i_acl, acl);
++ break;
++
++ case ACL_TYPE_DEFAULT:
++ ext3cow_iset_acl(inode, &ei->i_default_acl, acl);
++ break;
++ }
++ }
++ return error;
++}
++
++static int
++ext3cow_check_acl(struct inode *inode, int mask)
++{
++ struct posix_acl *acl = ext3cow_get_acl(inode, ACL_TYPE_ACCESS);
++
++ if (IS_ERR(acl))
++ return PTR_ERR(acl);
++ if (acl) {
++ int error = posix_acl_permission(inode, acl, mask);
++ posix_acl_release(acl);
++ return error;
++ }
++
++ return -EAGAIN;
++}
++
++int
++ext3cow_permission(struct inode *inode, int mask, struct nameidata *nd)
++{
++ return generic_permission(inode, mask, ext3cow_check_acl);
++}
++
++/*
++ * Initialize the ACLs of a new inode. Called from ext3cow_new_inode.
++ *
++ * dir->i_mutex: down
++ * inode->i_mutex: up (access to inode is still exclusive)
++ */
++int
++ext3cow_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
++{
++ struct posix_acl *acl = NULL;
++ int error = 0;
++
++ if (!S_ISLNK(inode->i_mode)) {
++ if (test_opt(dir->i_sb, POSIX_ACL)) {
++ acl = ext3cow_get_acl(dir, ACL_TYPE_DEFAULT);
++ if (IS_ERR(acl))
++ return PTR_ERR(acl);
++ }
++ if (!acl)
++ inode->i_mode &= ~current->fs->umask;
++ }
++ if (test_opt(inode->i_sb, POSIX_ACL) && acl) {
++ struct posix_acl *clone;
++ mode_t mode;
++
++ if (S_ISDIR(inode->i_mode)) {
++ error = ext3cow_set_acl(handle, inode,
++ ACL_TYPE_DEFAULT, acl);
++ if (error)
++ goto cleanup;
++ }
++ clone = posix_acl_clone(acl, GFP_KERNEL);
++ error = -ENOMEM;
++ if (!clone)
++ goto cleanup;
++
++ mode = inode->i_mode;
++ error = posix_acl_create_masq(clone, &mode);
++ if (error >= 0) {
++ inode->i_mode = mode;
++ if (error > 0) {
++ /* This is an extended ACL */
++ error = ext3cow_set_acl(handle, inode,
++ ACL_TYPE_ACCESS, clone);
++ }
++ }
++ posix_acl_release(clone);
++ }
++cleanup:
++ posix_acl_release(acl);
++ return error;
++}
++
++/*
++ * Does chmod for an inode that may have an Access Control List. The
++ * inode->i_mode field must be updated to the desired value by the caller
++ * before calling this function.
++ * Returns 0 on success, or a negative error number.
++ *
++ * We change the ACL rather than storing some ACL entries in the file
++ * mode permission bits (which would be more efficient), because that
++ * would break once additional permissions (like ACL_APPEND, ACL_DELETE
++ * for directories) are added. There are no more bits available in the
++ * file mode.
++ *
++ * inode->i_mutex: down
++ */
++int
++ext3cow_acl_chmod(struct inode *inode)
++{
++ struct posix_acl *acl, *clone;
++ int error;
++
++ if (S_ISLNK(inode->i_mode))
++ return -EOPNOTSUPP;
++ if (!test_opt(inode->i_sb, POSIX_ACL))
++ return 0;
++ acl = ext3cow_get_acl(inode, ACL_TYPE_ACCESS);
++ if (IS_ERR(acl) || !acl)
++ return PTR_ERR(acl);
++ clone = posix_acl_clone(acl, GFP_KERNEL);
++ posix_acl_release(acl);
++ if (!clone)
++ return -ENOMEM;
++ error = posix_acl_chmod_masq(clone, inode->i_mode);
++ if (!error) {
++ handle_t *handle;
++ int retries = 0;
++
++ retry:
++ handle = ext3cow_journal_start(inode,
++ EXT3COW_DATA_TRANS_BLOCKS(inode->i_sb));
++ if (IS_ERR(handle)) {
++ error = PTR_ERR(handle);
++ ext3cow_std_error(inode->i_sb, error);
++ goto out;
++ }
++ error = ext3cow_set_acl(handle, inode, ACL_TYPE_ACCESS, clone);
++ ext3cow_journal_stop(handle);
++ if (error == -ENOSPC &&
++ ext3cow_should_retry_alloc(inode->i_sb, &retries))
++ goto retry;
++ }
++out:
++ posix_acl_release(clone);
++ return error;
++}
++
++/*
++ * Extended attribute handlers
++ */
++static size_t
++ext3cow_xattr_list_acl_access(struct inode *inode, char *list, size_t list_len,
++ const char *name, size_t name_len)
++{
++ const size_t size = sizeof(POSIX_ACL_XATTR_ACCESS);
++
++ if (!test_opt(inode->i_sb, POSIX_ACL))
++ return 0;
++ if (list && size <= list_len)
++ memcpy(list, POSIX_ACL_XATTR_ACCESS, size);
++ return size;
++}
++
++static size_t
++ext3cow_xattr_list_acl_default(struct inode *inode, char *list, size_t list_len,
++ const char *name, size_t name_len)
++{
++ const size_t size = sizeof(POSIX_ACL_XATTR_DEFAULT);
++
++ if (!test_opt(inode->i_sb, POSIX_ACL))
++ return 0;
++ if (list && size <= list_len)
++ memcpy(list, POSIX_ACL_XATTR_DEFAULT, size);
++ return size;
++}
++
++static int
++ext3cow_xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
++{
++ struct posix_acl *acl;
++ int error;
++
++ if (!test_opt(inode->i_sb, POSIX_ACL))
++ return -EOPNOTSUPP;
++
++ acl = ext3cow_get_acl(inode, type);
++ if (IS_ERR(acl))
++ return PTR_ERR(acl);
++ if (acl == NULL)
++ return -ENODATA;
++ error = posix_acl_to_xattr(acl, buffer, size);
++ posix_acl_release(acl);
++
++ return error;
++}
++
++static int
++ext3cow_xattr_get_acl_access(struct inode *inode, const char *name,
++ void *buffer, size_t size)
++{
++ if (strcmp(name, "") != 0)
++ return -EINVAL;
++ return ext3cow_xattr_get_acl(inode, ACL_TYPE_ACCESS, buffer, size);
++}
++
++static int
++ext3cow_xattr_get_acl_default(struct inode *inode, const char *name,
++ void *buffer, size_t size)
++{
++ if (strcmp(name, "") != 0)
++ return -EINVAL;
++ return ext3cow_xattr_get_acl(inode, ACL_TYPE_DEFAULT, buffer, size);
++}
++
++static int
++ext3cow_xattr_set_acl(struct inode *inode, int type, const void *value,
++ size_t size)
++{
++ handle_t *handle;
++ struct posix_acl *acl;
++ int error, retries = 0;
++
++ if (!test_opt(inode->i_sb, POSIX_ACL))
++ return -EOPNOTSUPP;
++ if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
++ return -EPERM;
++
++ if (value) {
++ acl = posix_acl_from_xattr(value, size);
++ if (IS_ERR(acl))
++ return PTR_ERR(acl);
++ else if (acl) {
++ error = posix_acl_valid(acl);
++ if (error)
++ goto release_and_out;
++ }
++ } else
++ acl = NULL;
++
++retry:
++ handle = ext3cow_journal_start(inode, EXT3COW_DATA_TRANS_BLOCKS(inode->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ error = ext3cow_set_acl(handle, inode, type, acl);
++ ext3cow_journal_stop(handle);
++ if (error == -ENOSPC && ext3cow_should_retry_alloc(inode->i_sb, &retries))
++ goto retry;
++
++release_and_out:
++ posix_acl_release(acl);
++ return error;
++}
++
++static int
++ext3cow_xattr_set_acl_access(struct inode *inode, const char *name,
++ const void *value, size_t size, int flags)
++{
++ if (strcmp(name, "") != 0)
++ return -EINVAL;
++ return ext3cow_xattr_set_acl(inode, ACL_TYPE_ACCESS, value, size);
++}
++
++static int
++ext3cow_xattr_set_acl_default(struct inode *inode, const char *name,
++ const void *value, size_t size, int flags)
++{
++ if (strcmp(name, "") != 0)
++ return -EINVAL;
++ return ext3cow_xattr_set_acl(inode, ACL_TYPE_DEFAULT, value, size);
++}
++
++struct xattr_handler ext3cow_xattr_acl_access_handler = {
++ .prefix = POSIX_ACL_XATTR_ACCESS,
++ .list = ext3cow_xattr_list_acl_access,
++ .get = ext3cow_xattr_get_acl_access,
++ .set = ext3cow_xattr_set_acl_access,
++};
++
++struct xattr_handler ext3cow_xattr_acl_default_handler = {
++ .prefix = POSIX_ACL_XATTR_DEFAULT,
++ .list = ext3cow_xattr_list_acl_default,
++ .get = ext3cow_xattr_get_acl_default,
++ .set = ext3cow_xattr_set_acl_default,
++};
+diff -ruN linux-2.6.20.3/fs/ext3cow/acl.h linux-2.6.20.3-ext3cow/fs/ext3cow/acl.h
+--- linux-2.6.20.3/fs/ext3cow/acl.h 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/acl.h 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,81 @@
++/*
++ File: fs/ext3cow/acl.h
++
++ (C) 2001 Andreas Gruenbacher,
++*/
++
++#include
++
++#define EXT3COW_ACL_VERSION 0x0001
++
++typedef struct {
++ __le16 e_tag;
++ __le16 e_perm;
++ __le32 e_id;
++} ext3cow_acl_entry;
++
++typedef struct {
++ __le16 e_tag;
++ __le16 e_perm;
++} ext3cow_acl_entry_short;
++
++typedef struct {
++ __le32 a_version;
++} ext3cow_acl_header;
++
++static inline size_t ext3cow_acl_size(int count)
++{
++ if (count <= 4) {
++ return sizeof(ext3cow_acl_header) +
++ count * sizeof(ext3cow_acl_entry_short);
++ } else {
++ return sizeof(ext3cow_acl_header) +
++ 4 * sizeof(ext3cow_acl_entry_short) +
++ (count - 4) * sizeof(ext3cow_acl_entry);
++ }
++}
++
++static inline int ext3cow_acl_count(size_t size)
++{
++ ssize_t s;
++ size -= sizeof(ext3cow_acl_header);
++ s = size - 4 * sizeof(ext3cow_acl_entry_short);
++ if (s < 0) {
++ if (size % sizeof(ext3cow_acl_entry_short))
++ return -1;
++ return size / sizeof(ext3cow_acl_entry_short);
++ } else {
++ if (s % sizeof(ext3cow_acl_entry))
++ return -1;
++ return s / sizeof(ext3cow_acl_entry) + 4;
++ }
++}
++
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++
++/* Value for inode->u.ext3cow_i.i_acl and inode->u.ext3cow_i.i_default_acl
++ if the ACL has not been cached */
++#define EXT3COW_ACL_NOT_CACHED ((void *)-1)
++
++/* acl.c */
++extern int ext3cow_permission (struct inode *, int, struct nameidata *);
++extern int ext3cow_acl_chmod (struct inode *);
++extern int ext3cow_init_acl (handle_t *, struct inode *, struct inode *);
++
++#else /* CONFIG_EXT3COW_FS_POSIX_ACL */
++#include
++#define ext3cow_permission NULL
++
++static inline int
++ext3cow_acl_chmod(struct inode *inode)
++{
++ return 0;
++}
++
++static inline int
++ext3cow_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
++{
++ return 0;
++}
++#endif /* CONFIG_EXT3COW_FS_POSIX_ACL */
++
+diff -ruN linux-2.6.20.3/fs/ext3cow/balloc.c linux-2.6.20.3-ext3cow/fs/ext3cow/balloc.c
+--- linux-2.6.20.3/fs/ext3cow/balloc.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/balloc.c 2007-04-14 11:40:48.000000000 -0400
+@@ -0,0 +1,1823 @@
++/*
++ * linux/fs/ext3cow/balloc.c
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * Enhanced block allocation by Stephen Tweedie (sct@redhat.com), 1993
++ * Big-endian to little-endian byte-swapping/bitmaps by
++ * David S. Miller (davem@caip.rutgers.edu), 1995
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++
++/*
++ * balloc.c contains the blocks allocation and deallocation routines
++ */
++
++/*
++ * The free blocks are managed by bitmaps. A file system contains several
++ * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
++ * block for inodes, N blocks for the inode table and data blocks.
++ *
++ * The file system contains group descriptors which are located after the
++ * super block. Each descriptor contains the number of the bitmap block and
++ * the free blocks count in the block. The descriptors are loaded in memory
++ * when a file system is mounted (see ext3cow_read_super).
++ */
++
++
++#define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
++
++/**
++ * ext3cow_get_group_desc() -- load group descriptor from disk
++ * @sb: super block
++ * @block_group: given block group
++ * @bh: pointer to the buffer head to store the block
++ * group descriptor
++ */
++struct ext3cow_group_desc * ext3cow_get_group_desc(struct super_block * sb,
++ unsigned int block_group,
++ struct buffer_head ** bh)
++{
++ unsigned long group_desc;
++ unsigned long offset;
++ struct ext3cow_group_desc * desc;
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++
++ if (block_group >= sbi->s_groups_count) {
++ ext3cow_error (sb, "ext3cow_get_group_desc",
++ "block_group >= groups_count - "
++ "block_group = %d, groups_count = %lu",
++ block_group, sbi->s_groups_count);
++
++ return NULL;
++ }
++ smp_rmb();
++
++ group_desc = block_group >> EXT3COW_DESC_PER_BLOCK_BITS(sb);
++ offset = block_group & (EXT3COW_DESC_PER_BLOCK(sb) - 1);
++ if (!sbi->s_group_desc[group_desc]) {
++ ext3cow_error (sb, "ext3cow_get_group_desc",
++ "Group descriptor not loaded - "
++ "block_group = %d, group_desc = %lu, desc = %lu",
++ block_group, group_desc, offset);
++ return NULL;
++ }
++
++ desc = (struct ext3cow_group_desc *) sbi->s_group_desc[group_desc]->b_data;
++ if (bh)
++ *bh = sbi->s_group_desc[group_desc];
++ return desc + offset;
++}
++
++/**
++ * read_block_bitmap()
++ * @sb: super block
++ * @block_group: given block group
++ *
++ * Read the bitmap for a given block_group, reading into the specified
++ * slot in the superblock's bitmap cache.
++ *
++ * Return buffer_head on success or NULL in case of failure.
++ */
++static struct buffer_head *
++read_block_bitmap(struct super_block *sb, unsigned int block_group)
++{
++ struct ext3cow_group_desc * desc;
++ struct buffer_head * bh = NULL;
++
++ desc = ext3cow_get_group_desc (sb, block_group, NULL);
++ if (!desc)
++ goto error_out;
++ bh = sb_bread(sb, le32_to_cpu(desc->bg_block_bitmap));
++ if (!bh)
++ ext3cow_error (sb, "read_block_bitmap",
++ "Cannot read block bitmap - "
++ "block_group = %d, block_bitmap = %u",
++ block_group, le32_to_cpu(desc->bg_block_bitmap));
++error_out:
++ return bh;
++}
++/*
++ * The reservation window structure operations
++ * --------------------------------------------
++ * Operations include:
++ * dump, find, add, remove, is_empty, find_next_reservable_window, etc.
++ *
++ * We use a red-black tree to represent per-filesystem reservation
++ * windows.
++ *
++ */
++
++/**
++ * __rsv_window_dump() -- Dump the filesystem block allocation reservation map
++ * @rb_root: root of per-filesystem reservation rb tree
++ * @verbose: verbose mode
++ * @fn: function which wishes to dump the reservation map
++ *
++ * If verbose is turned on, it will print the whole block reservation
++ * windows(start, end). Otherwise, it will only print out the "bad" windows,
++ * those windows that overlap with their immediate neighbors.
++ */
++#if 1
++static void __rsv_window_dump(struct rb_root *root, int verbose,
++ const char *fn)
++{
++ struct rb_node *n;
++ struct ext3cow_reserve_window_node *rsv, *prev;
++ int bad;
++
++restart:
++ n = rb_first(root);
++ bad = 0;
++ prev = NULL;
++
++ printk("Block Allocation Reservation Windows Map (%s):\n", fn);
++ while (n) {
++ rsv = rb_entry(n, struct ext3cow_reserve_window_node, rsv_node);
++ if (verbose)
++ printk("reservation window 0x%p "
++ "start: %lu, end: %lu\n",
++ rsv, rsv->rsv_start, rsv->rsv_end);
++ if (rsv->rsv_start && rsv->rsv_start >= rsv->rsv_end) {
++ printk("Bad reservation %p (start >= end)\n",
++ rsv);
++ bad = 1;
++ }
++ if (prev && prev->rsv_end >= rsv->rsv_start) {
++ printk("Bad reservation %p (prev->end >= start)\n",
++ rsv);
++ bad = 1;
++ }
++ if (bad) {
++ if (!verbose) {
++ printk("Restarting reservation walk in verbose mode\n");
++ verbose = 1;
++ goto restart;
++ }
++ }
++ n = rb_next(n);
++ prev = rsv;
++ }
++ printk("Window map complete.\n");
++ if (bad)
++ BUG();
++}
++#define rsv_window_dump(root, verbose) \
++ __rsv_window_dump((root), (verbose), __FUNCTION__)
++#else
++#define rsv_window_dump(root, verbose) do {} while (0)
++#endif
++
++/**
++ * goal_in_my_reservation()
++ * @rsv: inode's reservation window
++ * @grp_goal: given goal block relative to the allocation block group
++ * @group: the current allocation block group
++ * @sb: filesystem super block
++ *
++ * Test if the given goal block (group relative) is within the file's
++ * own block reservation window range.
++ *
++ * If the reservation window is outside the goal allocation group, return 0;
++ * grp_goal (given goal block) could be -1, which means no specific
++ * goal block. In this case, always return 1.
++ * If the goal block is within the reservation window, return 1;
++ * otherwise, return 0;
++ */
++static int
++goal_in_my_reservation(struct ext3cow_reserve_window *rsv, ext3cow_grpblk_t grp_goal,
++ unsigned int group, struct super_block * sb)
++{
++ ext3cow_fsblk_t group_first_block, group_last_block;
++
++ group_first_block = ext3cow_group_first_block_no(sb, group);
++ group_last_block = group_first_block + (EXT3COW_BLOCKS_PER_GROUP(sb) - 1);
++
++ if ((rsv->_rsv_start > group_last_block) ||
++ (rsv->_rsv_end < group_first_block))
++ return 0;
++ if ((grp_goal >= 0) && ((grp_goal + group_first_block < rsv->_rsv_start)
++ || (grp_goal + group_first_block > rsv->_rsv_end)))
++ return 0;
++ return 1;
++}
++
++/**
++ * search_reserve_window()
++ * @rb_root: root of reservation tree
++ * @goal: target allocation block
++ *
++ * Find the reserved window which includes the goal, or the previous one
++ * if the goal is not in any window.
++ * Returns NULL if there are no windows or if all windows start after the goal.
++ */
++static struct ext3cow_reserve_window_node *
++search_reserve_window(struct rb_root *root, ext3cow_fsblk_t goal)
++{
++ struct rb_node *n = root->rb_node;
++ struct ext3cow_reserve_window_node *rsv;
++
++ if (!n)
++ return NULL;
++
++ do {
++ rsv = rb_entry(n, struct ext3cow_reserve_window_node, rsv_node);
++
++ if (goal < rsv->rsv_start)
++ n = n->rb_left;
++ else if (goal > rsv->rsv_end)
++ n = n->rb_right;
++ else
++ return rsv;
++ } while (n);
++ /*
++ * We've fallen off the end of the tree: the goal wasn't inside
++ * any particular node. OK, the previous node must be to one
++ * side of the interval containing the goal. If it's the RHS,
++ * we need to back up one.
++ */
++ if (rsv->rsv_start > goal) {
++ n = rb_prev(&rsv->rsv_node);
++ rsv = rb_entry(n, struct ext3cow_reserve_window_node, rsv_node);
++ }
++ return rsv;
++}
++
++/**
++ * ext3cow_rsv_window_add() -- Insert a window to the block reservation rb tree.
++ * @sb: super block
++ * @rsv: reservation window to add
++ *
++ * Must be called with rsv_lock hold.
++ */
++void ext3cow_rsv_window_add(struct super_block *sb,
++ struct ext3cow_reserve_window_node *rsv)
++{
++ struct rb_root *root = &EXT3COW_SB(sb)->s_rsv_window_root;
++ struct rb_node *node = &rsv->rsv_node;
++ ext3cow_fsblk_t start = rsv->rsv_start;
++
++ struct rb_node ** p = &root->rb_node;
++ struct rb_node * parent = NULL;
++ struct ext3cow_reserve_window_node *this;
++
++ while (*p)
++ {
++ parent = *p;
++ this = rb_entry(parent, struct ext3cow_reserve_window_node, rsv_node);
++
++ if (start < this->rsv_start)
++ p = &(*p)->rb_left;
++ else if (start > this->rsv_end)
++ p = &(*p)->rb_right;
++ else {
++ rsv_window_dump(root, 1);
++ BUG();
++ }
++ }
++
++ rb_link_node(node, parent, p);
++ rb_insert_color(node, root);
++}
++
++/**
++ * ext3cow_rsv_window_remove() -- unlink a window from the reservation rb tree
++ * @sb: super block
++ * @rsv: reservation window to remove
++ *
++ * Mark the block reservation window as not allocated, and unlink it
++ * from the filesystem reservation window rb tree. Must be called with
++ * rsv_lock hold.
++ */
++static void rsv_window_remove(struct super_block *sb,
++ struct ext3cow_reserve_window_node *rsv)
++{
++ rsv->rsv_start = EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED;
++ rsv->rsv_end = EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED;
++ rsv->rsv_alloc_hit = 0;
++ rb_erase(&rsv->rsv_node, &EXT3COW_SB(sb)->s_rsv_window_root);
++}
++
++/*
++ * rsv_is_empty() -- Check if the reservation window is allocated.
++ * @rsv: given reservation window to check
++ *
++ * returns 1 if the end block is EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED.
++ */
++static inline int rsv_is_empty(struct ext3cow_reserve_window *rsv)
++{
++ /* a valid reservation end block could not be 0 */
++ return rsv->_rsv_end == EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED;
++}
++
++/**
++ * ext3cow_init_block_alloc_info()
++ * @inode: file inode structure
++ *
++ * Allocate and initialize the reservation window structure, and
++ * link the window to the ext3cow inode structure at last
++ *
++ * The reservation window structure is only dynamically allocated
++ * and linked to ext3cow inode the first time the open file
++ * needs a new block. So, before every ext3cow_new_block(s) call, for
++ * regular files, we should check whether the reservation window
++ * structure exists or not. In the latter case, this function is called.
++ * Fail to do so will result in block reservation being turned off for that
++ * open file.
++ *
++ * This function is called from ext3cow_get_blocks_handle(), also called
++ * when setting the reservation window size through ioctl before the file
++ * is open for write (needs block allocation).
++ *
++ * Needs truncate_mutex protection prior to call this function.
++ */
++void ext3cow_init_block_alloc_info(struct inode *inode)
++{
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ struct ext3cow_block_alloc_info *block_i = ei->i_block_alloc_info;
++ struct super_block *sb = inode->i_sb;
++
++ block_i = kmalloc(sizeof(*block_i), GFP_NOFS);
++ if (block_i) {
++ struct ext3cow_reserve_window_node *rsv = &block_i->rsv_window_node;
++
++ rsv->rsv_start = EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED;
++ rsv->rsv_end = EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED;
++
++ /*
++ * if filesystem is mounted with NORESERVATION, the goal
++ * reservation window size is set to zero to indicate
++ * block reservation is off
++ */
++ if (!test_opt(sb, RESERVATION))
++ rsv->rsv_goal_size = 0;
++ else
++ rsv->rsv_goal_size = EXT3COW_DEFAULT_RESERVE_BLOCKS;
++ rsv->rsv_alloc_hit = 0;
++ block_i->last_alloc_logical_block = 0;
++ block_i->last_alloc_physical_block = 0;
++ }
++ ei->i_block_alloc_info = block_i;
++}
++
++/**
++ * ext3cow_discard_reservation()
++ * @inode: inode
++ *
++ * Discard(free) block reservation window on last file close, or truncate
++ * or at last iput().
++ *
++ * It is being called in three cases:
++ * ext3cow_release_file(): last writer close the file
++ * ext3cow_clear_inode(): last iput(), when nobody link to this file.
++ * ext3cow_truncate(): when the block indirect map is about to change.
++ *
++ */
++void ext3cow_discard_reservation(struct inode *inode)
++{
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ struct ext3cow_block_alloc_info *block_i = ei->i_block_alloc_info;
++ struct ext3cow_reserve_window_node *rsv;
++ spinlock_t *rsv_lock = &EXT3COW_SB(inode->i_sb)->s_rsv_window_lock;
++
++ if (!block_i)
++ return;
++
++ rsv = &block_i->rsv_window_node;
++ if (!rsv_is_empty(&rsv->rsv_window)) {
++ spin_lock(rsv_lock);
++ if (!rsv_is_empty(&rsv->rsv_window))
++ rsv_window_remove(inode->i_sb, rsv);
++ spin_unlock(rsv_lock);
++ }
++}
++
++/**
++ * ext3cow_free_blocks_sb() -- Free given blocks and update quota
++ * @handle: handle to this transaction
++ * @sb: super block
++ * @block: start physcial block to free
++ * @count: number of blocks to free
++ * @pdquot_freed_blocks: pointer to quota
++ */
++void ext3cow_free_blocks_sb(handle_t *handle, struct super_block *sb,
++ ext3cow_fsblk_t block, unsigned long count,
++ unsigned long *pdquot_freed_blocks)
++{
++ struct buffer_head *bitmap_bh = NULL;
++ struct buffer_head *gd_bh;
++ unsigned long block_group;
++ ext3cow_grpblk_t bit;
++ unsigned long i;
++ unsigned long overflow;
++ struct ext3cow_group_desc * desc;
++ struct ext3cow_super_block * es;
++ struct ext3cow_sb_info *sbi;
++ int err = 0, ret;
++ ext3cow_grpblk_t group_freed;
++
++ *pdquot_freed_blocks = 0;
++ sbi = EXT3COW_SB(sb);
++ es = sbi->s_es;
++ if (block < le32_to_cpu(es->s_first_data_block) ||
++ block + count < block ||
++ block + count > le32_to_cpu(es->s_blocks_count)) {
++ ext3cow_error (sb, "ext3cow_free_blocks",
++ "Freeing blocks not in datazone - "
++ "block = "E3FSBLK", count = %lu", block, count);
++ goto error_return;
++ }
++
++ //TODO: Remove:
++ printk(KERN_INFO "freeing block(s) %lu-%lu\n", block, block + count - 1);
++ ext3cow_debug ("freeing block(s) %lu-%lu\n", block, block + count - 1);
++
++do_more:
++ overflow = 0;
++ block_group = (block - le32_to_cpu(es->s_first_data_block)) /
++ EXT3COW_BLOCKS_PER_GROUP(sb);
++ bit = (block - le32_to_cpu(es->s_first_data_block)) %
++ EXT3COW_BLOCKS_PER_GROUP(sb);
++ /*
++ * Check to see if we are freeing blocks across a group
++ * boundary.
++ */
++ if (bit + count > EXT3COW_BLOCKS_PER_GROUP(sb)) {
++ overflow = bit + count - EXT3COW_BLOCKS_PER_GROUP(sb);
++ count -= overflow;
++ }
++ brelse(bitmap_bh);
++ bitmap_bh = read_block_bitmap(sb, block_group);
++ if (!bitmap_bh)
++ goto error_return;
++ desc = ext3cow_get_group_desc (sb, block_group, &gd_bh);
++ if (!desc)
++ goto error_return;
++
++ if (in_range (le32_to_cpu(desc->bg_block_bitmap), block, count) ||
++ in_range (le32_to_cpu(desc->bg_inode_bitmap), block, count) ||
++ in_range (block, le32_to_cpu(desc->bg_inode_table),
++ sbi->s_itb_per_group) ||
++ in_range (block + count - 1, le32_to_cpu(desc->bg_inode_table),
++ sbi->s_itb_per_group))
++ ext3cow_error (sb, "ext3cow_free_blocks",
++ "Freeing blocks in system zones - "
++ "Block = "E3FSBLK", count = %lu",
++ block, count);
++
++ /*
++ * We are about to start releasing blocks in the bitmap,
++ * so we need undo access.
++ */
++ /* @@@ check errors */
++ BUFFER_TRACE(bitmap_bh, "getting undo access");
++ err = ext3cow_journal_get_undo_access(handle, bitmap_bh);
++ if (err)
++ goto error_return;
++
++ /*
++ * We are about to modify some metadata. Call the journal APIs
++ * to unshare ->b_data if a currently-committing transaction is
++ * using it
++ */
++ BUFFER_TRACE(gd_bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, gd_bh);
++ if (err)
++ goto error_return;
++
++ jbd_lock_bh_state(bitmap_bh);
++
++ for (i = 0, group_freed = 0; i < count; i++) {
++ /*
++ * An HJ special. This is expensive...
++ */
++#ifdef CONFIG_JBD_DEBUG
++ jbd_unlock_bh_state(bitmap_bh);
++ {
++ struct buffer_head *debug_bh;
++ debug_bh = sb_find_get_block(sb, block + i);
++ if (debug_bh) {
++ BUFFER_TRACE(debug_bh, "Deleted!");
++ if (!bh2jh(bitmap_bh)->b_committed_data)
++ BUFFER_TRACE(debug_bh,
++ "No commited data in bitmap");
++ BUFFER_TRACE2(debug_bh, bitmap_bh, "bitmap");
++ __brelse(debug_bh);
++ }
++ }
++ jbd_lock_bh_state(bitmap_bh);
++#endif
++ if (need_resched()) {
++ jbd_unlock_bh_state(bitmap_bh);
++ cond_resched();
++ jbd_lock_bh_state(bitmap_bh);
++ }
++ /* @@@ This prevents newly-allocated data from being
++ * freed and then reallocated within the same
++ * transaction.
++ *
++ * Ideally we would want to allow that to happen, but to
++ * do so requires making journal_forget() capable of
++ * revoking the queued write of a data block, which
++ * implies blocking on the journal lock. *forget()
++ * cannot block due to truncate races.
++ *
++ * Eventually we can fix this by making journal_forget()
++ * return a status indicating whether or not it was able
++ * to revoke the buffer. On successful revoke, it is
++ * safe not to set the allocation bit in the committed
++ * bitmap, because we know that there is no outstanding
++ * activity on the buffer any more and so it is safe to
++ * reallocate it.
++ */
++ BUFFER_TRACE(bitmap_bh, "set in b_committed_data");
++ J_ASSERT_BH(bitmap_bh,
++ bh2jh(bitmap_bh)->b_committed_data != NULL);
++ ext3cow_set_bit_atomic(sb_bgl_lock(sbi, block_group), bit + i,
++ bh2jh(bitmap_bh)->b_committed_data);
++
++ /*
++ * We clear the bit in the bitmap after setting the committed
++ * data bit, because this is the reverse order to that which
++ * the allocator uses.
++ */
++ BUFFER_TRACE(bitmap_bh, "clear bit");
++ if (!ext3cow_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
++ bit + i, bitmap_bh->b_data)) {
++ jbd_unlock_bh_state(bitmap_bh);
++ ext3cow_error(sb, __FUNCTION__,
++ "bit already cleared for block "E3FSBLK,
++ block + i);
++ jbd_lock_bh_state(bitmap_bh);
++ BUFFER_TRACE(bitmap_bh, "bit already cleared");
++ } else {
++ group_freed++;
++ }
++ }
++ jbd_unlock_bh_state(bitmap_bh);
++
++ spin_lock(sb_bgl_lock(sbi, block_group));
++ desc->bg_free_blocks_count =
++ cpu_to_le16(le16_to_cpu(desc->bg_free_blocks_count) +
++ group_freed);
++ spin_unlock(sb_bgl_lock(sbi, block_group));
++ percpu_counter_mod(&sbi->s_freeblocks_counter, count);
++
++ /* We dirtied the bitmap block */
++ BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
++ err = ext3cow_journal_dirty_metadata(handle, bitmap_bh);
++
++ /* And the group descriptor block */
++ BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
++ ret = ext3cow_journal_dirty_metadata(handle, gd_bh);
++ if (!err) err = ret;
++ *pdquot_freed_blocks += group_freed;
++
++ if (overflow && !err) {
++ block += count;
++ count = overflow;
++ goto do_more;
++ }
++ sb->s_dirt = 1;
++error_return:
++ brelse(bitmap_bh);
++ ext3cow_std_error(sb, err);
++ return;
++}
++
++/**
++ * ext3cow_free_blocks() -- Free given blocks and update quota
++ * @handle: handle for this transaction
++ * @inode: inode
++ * @block: start physical block to free
++ * @count: number of blocks to count
++ */
++void ext3cow_free_blocks(handle_t *handle, struct inode *inode,
++ ext3cow_fsblk_t block, unsigned long count)
++{
++ struct super_block * sb;
++ unsigned long dquot_freed_blocks;
++
++ sb = inode->i_sb;
++ if (!sb) {
++ printk ("ext3cow_free_blocks: nonexistent device");
++ return;
++ }
++ ext3cow_free_blocks_sb(handle, sb, block, count, &dquot_freed_blocks);
++ if (dquot_freed_blocks)
++ DQUOT_FREE_BLOCK(inode, dquot_freed_blocks);
++ return;
++}
++
++/**
++ * ext3cow_test_allocatable()
++ * @nr: given allocation block group
++ * @bh: bufferhead contains the bitmap of the given block group
++ *
++ * For ext3cow allocations, we must not reuse any blocks which are
++ * allocated in the bitmap buffer's "last committed data" copy. This
++ * prevents deletes from freeing up the page for reuse until we have
++ * committed the delete transaction.
++ *
++ * If we didn't do this, then deleting something and reallocating it as
++ * data would allow the old block to be overwritten before the
++ * transaction committed (because we force data to disk before commit).
++ * This would lead to corruption if we crashed between overwriting the
++ * data and committing the delete.
++ *
++ * @@@ We may want to make this allocation behaviour conditional on
++ * data-writes at some point, and disable it for metadata allocations or
++ * sync-data inodes.
++ */
++static int ext3cow_test_allocatable(ext3cow_grpblk_t nr, struct buffer_head *bh)
++{
++ int ret;
++ struct journal_head *jh = bh2jh(bh);
++
++ if (ext3cow_test_bit(nr, bh->b_data))
++ return 0;
++
++ jbd_lock_bh_state(bh);
++ if (!jh->b_committed_data)
++ ret = 1;
++ else
++ ret = !ext3cow_test_bit(nr, jh->b_committed_data);
++ jbd_unlock_bh_state(bh);
++ return ret;
++}
++
++/**
++ * bitmap_search_next_usable_block()
++ * @start: the starting block (group relative) of the search
++ * @bh: bufferhead contains the block group bitmap
++ * @maxblocks: the ending block (group relative) of the reservation
++ *
++ * The bitmap search --- search forward alternately through the actual
++ * bitmap on disk and the last-committed copy in journal, until we find a
++ * bit free in both bitmaps.
++ */
++static ext3cow_grpblk_t
++bitmap_search_next_usable_block(ext3cow_grpblk_t start, struct buffer_head *bh,
++ ext3cow_grpblk_t maxblocks)
++{
++ ext3cow_grpblk_t next;
++ struct journal_head *jh = bh2jh(bh);
++
++ while (start < maxblocks) {
++ next = ext3cow_find_next_zero_bit(bh->b_data, maxblocks, start);
++ if (next >= maxblocks)
++ return -1;
++ if (ext3cow_test_allocatable(next, bh))
++ return next;
++ jbd_lock_bh_state(bh);
++ if (jh->b_committed_data)
++ start = ext3cow_find_next_zero_bit(jh->b_committed_data,
++ maxblocks, next);
++ jbd_unlock_bh_state(bh);
++ }
++ return -1;
++}
++
++/**
++ * find_next_usable_block()
++ * @start: the starting block (group relative) to find next
++ * allocatable block in bitmap.
++ * @bh: bufferhead contains the block group bitmap
++ * @maxblocks: the ending block (group relative) for the search
++ *
++ * Find an allocatable block in a bitmap. We honor both the bitmap and
++ * its last-committed copy (if that exists), and perform the "most
++ * appropriate allocation" algorithm of looking for a free block near
++ * the initial goal; then for a free byte somewhere in the bitmap; then
++ * for any free bit in the bitmap.
++ */
++static ext3cow_grpblk_t
++find_next_usable_block(ext3cow_grpblk_t start, struct buffer_head *bh,
++ ext3cow_grpblk_t maxblocks)
++{
++ ext3cow_grpblk_t here, next;
++ char *p, *r;
++
++ if (start > 0) {
++ /*
++ * The goal was occupied; search forward for a free
++ * block within the next XX blocks.
++ *
++ * end_goal is more or less random, but it has to be
++ * less than EXT3COW_BLOCKS_PER_GROUP. Aligning up to the
++ * next 64-bit boundary is simple..
++ */
++ ext3cow_grpblk_t end_goal = (start + 63) & ~63;
++ if (end_goal > maxblocks)
++ end_goal = maxblocks;
++ here = ext3cow_find_next_zero_bit(bh->b_data, end_goal, start);
++ if (here < end_goal && ext3cow_test_allocatable(here, bh))
++ return here;
++ ext3cow_debug("Bit not found near goal\n");
++ }
++
++ here = start;
++ if (here < 0)
++ here = 0;
++
++ p = ((char *)bh->b_data) + (here >> 3);
++ r = memscan(p, 0, ((maxblocks + 7) >> 3) - (here >> 3));
++ next = (r - ((char *)bh->b_data)) << 3;
++
++ if (next < maxblocks && next >= start && ext3cow_test_allocatable(next, bh))
++ return next;
++
++ /*
++ * The bitmap search --- search forward alternately through the actual
++ * bitmap and the last-committed copy until we find a bit free in
++ * both
++ */
++ here = bitmap_search_next_usable_block(here, bh, maxblocks);
++ return here;
++}
++
++/**
++ * claim_block()
++ * @block: the free block (group relative) to allocate
++ * @bh: the bufferhead containts the block group bitmap
++ *
++ * We think we can allocate this block in this bitmap. Try to set the bit.
++ * If that succeeds then check that nobody has allocated and then freed the
++ * block since we saw that is was not marked in b_committed_data. If it _was_
++ * allocated and freed then clear the bit in the bitmap again and return
++ * zero (failure).
++ */
++static inline int
++claim_block(spinlock_t *lock, ext3cow_grpblk_t block, struct buffer_head *bh)
++{
++ struct journal_head *jh = bh2jh(bh);
++ int ret;
++
++ if (ext3cow_set_bit_atomic(lock, block, bh->b_data))
++ return 0;
++ jbd_lock_bh_state(bh);
++ if (jh->b_committed_data && ext3cow_test_bit(block,jh->b_committed_data)) {
++ ext3cow_clear_bit_atomic(lock, block, bh->b_data);
++ ret = 0;
++ } else {
++ ret = 1;
++ }
++ jbd_unlock_bh_state(bh);
++ return ret;
++}
++
++/**
++ * ext3cow_try_to_allocate()
++ * @sb: superblock
++ * @handle: handle to this transaction
++ * @group: given allocation block group
++ * @bitmap_bh: bufferhead holds the block bitmap
++ * @grp_goal: given target block within the group
++ * @count: target number of blocks to allocate
++ * @my_rsv: reservation window
++ *
++ * Attempt to allocate blocks within a give range. Set the range of allocation
++ * first, then find the first free bit(s) from the bitmap (within the range),
++ * and at last, allocate the blocks by claiming the found free bit as allocated.
++ *
++ * To set the range of this allocation:
++ * if there is a reservation window, only try to allocate block(s) from the
++ * file's own reservation window;
++ * Otherwise, the allocation range starts from the give goal block, ends at
++ * the block group's last block.
++ *
++ * If we failed to allocate the desired block then we may end up crossing to a
++ * new bitmap. In that case we must release write access to the old one via
++ * ext3cow_journal_release_buffer(), else we'll run out of credits.
++ */
++static ext3cow_grpblk_t
++ext3cow_try_to_allocate(struct super_block *sb, handle_t *handle, int group,
++ struct buffer_head *bitmap_bh, ext3cow_grpblk_t grp_goal,
++ unsigned long *count, struct ext3cow_reserve_window *my_rsv)
++{
++ ext3cow_fsblk_t group_first_block;
++ ext3cow_grpblk_t start, end;
++ unsigned long num = 0;
++
++ /* we do allocation within the reservation window if we have a window */
++ if (my_rsv) {
++ group_first_block = ext3cow_group_first_block_no(sb, group);
++ if (my_rsv->_rsv_start >= group_first_block)
++ start = my_rsv->_rsv_start - group_first_block;
++ else
++ /* reservation window cross group boundary */
++ start = 0;
++ end = my_rsv->_rsv_end - group_first_block + 1;
++ if (end > EXT3COW_BLOCKS_PER_GROUP(sb))
++ /* reservation window crosses group boundary */
++ end = EXT3COW_BLOCKS_PER_GROUP(sb);
++ if ((start <= grp_goal) && (grp_goal < end))
++ start = grp_goal;
++ else
++ grp_goal = -1;
++ } else {
++ if (grp_goal > 0)
++ start = grp_goal;
++ else
++ start = 0;
++ end = EXT3COW_BLOCKS_PER_GROUP(sb);
++ }
++
++ BUG_ON(start > EXT3COW_BLOCKS_PER_GROUP(sb));
++
++repeat:
++ if (grp_goal < 0 || !ext3cow_test_allocatable(grp_goal, bitmap_bh)) {
++ grp_goal = find_next_usable_block(start, bitmap_bh, end);
++ if (grp_goal < 0)
++ goto fail_access;
++ if (!my_rsv) {
++ int i;
++
++ for (i = 0; i < 7 && grp_goal > start &&
++ ext3cow_test_allocatable(grp_goal - 1,
++ bitmap_bh);
++ i++, grp_goal--)
++ ;
++ }
++ }
++ start = grp_goal;
++
++ if (!claim_block(sb_bgl_lock(EXT3COW_SB(sb), group),
++ grp_goal, bitmap_bh)) {
++ /*
++ * The block was allocated by another thread, or it was
++ * allocated and then freed by another thread
++ */
++ start++;
++ grp_goal++;
++ if (start >= end)
++ goto fail_access;
++ goto repeat;
++ }
++ num++;
++ grp_goal++;
++ while (num < *count && grp_goal < end
++ && ext3cow_test_allocatable(grp_goal, bitmap_bh)
++ && claim_block(sb_bgl_lock(EXT3COW_SB(sb), group),
++ grp_goal, bitmap_bh)) {
++ num++;
++ grp_goal++;
++ }
++ *count = num;
++ return grp_goal - num;
++fail_access:
++ *count = num;
++ return -1;
++}
++
++/**
++ * find_next_reservable_window():
++ * find a reservable space within the given range.
++ * It does not allocate the reservation window for now:
++ * alloc_new_reservation() will do the work later.
++ *
++ * @search_head: the head of the searching list;
++ * This is not necessarily the list head of the whole filesystem
++ *
++ * We have both head and start_block to assist the search
++ * for the reservable space. The list starts from head,
++ * but we will shift to the place where start_block is,
++ * then start from there, when looking for a reservable space.
++ *
++ * @size: the target new reservation window size
++ *
++ * @group_first_block: the first block we consider to start
++ * the real search from
++ *
++ * @last_block:
++ * the maximum block number that our goal reservable space
++ * could start from. This is normally the last block in this
++ * group. The search will end when we found the start of next
++ * possible reservable space is out of this boundary.
++ * This could handle the cross boundary reservation window
++ * request.
++ *
++ * basically we search from the given range, rather than the whole
++ * reservation double linked list, (start_block, last_block)
++ * to find a free region that is of my size and has not
++ * been reserved.
++ *
++ */
++static int find_next_reservable_window(
++ struct ext3cow_reserve_window_node *search_head,
++ struct ext3cow_reserve_window_node *my_rsv,
++ struct super_block * sb,
++ ext3cow_fsblk_t start_block,
++ ext3cow_fsblk_t last_block)
++{
++ struct rb_node *next;
++ struct ext3cow_reserve_window_node *rsv, *prev;
++ ext3cow_fsblk_t cur;
++ int size = my_rsv->rsv_goal_size;
++
++ /* TODO: make the start of the reservation window byte-aligned */
++ /* cur = *start_block & ~7;*/
++ cur = start_block;
++ rsv = search_head;
++ if (!rsv)
++ return -1;
++
++ while (1) {
++ if (cur <= rsv->rsv_end)
++ cur = rsv->rsv_end + 1;
++
++ /* TODO?
++ * in the case we could not find a reservable space
++ * that is what is expected, during the re-search, we could
++ * remember what's the largest reservable space we could have
++ * and return that one.
++ *
++ * For now it will fail if we could not find the reservable
++ * space with expected-size (or more)...
++ */
++ if (cur > last_block)
++ return -1; /* fail */
++
++ prev = rsv;
++ next = rb_next(&rsv->rsv_node);
++ rsv = rb_entry(next,struct ext3cow_reserve_window_node,rsv_node);
++
++ /*
++ * Reached the last reservation, we can just append to the
++ * previous one.
++ */
++ if (!next)
++ break;
++
++ if (cur + size <= rsv->rsv_start) {
++ /*
++ * Found a reserveable space big enough. We could
++ * have a reservation across the group boundary here
++ */
++ break;
++ }
++ }
++ /*
++ * we come here either :
++ * when we reach the end of the whole list,
++ * and there is empty reservable space after last entry in the list.
++ * append it to the end of the list.
++ *
++ * or we found one reservable space in the middle of the list,
++ * return the reservation window that we could append to.
++ * succeed.
++ */
++
++ if ((prev != my_rsv) && (!rsv_is_empty(&my_rsv->rsv_window)))
++ rsv_window_remove(sb, my_rsv);
++
++ /*
++ * Let's book the whole avaliable window for now. We will check the
++ * disk bitmap later and then, if there are free blocks then we adjust
++ * the window size if it's larger than requested.
++ * Otherwise, we will remove this node from the tree next time
++ * call find_next_reservable_window.
++ */
++ my_rsv->rsv_start = cur;
++ my_rsv->rsv_end = cur + size - 1;
++ my_rsv->rsv_alloc_hit = 0;
++
++ if (prev != my_rsv)
++ ext3cow_rsv_window_add(sb, my_rsv);
++
++ return 0;
++}
++
++/**
++ * alloc_new_reservation()--allocate a new reservation window
++ *
++ * To make a new reservation, we search part of the filesystem
++ * reservation list (the list that inside the group). We try to
++ * allocate a new reservation window near the allocation goal,
++ * or the beginning of the group, if there is no goal.
++ *
++ * We first find a reservable space after the goal, then from
++ * there, we check the bitmap for the first free block after
++ * it. If there is no free block until the end of group, then the
++ * whole group is full, we failed. Otherwise, check if the free
++ * block is inside the expected reservable space, if so, we
++ * succeed.
++ * If the first free block is outside the reservable space, then
++ * start from the first free block, we search for next available
++ * space, and go on.
++ *
++ * on succeed, a new reservation will be found and inserted into the list
++ * It contains at least one free block, and it does not overlap with other
++ * reservation windows.
++ *
++ * failed: we failed to find a reservation window in this group
++ *
++ * @rsv: the reservation
++ *
++ * @grp_goal: The goal (group-relative). It is where the search for a
++ * free reservable space should start from.
++ * if we have a grp_goal(grp_goal >0 ), then start from there,
++ * no grp_goal(grp_goal = -1), we start from the first block
++ * of the group.
++ *
++ * @sb: the super block
++ * @group: the group we are trying to allocate in
++ * @bitmap_bh: the block group block bitmap
++ *
++ */
++static int alloc_new_reservation(struct ext3cow_reserve_window_node *my_rsv,
++ ext3cow_grpblk_t grp_goal, struct super_block *sb,
++ unsigned int group, struct buffer_head *bitmap_bh)
++{
++ struct ext3cow_reserve_window_node *search_head;
++ ext3cow_fsblk_t group_first_block, group_end_block, start_block;
++ ext3cow_grpblk_t first_free_block;
++ struct rb_root *fs_rsv_root = &EXT3COW_SB(sb)->s_rsv_window_root;
++ unsigned long size;
++ int ret;
++ spinlock_t *rsv_lock = &EXT3COW_SB(sb)->s_rsv_window_lock;
++
++ group_first_block = ext3cow_group_first_block_no(sb, group);
++ group_end_block = group_first_block + (EXT3COW_BLOCKS_PER_GROUP(sb) - 1);
++
++ if (grp_goal < 0)
++ start_block = group_first_block;
++ else
++ start_block = grp_goal + group_first_block;
++
++ size = my_rsv->rsv_goal_size;
++
++ if (!rsv_is_empty(&my_rsv->rsv_window)) {
++ /*
++ * if the old reservation is cross group boundary
++ * and if the goal is inside the old reservation window,
++ * we will come here when we just failed to allocate from
++ * the first part of the window. We still have another part
++ * that belongs to the next group. In this case, there is no
++ * point to discard our window and try to allocate a new one
++ * in this group(which will fail). we should
++ * keep the reservation window, just simply move on.
++ *
++ * Maybe we could shift the start block of the reservation
++ * window to the first block of next group.
++ */
++
++ if ((my_rsv->rsv_start <= group_end_block) &&
++ (my_rsv->rsv_end > group_end_block) &&
++ (start_block >= my_rsv->rsv_start))
++ return -1;
++
++ if ((my_rsv->rsv_alloc_hit >
++ (my_rsv->rsv_end - my_rsv->rsv_start + 1) / 2)) {
++ /*
++ * if the previously allocation hit ratio is
++ * greater than 1/2, then we double the size of
++ * the reservation window the next time,
++ * otherwise we keep the same size window
++ */
++ size = size * 2;
++ if (size > EXT3COW_MAX_RESERVE_BLOCKS)
++ size = EXT3COW_MAX_RESERVE_BLOCKS;
++ my_rsv->rsv_goal_size= size;
++ }
++ }
++
++ spin_lock(rsv_lock);
++ /*
++ * shift the search start to the window near the goal block
++ */
++ search_head = search_reserve_window(fs_rsv_root, start_block);
++
++ /*
++ * find_next_reservable_window() simply finds a reservable window
++ * inside the given range(start_block, group_end_block).
++ *
++ * To make sure the reservation window has a free bit inside it, we
++ * need to check the bitmap after we found a reservable window.
++ */
++retry:
++ ret = find_next_reservable_window(search_head, my_rsv, sb,
++ start_block, group_end_block);
++
++ if (ret == -1) {
++ if (!rsv_is_empty(&my_rsv->rsv_window))
++ rsv_window_remove(sb, my_rsv);
++ spin_unlock(rsv_lock);
++ return -1;
++ }
++
++ /*
++ * On success, find_next_reservable_window() returns the
++ * reservation window where there is a reservable space after it.
++ * Before we reserve this reservable space, we need
++ * to make sure there is at least a free block inside this region.
++ *
++ * searching the first free bit on the block bitmap and copy of
++ * last committed bitmap alternatively, until we found a allocatable
++ * block. Search start from the start block of the reservable space
++ * we just found.
++ */
++ spin_unlock(rsv_lock);
++ first_free_block = bitmap_search_next_usable_block(
++ my_rsv->rsv_start - group_first_block,
++ bitmap_bh, group_end_block - group_first_block + 1);
++
++ if (first_free_block < 0) {
++ /*
++ * no free block left on the bitmap, no point
++ * to reserve the space. return failed.
++ */
++ spin_lock(rsv_lock);
++ if (!rsv_is_empty(&my_rsv->rsv_window))
++ rsv_window_remove(sb, my_rsv);
++ spin_unlock(rsv_lock);
++ return -1; /* failed */
++ }
++
++ start_block = first_free_block + group_first_block;
++ /*
++ * check if the first free block is within the
++ * free space we just reserved
++ */
++ if (start_block >= my_rsv->rsv_start && start_block <= my_rsv->rsv_end)
++ return 0; /* success */
++ /*
++ * if the first free bit we found is out of the reservable space
++ * continue search for next reservable space,
++ * start from where the free block is,
++ * we also shift the list head to where we stopped last time
++ */
++ search_head = my_rsv;
++ spin_lock(rsv_lock);
++ goto retry;
++}
++
++/**
++ * try_to_extend_reservation()
++ * @my_rsv: given reservation window
++ * @sb: super block
++ * @size: the delta to extend
++ *
++ * Attempt to expand the reservation window large enough to have
++ * required number of free blocks
++ *
++ * Since ext3cow_try_to_allocate() will always allocate blocks within
++ * the reservation window range, if the window size is too small,
++ * multiple blocks allocation has to stop at the end of the reservation
++ * window. To make this more efficient, given the total number of
++ * blocks needed and the current size of the window, we try to
++ * expand the reservation window size if necessary on a best-effort
++ * basis before ext3cow_new_blocks() tries to allocate blocks,
++ */
++static void try_to_extend_reservation(struct ext3cow_reserve_window_node *my_rsv,
++ struct super_block *sb, int size)
++{
++ struct ext3cow_reserve_window_node *next_rsv;
++ struct rb_node *next;
++ spinlock_t *rsv_lock = &EXT3COW_SB(sb)->s_rsv_window_lock;
++
++ if (!spin_trylock(rsv_lock))
++ return;
++
++ next = rb_next(&my_rsv->rsv_node);
++
++ if (!next)
++ my_rsv->rsv_end += size;
++ else {
++ next_rsv = rb_entry(next, struct ext3cow_reserve_window_node, rsv_node);
++
++ if ((next_rsv->rsv_start - my_rsv->rsv_end - 1) >= size)
++ my_rsv->rsv_end += size;
++ else
++ my_rsv->rsv_end = next_rsv->rsv_start - 1;
++ }
++ spin_unlock(rsv_lock);
++}
++
++/**
++ * ext3cow_try_to_allocate_with_rsv()
++ * @sb: superblock
++ * @handle: handle to this transaction
++ * @group: given allocation block group
++ * @bitmap_bh: bufferhead holds the block bitmap
++ * @grp_goal: given target block within the group
++ * @count: target number of blocks to allocate
++ * @my_rsv: reservation window
++ * @errp: pointer to store the error code
++ *
++ * This is the main function used to allocate a new block and its reservation
++ * window.
++ *
++ * Each time when a new block allocation is need, first try to allocate from
++ * its own reservation. If it does not have a reservation window, instead of
++ * looking for a free bit on bitmap first, then look up the reservation list to
++ * see if it is inside somebody else's reservation window, we try to allocate a
++ * reservation window for it starting from the goal first. Then do the block
++ * allocation within the reservation window.
++ *
++ * This will avoid keeping on searching the reservation list again and
++ * again when somebody is looking for a free block (without
++ * reservation), and there are lots of free blocks, but they are all
++ * being reserved.
++ *
++ * We use a red-black tree for the per-filesystem reservation list.
++ *
++ */
++static ext3cow_grpblk_t
++ext3cow_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
++ unsigned int group, struct buffer_head *bitmap_bh,
++ ext3cow_grpblk_t grp_goal,
++ struct ext3cow_reserve_window_node * my_rsv,
++ unsigned long *count, int *errp)
++{
++ ext3cow_fsblk_t group_first_block, group_last_block;
++ ext3cow_grpblk_t ret = 0;
++ int fatal;
++ unsigned long num = *count;
++
++ *errp = 0;
++
++ /*
++ * Make sure we use undo access for the bitmap, because it is critical
++ * that we do the frozen_data COW on bitmap buffers in all cases even
++ * if the buffer is in BJ_Forget state in the committing transaction.
++ */
++ BUFFER_TRACE(bitmap_bh, "get undo access for new block");
++ fatal = ext3cow_journal_get_undo_access(handle, bitmap_bh);
++ if (fatal) {
++ *errp = fatal;
++ return -1;
++ }
++
++ /*
++ * we don't deal with reservation when
++ * filesystem is mounted without reservation
++ * or the file is not a regular file
++ * or last attempt to allocate a block with reservation turned on failed
++ */
++ if (my_rsv == NULL ) {
++ ret = ext3cow_try_to_allocate(sb, handle, group, bitmap_bh,
++ grp_goal, count, NULL);
++ goto out;
++ }
++ /*
++ * grp_goal is a group relative block number (if there is a goal)
++ * 0 <= grp_goal < EXT3COW_BLOCKS_PER_GROUP(sb)
++ * first block is a filesystem wide block number
++ * first block is the block number of the first block in this group
++ */
++ group_first_block = ext3cow_group_first_block_no(sb, group);
++ group_last_block = group_first_block + (EXT3COW_BLOCKS_PER_GROUP(sb) - 1);
++
++ /*
++ * Basically we will allocate a new block from inode's reservation
++ * window.
++ *
++ * We need to allocate a new reservation window, if:
++ * a) inode does not have a reservation window; or
++ * b) last attempt to allocate a block from existing reservation
++ * failed; or
++ * c) we come here with a goal and with a reservation window
++ *
++ * We do not need to allocate a new reservation window if we come here
++ * at the beginning with a goal and the goal is inside the window, or
++ * we don't have a goal but already have a reservation window.
++ * then we could go to allocate from the reservation window directly.
++ */
++ while (1) {
++ if (rsv_is_empty(&my_rsv->rsv_window) || (ret < 0) ||
++ !goal_in_my_reservation(&my_rsv->rsv_window,
++ grp_goal, group, sb)) {
++ if (my_rsv->rsv_goal_size < *count)
++ my_rsv->rsv_goal_size = *count;
++ ret = alloc_new_reservation(my_rsv, grp_goal, sb,
++ group, bitmap_bh);
++ if (ret < 0)
++ break; /* failed */
++
++ if (!goal_in_my_reservation(&my_rsv->rsv_window,
++ grp_goal, group, sb))
++ grp_goal = -1;
++ } else if (grp_goal >= 0) {
++ int curr = my_rsv->rsv_end -
++ (grp_goal + group_first_block) + 1;
++
++ if (curr < *count)
++ try_to_extend_reservation(my_rsv, sb,
++ *count - curr);
++ }
++
++ if ((my_rsv->rsv_start > group_last_block) ||
++ (my_rsv->rsv_end < group_first_block)) {
++ rsv_window_dump(&EXT3COW_SB(sb)->s_rsv_window_root, 1);
++ BUG();
++ }
++ ret = ext3cow_try_to_allocate(sb, handle, group, bitmap_bh,
++ grp_goal, &num, &my_rsv->rsv_window);
++ if (ret >= 0) {
++ my_rsv->rsv_alloc_hit += num;
++ *count = num;
++ break; /* succeed */
++ }
++ num = *count;
++ }
++out:
++ if (ret >= 0) {
++ BUFFER_TRACE(bitmap_bh, "journal_dirty_metadata for "
++ "bitmap block");
++ fatal = ext3cow_journal_dirty_metadata(handle, bitmap_bh);
++ if (fatal) {
++ *errp = fatal;
++ return -1;
++ }
++ return ret;
++ }
++
++ BUFFER_TRACE(bitmap_bh, "journal_release_buffer");
++ ext3cow_journal_release_buffer(handle, bitmap_bh);
++ return ret;
++}
++
++/**
++ * ext3cow_has_free_blocks()
++ * @sbi: in-core super block structure.
++ *
++ * Check if filesystem has at least 1 free block available for allocation.
++ */
++static int ext3cow_has_free_blocks(struct ext3cow_sb_info *sbi)
++{
++ ext3cow_fsblk_t free_blocks, root_blocks;
++
++ free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
++ root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
++ if (free_blocks < root_blocks + 1 && !capable(CAP_SYS_RESOURCE) &&
++ sbi->s_resuid != current->fsuid &&
++ (sbi->s_resgid == 0 || !in_group_p (sbi->s_resgid))) {
++ return 0;
++ }
++ return 1;
++}
++
++/**
++ * ext3cow_should_retry_alloc()
++ * @sb: super block
++ * @retries number of attemps has been made
++ *
++ * ext3cow_should_retry_alloc() is called when ENOSPC is returned, and if
++ * it is profitable to retry the operation, this function will wait
++ * for the current or commiting transaction to complete, and then
++ * return TRUE.
++ *
++ * if the total number of retries exceed three times, return FALSE.
++ */
++int ext3cow_should_retry_alloc(struct super_block *sb, int *retries)
++{
++ if (!ext3cow_has_free_blocks(EXT3COW_SB(sb)) || (*retries)++ > 3)
++ return 0;
++
++ jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
++
++ return journal_force_commit_nested(EXT3COW_SB(sb)->s_journal);
++}
++
++/**
++ * ext3cow_new_blocks() -- core block(s) allocation function
++ * @handle: handle to this transaction
++ * @inode: file inode
++ * @goal: given target block(filesystem wide)
++ * @count: target number of blocks to allocate
++ * @errp: error code
++ *
++ * ext3cow_new_blocks uses a goal block to assist allocation. It tries to
++ * allocate block(s) from the block group contains the goal block first. If that
++ * fails, it will try to allocate block(s) from other block groups without
++ * any specific goal block.
++ *
++ */
++ext3cow_fsblk_t ext3cow_new_blocks(handle_t *handle, struct inode *inode,
++ ext3cow_fsblk_t goal, unsigned long *count, int *errp)
++{
++ struct buffer_head *bitmap_bh = NULL;
++ struct buffer_head *gdp_bh;
++ int group_no;
++ int goal_group;
++ ext3cow_grpblk_t grp_target_blk; /* blockgroup relative goal block */
++ ext3cow_grpblk_t grp_alloc_blk; /* blockgroup-relative allocated block*/
++ ext3cow_fsblk_t ret_block; /* filesyetem-wide allocated block */
++ int bgi; /* blockgroup iteration index */
++ int fatal = 0, err;
++ int performed_allocation = 0;
++ ext3cow_grpblk_t free_blocks; /* number of free blocks in a group */
++ struct super_block *sb;
++ struct ext3cow_group_desc *gdp;
++ struct ext3cow_super_block *es;
++ struct ext3cow_sb_info *sbi;
++ struct ext3cow_reserve_window_node *my_rsv = NULL;
++ struct ext3cow_block_alloc_info *block_i;
++ unsigned short windowsz = 0;
++#ifdef EXT3COWFS_DEBUG
++ static int goal_hits, goal_attempts;
++#endif
++ unsigned long ngroups;
++ unsigned long num = *count;
++
++ *errp = -ENOSPC;
++ sb = inode->i_sb;
++ if (!sb) {
++ printk("ext3cow_new_block: nonexistent device");
++ return 0;
++ }
++
++ /*
++ * Check quota for allocation of this block.
++ */
++ if (DQUOT_ALLOC_BLOCK(inode, num)) {
++ *errp = -EDQUOT;
++ return 0;
++ }
++
++ sbi = EXT3COW_SB(sb);
++ es = EXT3COW_SB(sb)->s_es;
++ ext3cow_debug("goal=%lu.\n", goal);
++ /*
++ * Allocate a block from reservation only when
++ * filesystem is mounted with reservation(default,-o reservation), and
++ * it's a regular file, and
++ * the desired window size is greater than 0 (One could use ioctl
++ * command EXT3COW_IOC_SETRSVSZ to set the window size to 0 to turn off
++ * reservation on that particular file)
++ */
++ block_i = EXT3COW_I(inode)->i_block_alloc_info;
++ if (block_i && ((windowsz = block_i->rsv_window_node.rsv_goal_size) > 0))
++ my_rsv = &block_i->rsv_window_node;
++
++ if (!ext3cow_has_free_blocks(sbi)) {
++ *errp = -ENOSPC;
++ goto out;
++ }
++
++ /*
++ * First, test whether the goal block is free.
++ */
++ if (goal < le32_to_cpu(es->s_first_data_block) ||
++ goal >= le32_to_cpu(es->s_blocks_count))
++ goal = le32_to_cpu(es->s_first_data_block);
++ group_no = (goal - le32_to_cpu(es->s_first_data_block)) /
++ EXT3COW_BLOCKS_PER_GROUP(sb);
++ goal_group = group_no;
++retry_alloc:
++ gdp = ext3cow_get_group_desc(sb, group_no, &gdp_bh);
++ if (!gdp)
++ goto io_error;
++
++ free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
++ /*
++ * if there is not enough free blocks to make a new resevation
++ * turn off reservation for this allocation
++ */
++ if (my_rsv && (free_blocks < windowsz)
++ && (rsv_is_empty(&my_rsv->rsv_window)))
++ my_rsv = NULL;
++
++ if (free_blocks > 0) {
++ grp_target_blk = ((goal - le32_to_cpu(es->s_first_data_block)) %
++ EXT3COW_BLOCKS_PER_GROUP(sb));
++ bitmap_bh = read_block_bitmap(sb, group_no);
++ if (!bitmap_bh)
++ goto io_error;
++ grp_alloc_blk = ext3cow_try_to_allocate_with_rsv(sb, handle,
++ group_no, bitmap_bh, grp_target_blk,
++ my_rsv, &num, &fatal);
++ if (fatal)
++ goto out;
++ if (grp_alloc_blk >= 0)
++ goto allocated;
++ }
++
++ ngroups = EXT3COW_SB(sb)->s_groups_count;
++ smp_rmb();
++
++ /*
++ * Now search the rest of the groups. We assume that
++ * i and gdp correctly point to the last group visited.
++ */
++ for (bgi = 0; bgi < ngroups; bgi++) {
++ group_no++;
++ if (group_no >= ngroups)
++ group_no = 0;
++ gdp = ext3cow_get_group_desc(sb, group_no, &gdp_bh);
++ if (!gdp)
++ goto io_error;
++ free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
++ /*
++ * skip this group if the number of
++ * free blocks is less than half of the reservation
++ * window size.
++ */
++ if (free_blocks <= (windowsz/2))
++ continue;
++
++ brelse(bitmap_bh);
++ bitmap_bh = read_block_bitmap(sb, group_no);
++ if (!bitmap_bh)
++ goto io_error;
++ /*
++ * try to allocate block(s) from this group, without a goal(-1).
++ */
++ grp_alloc_blk = ext3cow_try_to_allocate_with_rsv(sb, handle,
++ group_no, bitmap_bh, -1, my_rsv,
++ &num, &fatal);
++ if (fatal)
++ goto out;
++ if (grp_alloc_blk >= 0)
++ goto allocated;
++ }
++ /*
++ * We may end up a bogus ealier ENOSPC error due to
++ * filesystem is "full" of reservations, but
++ * there maybe indeed free blocks avaliable on disk
++ * In this case, we just forget about the reservations
++ * just do block allocation as without reservations.
++ */
++ if (my_rsv) {
++ my_rsv = NULL;
++ windowsz = 0;
++ group_no = goal_group;
++ goto retry_alloc;
++ }
++ /* No space left on the device */
++ *errp = -ENOSPC;
++ goto out;
++
++allocated:
++
++ ext3cow_debug("using block group %d(%d)\n",
++ group_no, gdp->bg_free_blocks_count);
++
++ BUFFER_TRACE(gdp_bh, "get_write_access");
++ fatal = ext3cow_journal_get_write_access(handle, gdp_bh);
++ if (fatal)
++ goto out;
++
++ ret_block = grp_alloc_blk + ext3cow_group_first_block_no(sb, group_no);
++
++ if (in_range(le32_to_cpu(gdp->bg_block_bitmap), ret_block, num) ||
++ in_range(le32_to_cpu(gdp->bg_inode_bitmap), ret_block, num) ||
++ in_range(ret_block, le32_to_cpu(gdp->bg_inode_table),
++ EXT3COW_SB(sb)->s_itb_per_group) ||
++ in_range(ret_block + num - 1, le32_to_cpu(gdp->bg_inode_table),
++ EXT3COW_SB(sb)->s_itb_per_group))
++ ext3cow_error(sb, "ext3cow_new_block",
++ "Allocating block in system zone - "
++ "blocks from "E3FSBLK", length %lu",
++ ret_block, num);
++
++ performed_allocation = 1;
++
++#ifdef CONFIG_JBD_DEBUG
++ {
++ struct buffer_head *debug_bh;
++
++ /* Record bitmap buffer state in the newly allocated block */
++ debug_bh = sb_find_get_block(sb, ret_block);
++ if (debug_bh) {
++ BUFFER_TRACE(debug_bh, "state when allocated");
++ BUFFER_TRACE2(debug_bh, bitmap_bh, "bitmap state");
++ brelse(debug_bh);
++ }
++ }
++ jbd_lock_bh_state(bitmap_bh);
++ spin_lock(sb_bgl_lock(sbi, group_no));
++ if (buffer_jbd(bitmap_bh) && bh2jh(bitmap_bh)->b_committed_data) {
++ int i;
++
++ for (i = 0; i < num; i++) {
++ if (ext3cow_test_bit(grp_alloc_blk+i,
++ bh2jh(bitmap_bh)->b_committed_data)) {
++ printk("%s: block was unexpectedly set in "
++ "b_committed_data\n", __FUNCTION__);
++ }
++ }
++ }
++ ext3cow_debug("found bit %d\n", grp_alloc_blk);
++ spin_unlock(sb_bgl_lock(sbi, group_no));
++ jbd_unlock_bh_state(bitmap_bh);
++#endif
++
++ if (ret_block + num - 1 >= le32_to_cpu(es->s_blocks_count)) {
++ ext3cow_error(sb, "ext3cow_new_block",
++ "block("E3FSBLK") >= blocks count(%d) - "
++ "block_group = %d, es == %p ", ret_block,
++ le32_to_cpu(es->s_blocks_count), group_no, es);
++ goto out;
++ }
++
++ /*
++ * It is up to the caller to add the new buffer to a journal
++ * list of some description. We don't know in advance whether
++ * the caller wants to use it as metadata or data.
++ */
++ ext3cow_debug("allocating block %lu. Goal hits %d of %d.\n",
++ ret_block, goal_hits, goal_attempts);
++
++ spin_lock(sb_bgl_lock(sbi, group_no));
++ gdp->bg_free_blocks_count =
++ cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count)-num);
++ spin_unlock(sb_bgl_lock(sbi, group_no));
++ percpu_counter_mod(&sbi->s_freeblocks_counter, -num);
++
++ BUFFER_TRACE(gdp_bh, "journal_dirty_metadata for group descriptor");
++ err = ext3cow_journal_dirty_metadata(handle, gdp_bh);
++ if (!fatal)
++ fatal = err;
++
++ sb->s_dirt = 1;
++ if (fatal)
++ goto out;
++
++ *errp = 0;
++ brelse(bitmap_bh);
++ DQUOT_FREE_BLOCK(inode, *count-num);
++ *count = num;
++ return ret_block;
++
++io_error:
++ *errp = -EIO;
++out:
++ if (fatal) {
++ *errp = fatal;
++ ext3cow_std_error(sb, fatal);
++ }
++ /*
++ * Undo the block allocation
++ */
++ if (!performed_allocation)
++ DQUOT_FREE_BLOCK(inode, *count);
++ brelse(bitmap_bh);
++ return 0;
++}
++
++ext3cow_fsblk_t ext3cow_new_block(handle_t *handle, struct inode *inode,
++ ext3cow_fsblk_t goal, int *errp)
++{
++ unsigned long count = 1;
++
++ return ext3cow_new_blocks(handle, inode, goal, &count, errp);
++}
++
++/**
++ * ext3cow_count_free_blocks() -- count filesystem free blocks
++ * @sb: superblock
++ *
++ * Adds up the number of free blocks from each block group.
++ */
++ext3cow_fsblk_t ext3cow_count_free_blocks(struct super_block *sb)
++{
++ ext3cow_fsblk_t desc_count;
++ struct ext3cow_group_desc *gdp;
++ int i;
++ unsigned long ngroups = EXT3COW_SB(sb)->s_groups_count;
++#ifdef EXT3COWFS_DEBUG
++ struct ext3cow_super_block *es;
++ ext3cow_fsblk_t bitmap_count;
++ unsigned long x;
++ struct buffer_head *bitmap_bh = NULL;
++
++ es = EXT3COW_SB(sb)->s_es;
++ desc_count = 0;
++ bitmap_count = 0;
++ gdp = NULL;
++
++ smp_rmb();
++ for (i = 0; i < ngroups; i++) {
++ gdp = ext3cow_get_group_desc(sb, i, NULL);
++ if (!gdp)
++ continue;
++ desc_count += le16_to_cpu(gdp->bg_free_blocks_count);
++ brelse(bitmap_bh);
++ bitmap_bh = read_block_bitmap(sb, i);
++ if (bitmap_bh == NULL)
++ continue;
++
++ x = ext3cow_count_free(bitmap_bh, sb->s_blocksize);
++ printk("group %d: stored = %d, counted = %lu\n",
++ i, le16_to_cpu(gdp->bg_free_blocks_count), x);
++ bitmap_count += x;
++ }
++ brelse(bitmap_bh);
++ printk("ext3cow_count_free_blocks: stored = "E3FSBLK
++ ", computed = "E3FSBLK", "E3FSBLK"\n",
++ le32_to_cpu(es->s_free_blocks_count),
++ desc_count, bitmap_count);
++ return bitmap_count;
++#else
++ desc_count = 0;
++ smp_rmb();
++ for (i = 0; i < ngroups; i++) {
++ gdp = ext3cow_get_group_desc(sb, i, NULL);
++ if (!gdp)
++ continue;
++ desc_count += le16_to_cpu(gdp->bg_free_blocks_count);
++ }
++
++ return desc_count;
++#endif
++}
++
++static inline int
++block_in_use(ext3cow_fsblk_t block, struct super_block *sb, unsigned char *map)
++{
++ return ext3cow_test_bit ((block -
++ le32_to_cpu(EXT3COW_SB(sb)->s_es->s_first_data_block)) %
++ EXT3COW_BLOCKS_PER_GROUP(sb), map);
++}
++
++static inline int test_root(int a, int b)
++{
++ int num = b;
++
++ while (a > num)
++ num *= b;
++ return num == a;
++}
++
++static int ext3cow_group_sparse(int group)
++{
++ if (group <= 1)
++ return 1;
++ if (!(group & 1))
++ return 0;
++ return (test_root(group, 7) || test_root(group, 5) ||
++ test_root(group, 3));
++}
++
++/**
++ * ext3cow_bg_has_super - number of blocks used by the superblock in group
++ * @sb: superblock for filesystem
++ * @group: group number to check
++ *
++ * Return the number of blocks used by the superblock (primary or backup)
++ * in this group. Currently this will be only 0 or 1.
++ */
++int ext3cow_bg_has_super(struct super_block *sb, int group)
++{
++ if (EXT3COW_HAS_RO_COMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_RO_COMPAT_SPARSE_SUPER) &&
++ !ext3cow_group_sparse(group))
++ return 0;
++ return 1;
++}
++
++static unsigned long ext3cow_bg_num_gdb_meta(struct super_block *sb, int group)
++{
++ unsigned long metagroup = group / EXT3COW_DESC_PER_BLOCK(sb);
++ unsigned long first = metagroup * EXT3COW_DESC_PER_BLOCK(sb);
++ unsigned long last = first + EXT3COW_DESC_PER_BLOCK(sb) - 1;
++
++ if (group == first || group == first + 1 || group == last)
++ return 1;
++ return 0;
++}
++
++static unsigned long ext3cow_bg_num_gdb_nometa(struct super_block *sb, int group)
++{
++ if (EXT3COW_HAS_RO_COMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_RO_COMPAT_SPARSE_SUPER) &&
++ !ext3cow_group_sparse(group))
++ return 0;
++ return EXT3COW_SB(sb)->s_gdb_count;
++}
++
++/**
++ * ext3cow_bg_num_gdb - number of blocks used by the group table in group
++ * @sb: superblock for filesystem
++ * @group: group number to check
++ *
++ * Return the number of blocks used by the group descriptor table
++ * (primary or backup) in this group. In the future there may be a
++ * different number of descriptor blocks in each group.
++ */
++unsigned long ext3cow_bg_num_gdb(struct super_block *sb, int group)
++{
++ unsigned long first_meta_bg =
++ le32_to_cpu(EXT3COW_SB(sb)->s_es->s_first_meta_bg);
++ unsigned long metagroup = group / EXT3COW_DESC_PER_BLOCK(sb);
++
++ if (!EXT3COW_HAS_INCOMPAT_FEATURE(sb,EXT3COW_FEATURE_INCOMPAT_META_BG) ||
++ metagroup < first_meta_bg)
++ return ext3cow_bg_num_gdb_nometa(sb,group);
++
++ return ext3cow_bg_num_gdb_meta(sb,group);
++
++}
+diff -ruN linux-2.6.20.3/fs/ext3cow/bitmap.c linux-2.6.20.3-ext3cow/fs/ext3cow/bitmap.c
+--- linux-2.6.20.3/fs/ext3cow/bitmap.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/bitmap.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,32 @@
++/*
++ * linux/fs/ext3/bitmap.c
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ */
++
++#include
++#include
++#include
++
++#ifdef EXT3COWFS_DEBUG
++
++static int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
++
++unsigned long ext3cow_count_free (struct buffer_head * map, unsigned int numchars)
++{
++ unsigned int i;
++ unsigned long sum = 0;
++
++ if (!map)
++ return (0);
++ for (i = 0; i < numchars; i++)
++ sum += nibblemap[map->b_data[i] & 0xf] +
++ nibblemap[(map->b_data[i] >> 4) & 0xf];
++ return (sum);
++}
++
++#endif /* EXT3COWFS_DEBUG */
++
+diff -ruN linux-2.6.20.3/fs/ext3cow/dir.c linux-2.6.20.3-ext3cow/fs/ext3cow/dir.c
+--- linux-2.6.20.3/fs/ext3cow/dir.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/dir.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,732 @@
++/*
++ * linux/fs/ext3cow/dir.c
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/fs/minix/dir.c
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ *
++ * ext3cow directory handling functions
++ *
++ * Big-endian to little-endian byte-swapping/bitmaps by
++ * David S. Miller (davem@caip.rutgers.edu), 1995
++ *
++ * Hash Tree Directory indexing (c) 2001 Daniel Phillips
++ *
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++
++static unsigned char ext3cow_filetype_table[] = {
++ DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
++};
++
++static int ext3cow_readdir(struct file *, void *, filldir_t);
++static int ext3cow_dx_readdir(struct file * filp,
++ void * dirent, filldir_t filldir);
++static int ext3cow_release_dir (struct inode * inode,
++ struct file * filp);
++
++const struct file_operations ext3cow_dir_operations = {
++ .llseek = generic_file_llseek,
++ .read = generic_read_dir,
++ .readdir = ext3cow_readdir, /* we take BKL. needed?*/
++ .ioctl = ext3cow_ioctl, /* BKL held */
++#ifdef CONFIG_COMPAT
++ .compat_ioctl = ext3cow_compat_ioctl,
++#endif
++ .fsync = ext3cow_sync_file, /* BKL held */
++#ifdef CONFIG_EXT3COW_INDEX
++ .release = ext3cow_release_dir,
++#endif
++};
++
++
++static unsigned char get_dtype(struct super_block *sb, int filetype)
++{
++ if (!EXT3COW_HAS_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_FILETYPE) ||
++ (filetype >= EXT3COW_FT_MAX))
++ return DT_UNKNOWN;
++
++ return (ext3cow_filetype_table[filetype]);
++}
++
++static int ext3cow_readversions(struct file * filp, void * dirent,
++ filldir_t filldir)
++{
++ int error = 0;
++ unsigned long offset;
++ int i, stored;
++ struct buffer_head *bh;
++ struct ext3cow_dir_entry_2 * de;
++ struct super_block * sb;
++ int err;
++ struct inode *dir = filp->f_dentry->d_inode;
++ char *at;
++ unsigned long ino;
++ int ref_len = filp->f_dentry->d_name.len -1;
++
++ sb = dir->i_sb;
++
++ stored = 0;
++ bh = NULL;
++ offset = filp->f_pos & (sb->s_blocksize - 1);
++
++ at = strrchr(filp->f_dentry->d_name.name, EXT3COW_FLUX_TOKEN);
++
++ while (!error && !stored && filp->f_pos < dir->i_size) {
++ unsigned long blk = (filp->f_pos) >> EXT3COW_BLOCK_SIZE_BITS(sb);
++ struct buffer_head map_bh;
++
++ bh = NULL;
++ map_bh.b_state = 0;
++ err = ext3cow_get_blocks_handle(NULL, dir, blk, 1,
++ &map_bh, 0, 0);
++ if (err > 0) {
++ page_cache_readahead(sb->s_bdev->bd_inode->i_mapping,
++ &filp->f_ra,
++ filp,
++ map_bh.b_blocknr >>
++ (PAGE_CACHE_SHIFT - dir->i_blkbits),
++ 1);
++ bh = ext3cow_bread(NULL, dir, blk, 0, &err);
++ }
++
++ /*
++ * We ignore I/O errors on directories so users have a chance
++ * of recovering data when there's a bad sector
++ */
++ if (!bh) {
++ ext3cow_error (sb, "ext3cow_readdir",
++ "directory #%lu contains a hole at offset %lu",
++ dir->i_ino, (unsigned long)filp->f_pos);
++ /* corrupt size? Maybe no more blocks to read */
++ if (filp->f_pos > dir->i_blocks << 9)
++ break;
++ filp->f_pos += sb->s_blocksize - offset;
++ continue;
++ }
++
++ ver_revalidate:
++ /* If the dir block has changed since the last call to
++ * readdir(2), then we might be pointing to an invalid
++ * dirent right now. Scan from the start of the block
++ * to make sure. */
++ if (filp->f_version != dir->i_version) {
++ for (i = 0; i < sb->s_blocksize && i < offset; ) {
++ de = (struct ext3cow_dir_entry_2 *)
++ (bh->b_data + i);
++ /* It's too expensive to do a full
++ * dirent test each time round this
++ * loop, but we do have to test at
++ * least that it is non-zero. A
++ * failure will be detected in the
++ * dirent test below. */
++ if (le16_to_cpu(de->rec_len) <
++ EXT3COW_DIR_REC_LEN(1))
++ break;
++ i += le16_to_cpu(de->rec_len);
++ }
++ offset = i;
++ filp->f_pos = (filp->f_pos & ~(sb->s_blocksize - 1))
++ | offset;
++ filp->f_version = dir->i_version;
++ }
++
++ while (!error && filp->f_pos < dir->i_size
++ && offset < sb->s_blocksize) {
++ de = (struct ext3cow_dir_entry_2 *) (bh->b_data + offset);
++ if (!ext3cow_check_dir_entry ("ext3cow_readdir", dir, de,
++ bh, offset)) {
++ /* On error, skip the f_pos to the
++ next block. */
++ filp->f_pos = (filp->f_pos |
++ (sb->s_blocksize - 1)) + 1;
++ brelse (bh);
++ return stored;
++ }
++ offset += le16_to_cpu(de->rec_len);
++
++ if (le32_to_cpu(de->inode)){
++ unsigned long version = filp->f_version;
++ unsigned char d_type = DT_UNKNOWN;
++
++ /* We might block in the next section
++ * if the data destination is
++ * currently swapped out. So, use a
++ * version stamp to detect whether or
++ * not the directory has been modified
++ * during the copy operation.
++ */
++
++ if (EXT3COW_HAS_INCOMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_INCOMPAT_FILETYPE)
++ && de->file_type < EXT3COW_FT_MAX)
++ d_type =
++ ext3cow_filetype_table[de->file_type];
++ if (de->name_len == ref_len
++ && strncmp(filp->f_dentry->d_name.name, de->name, ref_len)==0) {
++
++ struct inode * inde;
++ char * name;
++
++ name = kmalloc(EXT3COW_NAME_LEN, GFP_KERNEL);
++ strncpy(name, de->name, de->name_len);
++ inde = iget(dir->i_sb, de->inode);
++
++ if (de->death_epoch!=0 && de->birth_epoch!=de->death_epoch) {
++ name[de->name_len]='\0';
++ sprintf(name,"%s@%d",name, de->death_epoch);
++ error = filldir(dirent, name,
++ strlen(name),
++ filp->f_pos,
++ le32_to_cpu(inde->i_ino),
++ d_type);
++ stored++;
++ }
++
++ while (EXT3COW_I(inde)->i_next_inode!=0) {
++ name[de->name_len]='\0';
++ sprintf(name,"%s@%d",name, EXT3COW_I_EPOCHNUMBER(inde));
++ error = filldir(dirent, name,
++ strlen(name),
++ filp->f_pos,
++ le32_to_cpu(inde->i_ino),
++ d_type);
++ ino = EXT3COW_I(inde)->i_next_inode;
++ iput(inde);
++ inde = iget(dir->i_sb, ino);
++ stored++;
++ }
++
++ kfree(name);
++ iput(inde);
++
++ if (error)
++ break;
++
++ if (!stored &&
++ EXT3COW_IS_DIRENT_SCOPED(de, EXT3COW_I_EPOCHNUMBER(dir))) {
++ error = filldir(dirent, de->name,
++ de->name_len,
++ filp->f_pos,
++ le32_to_cpu(de->inode),
++ d_type);
++ }
++
++ if (error)
++ break;
++ if (version != filp->f_version)
++ goto ver_revalidate;
++ stored ++;
++ }
++ }
++
++ filp->f_pos += le16_to_cpu(de->rec_len);
++ }
++ offset = 0;
++ brelse (bh);
++ }
++ return 0;
++}
++
++
++int ext3cow_check_dir_entry (const char * function, struct inode * dir,
++ struct ext3cow_dir_entry_2 * de,
++ struct buffer_head * bh,
++ unsigned long offset)
++{
++ const char * error_msg = NULL;
++ const int rlen = le16_to_cpu(de->rec_len);
++ unsigned int current_epoch = EXT3COW_S_EPOCHNUMBER(dir->i_sb);
++
++ if (rlen < EXT3COW_DIR_REC_LEN(1))
++ error_msg = "rec_len is smaller than minimal";
++ else if (rlen % 4 != 0)
++ error_msg = "rec_len % 4 != 0";
++ else if (rlen < EXT3COW_DIR_REC_LEN(de->name_len))
++ error_msg = "rec_len is too small for name_len";
++ else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
++ error_msg = "directory entry across blocks";
++ else if (le32_to_cpu(de->inode) >
++ le32_to_cpu(EXT3COW_SB(dir->i_sb)->s_es->s_inodes_count))
++ error_msg = "inode out of bounds";
++ /* Some bounds on versioned entries -znjp*/
++ else if (le32_to_cpu(de->death_epoch) != EXT3COW_DIRENT_ALIVE &&
++ le32_to_cpu(de->birth_epoch) > le32_to_cpu(de->death_epoch))
++ error_msg = "entry died before it was born";
++ else if (le32_to_cpu(de->birth_epoch) > current_epoch)
++ error_msg = "entry was born in the future";
++ else if (le32_to_cpu(de->death_epoch) > current_epoch)
++ error_msg = "entry has already died in the future";
++
++ if (error_msg != NULL)
++ ext3cow_error (dir->i_sb, function,
++ "bad entry in directory #%lu: %s - "
++ "offset=%lu, inode=%lu, rec_len=%d, name_len=%d, "
++ "birth_epoch=%d death_epoch=%d",
++ dir->i_ino, error_msg, offset,
++ (unsigned long) le32_to_cpu(de->inode),
++ rlen, de->name_len, de->birth_epoch, de->death_epoch);
++ return error_msg == NULL ? 1 : 0;
++}
++
++static int ext3cow_readdir(struct file * filp,
++ void * dirent, filldir_t filldir)
++{
++ int error = 0;
++ unsigned long offset;
++ int i, stored;
++ struct ext3cow_dir_entry_2 *de;
++ struct super_block *sb;
++ int err;
++ struct inode *inode = filp->f_path.dentry->d_inode;
++ int ret = 0;
++
++ /* is this a version listing? */
++ if (filp->f_dentry->d_name.name[filp->f_dentry->d_name.len-1] ==
++ EXT3COW_FLUX_TOKEN)
++ return ext3cow_readversions(filp, dirent, filldir);
++
++ sb = inode->i_sb;
++
++#ifdef CONFIG_EXT3COW_INDEX
++ if (EXT3COW_HAS_COMPAT_FEATURE(inode->i_sb,
++ EXT3COW_FEATURE_COMPAT_DIR_INDEX) &&
++ ((EXT3COW_I(inode)->i_flags & EXT3COW_INDEX_FL) ||
++ ((inode->i_size >> sb->s_blocksize_bits) == 1))) {
++
++ err = ext3cow_dx_readdir(filp, dirent, filldir);
++ if (err != ERR_BAD_DX_DIR) {
++ ret = err;
++ goto out;
++ }
++ /*
++ * We don't set the inode dirty flag since it's not
++ * critical that it get flushed back to the disk.
++ */
++ EXT3COW_I(filp->f_path.dentry->d_inode)->i_flags &= ~EXT3COW_INDEX_FL;
++ }
++#endif
++ stored = 0;
++ offset = filp->f_pos & (sb->s_blocksize - 1);
++
++ while (!error && !stored && filp->f_pos < inode->i_size) {
++ unsigned long blk = filp->f_pos >> EXT3COW_BLOCK_SIZE_BITS(sb);
++ struct buffer_head map_bh;
++ struct buffer_head *bh = NULL;
++
++ map_bh.b_state = 0;
++ err = ext3cow_get_blocks_handle(NULL, inode, blk, 1,
++ &map_bh, 0, 0);
++ if (err > 0) {
++ page_cache_readahead(sb->s_bdev->bd_inode->i_mapping,
++ &filp->f_ra,
++ filp,
++ map_bh.b_blocknr >>
++ (PAGE_CACHE_SHIFT - inode->i_blkbits),
++ 1);
++ bh = ext3cow_bread(NULL, inode, blk, 0, &err);
++ }
++
++ /*
++ * We ignore I/O errors on directories so users have a chance
++ * of recovering data when there's a bad sector
++ */
++ if (!bh) {
++ ext3cow_error (sb, "ext3cow_readdir",
++ "directory #%lu contains a hole at offset %lu",
++ inode->i_ino, (unsigned long)filp->f_pos);
++ /* corrupt size? Maybe no more blocks to read */
++ if (filp->f_pos > inode->i_blocks << 9)
++ break;
++ filp->f_pos += sb->s_blocksize - offset;
++ continue;
++ }
++
++revalidate:
++ /* If the dir block has changed since the last call to
++ * readdir(2), then we might be pointing to an invalid
++ * dirent right now. Scan from the start of the block
++ * to make sure. */
++ if (filp->f_version != inode->i_version) {
++ for (i = 0; i < sb->s_blocksize && i < offset; ) {
++ de = (struct ext3cow_dir_entry_2 *)
++ (bh->b_data + i);
++ /* It's too expensive to do a full
++ * dirent test each time round this
++ * loop, but we do have to test at
++ * least that it is non-zero. A
++ * failure will be detected in the
++ * dirent test below. */
++ if (le16_to_cpu(de->rec_len) <
++ EXT3COW_DIR_REC_LEN(1))
++ break;
++ i += le16_to_cpu(de->rec_len);
++ }
++ offset = i;
++ filp->f_pos = (filp->f_pos & ~(sb->s_blocksize - 1))
++ | offset;
++ filp->f_version = inode->i_version;
++ }
++
++ while (!error && filp->f_pos < inode->i_size
++ && offset < sb->s_blocksize) {
++ de = (struct ext3cow_dir_entry_2 *) (bh->b_data + offset);
++ if (!ext3cow_check_dir_entry ("ext3cow_readdir", inode, de,
++ bh, offset)) {
++ /* On error, skip the f_pos to the
++ next block. */
++ filp->f_pos = (filp->f_pos |
++ (sb->s_blocksize - 1)) + 1;
++ brelse (bh);
++ ret = stored;
++ goto out;
++ }
++ offset += le16_to_cpu(de->rec_len);
++ /*
++ printk("Inode %ld Epoch number %u: is
++ dir %d -> %s be %d de %d scoped? %d\n",
++ dir->i_ino,
++ EXT3COW_I_EPOCHNUMBER(dir),
++ de->inode,
++ de->name,
++ de->birth_epoch,
++ de->death_epoch,
++ EXT3COW_IS_DIRENT_SCOPED(de, EXT3COW_I_EPOCHNUMBER(dir)));
++ */
++
++ /* Only add scoped dirents - znjp */
++ if (le32_to_cpu(de->inode) &&
++ EXT3COW_IS_DIRENT_SCOPED(de, EXT3COW_I_EPOCHNUMBER(inode))) {
++ /* We might block in the next section
++ * if the data destination is
++ * currently swapped out. So, use a
++ * version stamp to detect whether or
++ * not the directory has been modified
++ * during the copy operation.
++ */
++ unsigned long version = filp->f_version;
++
++ error = filldir(dirent, de->name,
++ de->name_len,
++ filp->f_pos,
++ le32_to_cpu(de->inode),
++ get_dtype(sb, de->file_type));
++ if (error)
++ break;
++ if (version != filp->f_version)
++ goto revalidate;
++ stored ++;
++ }
++ filp->f_pos += le16_to_cpu(de->rec_len);
++ }
++ offset = 0;
++ brelse (bh);
++ }
++out:
++ return ret;
++}
++
++#ifdef CONFIG_EXT3COW_INDEX
++/*
++ * These functions convert from the major/minor hash to an f_pos
++ * value.
++ *
++ * Currently we only use major hash numer. This is unfortunate, but
++ * on 32-bit machines, the same VFS interface is used for lseek and
++ * llseek, so if we use the 64 bit offset, then the 32-bit versions of
++ * lseek/telldir/seekdir will blow out spectacularly, and from within
++ * the ext2 low-level routine, we don't know if we're being called by
++ * a 64-bit version of the system call or the 32-bit version of the
++ * system call. Worse yet, NFSv2 only allows for a 32-bit readdir
++ * cookie. Sigh.
++ */
++#define hash2pos(major, minor) (major >> 1)
++#define pos2maj_hash(pos) ((pos << 1) & 0xffffffff)
++#define pos2min_hash(pos) (0)
++
++/*
++ * This structure holds the nodes of the red-black tree used to store
++ * the directory entry in hash order.
++ */
++struct fname {
++ __u32 hash;
++ __u32 minor_hash;
++ struct rb_node rb_hash;
++ struct fname *next;
++ __u32 inode;
++ __u8 name_len;
++ __u8 file_type;
++ char name[0];
++};
++
++/*
++ * This functoin implements a non-recursive way of freeing all of the
++ * nodes in the red-black tree.
++ */
++static void free_rb_tree_fname(struct rb_root *root)
++{
++ struct rb_node *n = root->rb_node;
++ struct rb_node *parent;
++ struct fname *fname;
++
++ while (n) {
++ /* Do the node's children first */
++ if ((n)->rb_left) {
++ n = n->rb_left;
++ continue;
++ }
++ if (n->rb_right) {
++ n = n->rb_right;
++ continue;
++ }
++ /*
++ * The node has no children; free it, and then zero
++ * out parent's link to it. Finally go to the
++ * beginning of the loop and try to free the parent
++ * node.
++ */
++ parent = rb_parent(n);
++ fname = rb_entry(n, struct fname, rb_hash);
++ while (fname) {
++ struct fname * old = fname;
++ fname = fname->next;
++ kfree (old);
++ }
++ if (!parent)
++ root->rb_node = NULL;
++ else if (parent->rb_left == n)
++ parent->rb_left = NULL;
++ else if (parent->rb_right == n)
++ parent->rb_right = NULL;
++ n = parent;
++ }
++ root->rb_node = NULL;
++}
++
++
++static struct dir_private_info *create_dir_info(loff_t pos)
++{
++ struct dir_private_info *p;
++
++ p = kmalloc(sizeof(struct dir_private_info), GFP_KERNEL);
++ if (!p)
++ return NULL;
++ p->root.rb_node = NULL;
++ p->curr_node = NULL;
++ p->extra_fname = NULL;
++ p->last_pos = 0;
++ p->curr_hash = pos2maj_hash(pos);
++ p->curr_minor_hash = pos2min_hash(pos);
++ p->next_hash = 0;
++ return p;
++}
++
++void ext3cow_htree_free_dir_info(struct dir_private_info *p)
++{
++ free_rb_tree_fname(&p->root);
++ kfree(p);
++}
++
++/*
++ * Given a directory entry, enter it into the fname rb tree.
++ */
++int ext3cow_htree_store_dirent(struct file *dir_file, __u32 hash,
++ __u32 minor_hash,
++ struct ext3cow_dir_entry_2 *dirent)
++{
++ struct rb_node **p, *parent = NULL;
++ struct fname * fname, *new_fn;
++ struct dir_private_info *info;
++ int len;
++
++ info = (struct dir_private_info *) dir_file->private_data;
++ p = &info->root.rb_node;
++
++ /* Create and allocate the fname structure */
++ len = sizeof(struct fname) + dirent->name_len + 1;
++ new_fn = kzalloc(len, GFP_KERNEL);
++ if (!new_fn)
++ return -ENOMEM;
++ new_fn->hash = hash;
++ new_fn->minor_hash = minor_hash;
++ new_fn->inode = le32_to_cpu(dirent->inode);
++ new_fn->name_len = dirent->name_len;
++ new_fn->file_type = dirent->file_type;
++ memcpy(new_fn->name, dirent->name, dirent->name_len);
++ new_fn->name[dirent->name_len] = 0;
++
++ while (*p) {
++ parent = *p;
++ fname = rb_entry(parent, struct fname, rb_hash);
++
++ /*
++ * If the hash and minor hash match up, then we put
++ * them on a linked list. This rarely happens...
++ */
++ if ((new_fn->hash == fname->hash) &&
++ (new_fn->minor_hash == fname->minor_hash)) {
++ new_fn->next = fname->next;
++ fname->next = new_fn;
++ return 0;
++ }
++
++ if (new_fn->hash < fname->hash)
++ p = &(*p)->rb_left;
++ else if (new_fn->hash > fname->hash)
++ p = &(*p)->rb_right;
++ else if (new_fn->minor_hash < fname->minor_hash)
++ p = &(*p)->rb_left;
++ else /* if (new_fn->minor_hash > fname->minor_hash) */
++ p = &(*p)->rb_right;
++ }
++
++ rb_link_node(&new_fn->rb_hash, parent, p);
++ rb_insert_color(&new_fn->rb_hash, &info->root);
++ return 0;
++}
++
++
++
++/*
++ * This is a helper function for ext3cow_dx_readdir. It calls filldir
++ * for all entres on the fname linked list. (Normally there is only
++ * one entry on the linked list, unless there are 62 bit hash collisions.)
++ */
++static int call_filldir(struct file * filp, void * dirent,
++ filldir_t filldir, struct fname *fname)
++{
++ struct dir_private_info *info = filp->private_data;
++ loff_t curr_pos;
++ struct inode *inode = filp->f_path.dentry->d_inode;
++ struct super_block * sb;
++ int error;
++
++ sb = inode->i_sb;
++
++ printk(KERN_INFO, "Got %s\n", filp->f_path.dentry->d_name.name);
++
++ if (!fname) {
++ printk("call_filldir: called with null fname?!?\n");
++ return 0;
++ }
++ curr_pos = hash2pos(fname->hash, fname->minor_hash);
++ while (fname) {
++ error = filldir(dirent, fname->name,
++ fname->name_len, curr_pos,
++ fname->inode,
++ get_dtype(sb, fname->file_type));
++ if (error) {
++ filp->f_pos = curr_pos;
++ info->extra_fname = fname->next;
++ return error;
++ }
++ fname = fname->next;
++ }
++ return 0;
++}
++
++static int ext3cow_dx_readdir(struct file * filp,
++ void * dirent, filldir_t filldir)
++{
++ struct dir_private_info *info = filp->private_data;
++ struct inode *inode = filp->f_path.dentry->d_inode;
++ struct fname *fname;
++ int ret;
++
++ if (!info) {
++ info = create_dir_info(filp->f_pos);
++ if (!info)
++ return -ENOMEM;
++ filp->private_data = info;
++ }
++
++ if (filp->f_pos == EXT3COW_HTREE_EOF)
++ return 0; /* EOF */
++
++ /* Some one has messed with f_pos; reset the world */
++ if (info->last_pos != filp->f_pos) {
++ free_rb_tree_fname(&info->root);
++ info->curr_node = NULL;
++ info->extra_fname = NULL;
++ info->curr_hash = pos2maj_hash(filp->f_pos);
++ info->curr_minor_hash = pos2min_hash(filp->f_pos);
++ }
++
++ /*
++ * If there are any leftover names on the hash collision
++ * chain, return them first.
++ */
++ if (info->extra_fname &&
++ call_filldir(filp, dirent, filldir, info->extra_fname))
++ goto finished;
++
++ if (!info->curr_node)
++ info->curr_node = rb_first(&info->root);
++
++ while (1) {
++ /*
++ * Fill the rbtree if we have no more entries,
++ * or the inode has changed since we last read in the
++ * cached entries.
++ */
++ if ((!info->curr_node) ||
++ (filp->f_version != inode->i_version)) {
++ info->curr_node = NULL;
++ free_rb_tree_fname(&info->root);
++ filp->f_version = inode->i_version;
++ ret = ext3cow_htree_fill_tree(filp, info->curr_hash,
++ info->curr_minor_hash,
++ &info->next_hash);
++ if (ret < 0)
++ return ret;
++ if (ret == 0) {
++ filp->f_pos = EXT3COW_HTREE_EOF;
++ break;
++ }
++ info->curr_node = rb_first(&info->root);
++ }
++
++ fname = rb_entry(info->curr_node, struct fname, rb_hash);
++ info->curr_hash = fname->hash;
++ info->curr_minor_hash = fname->minor_hash;
++ if (call_filldir(filp, dirent, filldir, fname))
++ break;
++
++ info->curr_node = rb_next(info->curr_node);
++ if (!info->curr_node) {
++ if (info->next_hash == ~0) {
++ filp->f_pos = EXT3COW_HTREE_EOF;
++ break;
++ }
++ info->curr_hash = info->next_hash;
++ info->curr_minor_hash = 0;
++ }
++ }
++finished:
++ info->last_pos = filp->f_pos;
++ return 0;
++}
++
++static int ext3cow_release_dir (struct inode * inode, struct file * filp)
++{
++ if (filp->private_data)
++ ext3cow_htree_free_dir_info(filp->private_data);
++
++ return 0;
++}
++
++#endif
+diff -ruN linux-2.6.20.3/fs/ext3cow/ext3cow_jbd.c linux-2.6.20.3-ext3cow/fs/ext3cow/ext3cow_jbd.c
+--- linux-2.6.20.3/fs/ext3cow/ext3cow_jbd.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/ext3cow_jbd.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,59 @@
++/*
++ * Interface between ext3cow and JBD
++ */
++
++#include
++
++int __ext3cow_journal_get_undo_access(const char *where, handle_t *handle,
++ struct buffer_head *bh)
++{
++ int err = journal_get_undo_access(handle, bh);
++ if (err)
++ ext3cow_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
++ return err;
++}
++
++int __ext3cow_journal_get_write_access(const char *where, handle_t *handle,
++ struct buffer_head *bh)
++{
++ int err = journal_get_write_access(handle, bh);
++ if (err)
++ ext3cow_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
++ return err;
++}
++
++int __ext3cow_journal_forget(const char *where, handle_t *handle,
++ struct buffer_head *bh)
++{
++ int err = journal_forget(handle, bh);
++ if (err)
++ ext3cow_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
++ return err;
++}
++
++int __ext3cow_journal_revoke(const char *where, handle_t *handle,
++ unsigned long blocknr, struct buffer_head *bh)
++{
++ int err = journal_revoke(handle, blocknr, bh);
++ if (err)
++ ext3cow_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
++ return err;
++}
++
++int __ext3cow_journal_get_create_access(const char *where,
++ handle_t *handle, struct buffer_head *bh)
++{
++ int err = journal_get_create_access(handle, bh);
++ if (err)
++ ext3cow_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
++ return err;
++}
++
++int __ext3cow_journal_dirty_metadata(const char *where,
++ handle_t *handle, struct buffer_head *bh)
++{
++ int err = journal_dirty_metadata(handle, bh);
++ if (err)
++ ext3cow_journal_abort_handle(where, __FUNCTION__, bh, handle,err);
++ return err;
++}
+diff -ruN linux-2.6.20.3/fs/ext3cow/file.c linux-2.6.20.3-ext3cow/fs/ext3cow/file.c
+--- linux-2.6.20.3/fs/ext3cow/file.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/file.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,147 @@
++/*
++ * linux/fs/ext3cow/file.c
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/fs/minix/file.c
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ *
++ * ext3cow fs regular file handling primitives
++ *
++ * 64-bit file support on 64-bit platforms by Jakub Jelinek
++ * (jj@sunsite.ms.mff.cuni.cz)
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include "xattr.h"
++#include "acl.h"
++
++/*
++ * Called when an inode is released. Note that this is different
++ * from ext3cow_file_open: open gets called at every open, but release
++ * gets called only when /all/ the files are closed.
++ */
++static int ext3cow_release_file (struct inode * inode, struct file * filp)
++{
++ /* if we are the last writer on the inode, drop the block reservation */
++ if ((filp->f_mode & FMODE_WRITE) &&
++ (atomic_read(&inode->i_writecount) == 1))
++ {
++ mutex_lock(&EXT3COW_I(inode)->truncate_mutex);
++ ext3cow_discard_reservation(inode);
++ mutex_unlock(&EXT3COW_I(inode)->truncate_mutex);
++ }
++ if (is_dx(inode) && filp->private_data)
++ ext3cow_htree_free_dir_info(filp->private_data);
++
++ return 0;
++}
++
++static ssize_t
++ext3cow_file_write(struct kiocb *iocb, const struct iovec *iov,
++ unsigned long nr_segs, loff_t pos)
++{
++ struct file *file = iocb->ki_filp;
++ struct inode *inode = file->f_path.dentry->d_inode;
++ struct inode *dir = file->f_path.dentry->d_parent->d_inode;
++ ssize_t ret = 0;
++ int err = 0;
++
++ /* This is the place where we create a new version on write -znjp */
++ if(EXT3COW_S_EPOCHNUMBER(inode->i_sb) > EXT3COW_I_EPOCHNUMBER(inode)){
++ err = ext3cow_dup_inode(dir, inode);
++ if(err)
++ return err;
++ }
++
++ ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
++
++ /*
++ * Skip flushing if there was an error, or if nothing was written.
++ */
++ if (ret <= 0)
++ return ret;
++
++ /*
++ * If the inode is IS_SYNC, or is O_SYNC and we are doing data
++ * journalling then we need to make sure that we force the transaction
++ * to disk to keep all metadata uptodate synchronously.
++ */
++ if (file->f_flags & O_SYNC) {
++ /*
++ * If we are non-data-journaled, then the dirty data has
++ * already been flushed to backing store by generic_osync_inode,
++ * and the inode has been flushed too if there have been any
++ * modifications other than mere timestamp updates.
++ *
++ * Open question --- do we care about flushing timestamps too
++ * if the inode is IS_SYNC?
++ */
++ if (!ext3cow_should_journal_data(inode))
++ return ret;
++
++ goto force_commit;
++ }
++
++ /*
++ * So we know that there has been no forced data flush. If the inode
++ * is marked IS_SYNC, we need to force one ourselves.
++ */
++ if (!IS_SYNC(inode))
++ return ret;
++
++ /*
++ * Open question #2 --- should we force data to disk here too? If we
++ * don't, the only impact is that data=writeback filesystems won't
++ * flush data to disk automatically on IS_SYNC, only metadata (but
++ * historically, that is what ext2 has done.)
++ */
++
++force_commit:
++ err = ext3cow_force_commit(inode->i_sb);
++ if (err)
++ return err;
++ return ret;
++}
++
++const struct file_operations ext3cow_file_operations = {
++ .llseek = generic_file_llseek,
++ .read = do_sync_read,
++ .write = do_sync_write,
++ .aio_read = generic_file_aio_read,
++ .aio_write = ext3cow_file_write,
++ .ioctl = ext3cow_ioctl,
++#ifdef CONFIG_COMPAT
++ .compat_ioctl = ext3cow_compat_ioctl,
++#endif
++ .mmap = generic_file_mmap,
++ .open = generic_file_open,
++ .release = ext3cow_release_file,
++ .fsync = ext3cow_sync_file,
++ .sendfile = generic_file_sendfile,
++ .splice_read = generic_file_splice_read,
++ .splice_write = generic_file_splice_write,
++};
++
++struct inode_operations ext3cow_file_inode_operations = {
++ .truncate = ext3cow_truncate,
++ .setattr = ext3cow_setattr,
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ .setxattr = generic_setxattr,
++ .getxattr = generic_getxattr,
++ .listxattr = ext3cow_listxattr,
++ .removexattr = generic_removexattr,
++#endif
++ .permission = ext3cow_permission,
++};
++
+diff -ruN linux-2.6.20.3/fs/ext3cow/fsync.c linux-2.6.20.3-ext3cow/fs/ext3cow/fsync.c
+--- linux-2.6.20.3/fs/ext3cow/fsync.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/fsync.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,88 @@
++/*
++ * linux/fs/ext3cow/fsync.c
++ *
++ * Copyright (C) 1993 Stephen Tweedie (sct@redhat.com)
++ * from
++ * Copyright (C) 1992 Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ * from
++ * linux/fs/minix/truncate.c Copyright (C) 1991, 1992 Linus Torvalds
++ *
++ * ext3cowfs fsync primitive
++ *
++ * Big-endian to little-endian byte-swapping/bitmaps by
++ * David S. Miller (davem@caip.rutgers.edu), 1995
++ *
++ * Removed unnecessary code duplication for little endian machines
++ * and excessive __inline__s.
++ * Andi Kleen, 1997
++ *
++ * Major simplications and cleanup - we only need to do the metadata, because
++ * we can depend on generic_block_fdatasync() to sync the data blocks.
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++
++/*
++ * akpm: A new design for ext3cow_sync_file().
++ *
++ * This is only called from sys_fsync(), sys_fdatasync() and sys_msync().
++ * There cannot be a transaction open by this task.
++ * Another task could have dirtied this inode. Its data can be in any
++ * state in the journalling system.
++ *
++ * What we do is just kick off a commit and wait on it. This will snapshot the
++ * inode to disk.
++ */
++
++int ext3cow_sync_file(struct file * file, struct dentry *dentry, int datasync)
++{
++ struct inode *inode = dentry->d_inode;
++ int ret = 0;
++
++ J_ASSERT(ext3cow_journal_current_handle() == 0);
++
++ /*
++ * data=writeback:
++ * The caller's filemap_fdatawrite()/wait will sync the data.
++ * sync_inode() will sync the metadata
++ *
++ * data=ordered:
++ * The caller's filemap_fdatawrite() will write the data and
++ * sync_inode() will write the inode if it is dirty. Then the caller's
++ * filemap_fdatawait() will wait on the pages.
++ *
++ * data=journal:
++ * filemap_fdatawrite won't do anything (the buffers are clean).
++ * ext3cow_force_commit will write the file data into the journal and
++ * will wait on that.
++ * filemap_fdatawait() will encounter a ton of newly-dirtied pages
++ * (they were dirtied by commit). But that's OK - the blocks are
++ * safe in-journal, which is all fsync() needs to ensure.
++ */
++ if (ext3cow_should_journal_data(inode)) {
++ ret = ext3cow_force_commit(inode->i_sb);
++ goto out;
++ }
++
++ /*
++ * The VFS has written the file data. If the inode is unaltered
++ * then we need not start a commit.
++ */
++ if (inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC)) {
++ struct writeback_control wbc = {
++ .sync_mode = WB_SYNC_ALL,
++ .nr_to_write = 0, /* sys_fsync did this */
++ };
++ ret = sync_inode(inode, &wbc);
++ }
++out:
++ return ret;
++}
+diff -ruN linux-2.6.20.3/fs/ext3cow/hash.c linux-2.6.20.3-ext3cow/fs/ext3cow/hash.c
+--- linux-2.6.20.3/fs/ext3cow/hash.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/hash.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,152 @@
++/*
++ * linux/fs/ext3cow/hash.c
++ *
++ * Copyright (C) 2002 by Theodore Ts'o
++ *
++ * This file is released under the GPL v2.
++ *
++ * This file may be redistributed under the terms of the GNU Public
++ * License.
++ */
++
++#include
++#include
++#include
++#include
++#include
++
++#define DELTA 0x9E3779B9
++
++static void TEA_transform(__u32 buf[4], __u32 const in[])
++{
++ __u32 sum = 0;
++ __u32 b0 = buf[0], b1 = buf[1];
++ __u32 a = in[0], b = in[1], c = in[2], d = in[3];
++ int n = 16;
++
++ do {
++ sum += DELTA;
++ b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);
++ b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);
++ } while(--n);
++
++ buf[0] += b0;
++ buf[1] += b1;
++}
++
++
++/* The old legacy hash */
++static __u32 dx_hack_hash (const char *name, int len)
++{
++ __u32 hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9;
++ while (len--) {
++ __u32 hash = hash1 + (hash0 ^ (*name++ * 7152373));
++
++ if (hash & 0x80000000) hash -= 0x7fffffff;
++ hash1 = hash0;
++ hash0 = hash;
++ }
++ return (hash0 << 1);
++}
++
++static void str2hashbuf(const char *msg, int len, __u32 *buf, int num)
++{
++ __u32 pad, val;
++ int i;
++
++ pad = (__u32)len | ((__u32)len << 8);
++ pad |= pad << 16;
++
++ val = pad;
++ if (len > num*4)
++ len = num * 4;
++ for (i=0; i < len; i++) {
++ if ((i % 4) == 0)
++ val = pad;
++ val = msg[i] + (val << 8);
++ if ((i % 4) == 3) {
++ *buf++ = val;
++ val = pad;
++ num--;
++ }
++ }
++ if (--num >= 0)
++ *buf++ = val;
++ while (--num >= 0)
++ *buf++ = pad;
++}
++
++/*
++ * Returns the hash of a filename. If len is 0 and name is NULL, then
++ * this function can be used to test whether or not a hash version is
++ * supported.
++ *
++ * The seed is an 4 longword (32 bits) "secret" which can be used to
++ * uniquify a hash. If the seed is all zero's, then some default seed
++ * may be used.
++ *
++ * A particular hash version specifies whether or not the seed is
++ * represented, and whether or not the returned hash is 32 bits or 64
++ * bits. 32 bit hashes will return 0 for the minor hash.
++ */
++int ext3cowfs_dirhash(const char *name, int len, struct dx_hash_info *hinfo)
++{
++ __u32 hash;
++ __u32 minor_hash = 0;
++ const char *p;
++ int i;
++ __u32 in[8], buf[4];
++
++ /* Initialize the default seed for the hash checksum functions */
++ buf[0] = 0x67452301;
++ buf[1] = 0xefcdab89;
++ buf[2] = 0x98badcfe;
++ buf[3] = 0x10325476;
++
++ /* Check to see if the seed is all zero's */
++ if (hinfo->seed) {
++ for (i=0; i < 4; i++) {
++ if (hinfo->seed[i])
++ break;
++ }
++ if (i < 4)
++ memcpy(buf, hinfo->seed, sizeof(buf));
++ }
++
++ switch (hinfo->hash_version) {
++ case DX_HASH_LEGACY:
++ hash = dx_hack_hash(name, len);
++ break;
++ case DX_HASH_HALF_MD4:
++ p = name;
++ while (len > 0) {
++ str2hashbuf(p, len, in, 8);
++ half_md4_transform(buf, in);
++ len -= 32;
++ p += 32;
++ }
++ minor_hash = buf[2];
++ hash = buf[1];
++ break;
++ case DX_HASH_TEA:
++ p = name;
++ while (len > 0) {
++ str2hashbuf(p, len, in, 4);
++ TEA_transform(buf, in);
++ len -= 16;
++ p += 16;
++ }
++ hash = buf[0];
++ minor_hash = buf[1];
++ break;
++ default:
++ hinfo->hash = 0;
++ return -1;
++ }
++ hash = hash & ~1;
++ if (hash == (EXT3COW_HTREE_EOF << 1))
++ hash = (EXT3COW_HTREE_EOF-1) << 1;
++ hinfo->hash = hash;
++ hinfo->minor_hash = minor_hash;
++ return 0;
++}
+diff -ruN linux-2.6.20.3/fs/ext3cow/ialloc.c linux-2.6.20.3-ext3cow/fs/ext3cow/ialloc.c
+--- linux-2.6.20.3/fs/ext3cow/ialloc.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/ialloc.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,763 @@
++/*
++ * linux/fs/ext3cow/ialloc.c
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * BSD ufs-inspired inode and directory allocation by
++ * Stephen Tweedie (sct@redhat.com), 1993
++ * Big-endian to little-endian byte-swapping/bitmaps by
++ * David S. Miller (davem@caip.rutgers.edu), 1995
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++
++#include
++
++#include "xattr.h"
++#include "acl.h"
++
++/*
++ * ialloc.c contains the inodes allocation and deallocation routines
++ */
++
++/*
++ * The free inodes are managed by bitmaps. A file system contains several
++ * blocks groups. Each group contains 1 bitmap block for blocks, 1 bitmap
++ * block for inodes, N blocks for the inode table and data blocks.
++ *
++ * The file system contains group descriptors which are located after the
++ * super block. Each descriptor contains the number of the bitmap block and
++ * the free blocks count in the block.
++ */
++
++
++/*
++ * Read the inode allocation bitmap for a given block_group, reading
++ * into the specified slot in the superblock's bitmap cache.
++ *
++ * Return buffer_head of bitmap on success or NULL.
++ */
++static struct buffer_head *
++read_inode_bitmap(struct super_block * sb, unsigned long block_group)
++{
++ struct ext3cow_group_desc *desc;
++ struct buffer_head *bh = NULL;
++
++ desc = ext3cow_get_group_desc(sb, block_group, NULL);
++ if (!desc)
++ goto error_out;
++
++ bh = sb_bread(sb, le32_to_cpu(desc->bg_inode_bitmap));
++ if (!bh)
++ ext3cow_error(sb, "read_inode_bitmap",
++ "Cannot read inode bitmap - "
++ "block_group = %lu, inode_bitmap = %u",
++ block_group, le32_to_cpu(desc->bg_inode_bitmap));
++error_out:
++ return bh;
++}
++
++/*
++ * NOTE! When we get the inode, we're the only people
++ * that have access to it, and as such there are no
++ * race conditions we have to worry about. The inode
++ * is not on the hash-lists, and it cannot be reached
++ * through the filesystem because the directory entry
++ * has been deleted earlier.
++ *
++ * HOWEVER: we must make sure that we get no aliases,
++ * which means that we have to call "clear_inode()"
++ * _before_ we mark the inode not in use in the inode
++ * bitmaps. Otherwise a newly created file might use
++ * the same inode number (not actually the same pointer
++ * though), and then we'd have two inodes sharing the
++ * same inode number and space on the harddisk.
++ */
++void ext3cow_free_inode (handle_t *handle, struct inode * inode)
++{
++ struct super_block * sb = inode->i_sb;
++ int is_directory;
++ unsigned long ino;
++ struct buffer_head *bitmap_bh = NULL;
++ struct buffer_head *bh2;
++ unsigned long block_group;
++ unsigned long bit;
++ struct ext3cow_group_desc * gdp;
++ struct ext3cow_super_block * es;
++ struct ext3cow_sb_info *sbi;
++ int fatal = 0, err;
++
++ if (atomic_read(&inode->i_count) > 1) {
++ printk ("ext3cow_free_inode: inode has count=%d\n",
++ atomic_read(&inode->i_count));
++ return;
++ }
++ if (inode->i_nlink) {
++ printk ("ext3cow_free_inode: inode has nlink=%d\n",
++ inode->i_nlink);
++ return;
++ }
++ if (!sb) {
++ printk("ext3cow_free_inode: inode on nonexistent device\n");
++ return;
++ }
++ sbi = EXT3COW_SB(sb);
++
++ ino = inode->i_ino;
++ ext3cow_debug ("freeing inode %lu\n", ino);
++
++ /*
++ * Note: we must free any quota before locking the superblock,
++ * as writing the quota to disk may need the lock as well.
++ */
++ DQUOT_INIT(inode);
++ ext3cow_xattr_delete_inode(handle, inode);
++ DQUOT_FREE_INODE(inode);
++ DQUOT_DROP(inode);
++
++ is_directory = S_ISDIR(inode->i_mode);
++
++ /* Do this BEFORE marking the inode not in use or returning an error */
++ clear_inode (inode);
++
++ es = EXT3COW_SB(sb)->s_es;
++ if (ino < EXT3COW_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
++ ext3cow_error (sb, "ext3cow_free_inode",
++ "reserved or nonexistent inode %lu", ino);
++ goto error_return;
++ }
++ block_group = (ino - 1) / EXT3COW_INODES_PER_GROUP(sb);
++ bit = (ino - 1) % EXT3COW_INODES_PER_GROUP(sb);
++ bitmap_bh = read_inode_bitmap(sb, block_group);
++ if (!bitmap_bh)
++ goto error_return;
++
++ BUFFER_TRACE(bitmap_bh, "get_write_access");
++ fatal = ext3cow_journal_get_write_access(handle, bitmap_bh);
++ if (fatal)
++ goto error_return;
++
++ /* Ok, now we can actually update the inode bitmaps.. */
++ if (!ext3cow_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
++ bit, bitmap_bh->b_data))
++ ext3cow_error (sb, "ext3cow_free_inode",
++ "bit already cleared for inode %lu", ino);
++ else {
++ gdp = ext3cow_get_group_desc (sb, block_group, &bh2);
++
++ BUFFER_TRACE(bh2, "get_write_access");
++ fatal = ext3cow_journal_get_write_access(handle, bh2);
++ if (fatal) goto error_return;
++
++ if (gdp) {
++ spin_lock(sb_bgl_lock(sbi, block_group));
++ gdp->bg_free_inodes_count = cpu_to_le16(
++ le16_to_cpu(gdp->bg_free_inodes_count) + 1);
++ if (is_directory)
++ gdp->bg_used_dirs_count = cpu_to_le16(
++ le16_to_cpu(gdp->bg_used_dirs_count) - 1);
++ spin_unlock(sb_bgl_lock(sbi, block_group));
++ percpu_counter_inc(&sbi->s_freeinodes_counter);
++ if (is_directory)
++ percpu_counter_dec(&sbi->s_dirs_counter);
++
++ }
++ BUFFER_TRACE(bh2, "call ext3cow_journal_dirty_metadata");
++ err = ext3cow_journal_dirty_metadata(handle, bh2);
++ if (!fatal) fatal = err;
++ }
++ BUFFER_TRACE(bitmap_bh, "call ext3cow_journal_dirty_metadata");
++ err = ext3cow_journal_dirty_metadata(handle, bitmap_bh);
++ if (!fatal)
++ fatal = err;
++ sb->s_dirt = 1;
++error_return:
++ brelse(bitmap_bh);
++ ext3cow_std_error(sb, fatal);
++}
++
++/*
++ * There are two policies for allocating an inode. If the new inode is
++ * a directory, then a forward search is made for a block group with both
++ * free space and a low directory-to-inode ratio; if that fails, then of
++ * the groups with above-average free space, that group with the fewest
++ * directories already is chosen.
++ *
++ * For other inodes, search forward from the parent directory\'s block
++ * group to find a free inode.
++ */
++static int find_group_dir(struct super_block *sb, struct inode *parent)
++{
++ int ngroups = EXT3COW_SB(sb)->s_groups_count;
++ unsigned int freei, avefreei;
++ struct ext3cow_group_desc *desc, *best_desc = NULL;
++ struct buffer_head *bh;
++ int group, best_group = -1;
++
++ freei = percpu_counter_read_positive(&EXT3COW_SB(sb)->s_freeinodes_counter);
++ avefreei = freei / ngroups;
++
++ for (group = 0; group < ngroups; group++) {
++ desc = ext3cow_get_group_desc (sb, group, &bh);
++ if (!desc || !desc->bg_free_inodes_count)
++ continue;
++ if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
++ continue;
++ if (!best_desc ||
++ (le16_to_cpu(desc->bg_free_blocks_count) >
++ le16_to_cpu(best_desc->bg_free_blocks_count))) {
++ best_group = group;
++ best_desc = desc;
++ }
++ }
++ return best_group;
++}
++
++/*
++ * Orlov's allocator for directories.
++ *
++ * We always try to spread first-level directories.
++ *
++ * If there are blockgroups with both free inodes and free blocks counts
++ * not worse than average we return one with smallest directory count.
++ * Otherwise we simply return a random group.
++ *
++ * For the rest rules look so:
++ *
++ * It's OK to put directory into a group unless
++ * it has too many directories already (max_dirs) or
++ * it has too few free inodes left (min_inodes) or
++ * it has too few free blocks left (min_blocks) or
++ * it's already running too large debt (max_debt).
++ * Parent's group is prefered, if it doesn't satisfy these
++ * conditions we search cyclically through the rest. If none
++ * of the groups look good we just look for a group with more
++ * free inodes than average (starting at parent's group).
++ *
++ * Debt is incremented each time we allocate a directory and decremented
++ * when we allocate an inode, within 0--255.
++ */
++
++#define INODE_COST 64
++#define BLOCK_COST 256
++
++static int find_group_orlov(struct super_block *sb, struct inode *parent)
++{
++ int parent_group = EXT3COW_I(parent)->i_block_group;
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ struct ext3cow_super_block *es = sbi->s_es;
++ int ngroups = sbi->s_groups_count;
++ int inodes_per_group = EXT3COW_INODES_PER_GROUP(sb);
++ unsigned int freei, avefreei;
++ ext3cow_fsblk_t freeb, avefreeb;
++ ext3cow_fsblk_t blocks_per_dir;
++ unsigned int ndirs;
++ int max_debt, max_dirs, min_inodes;
++ ext3cow_grpblk_t min_blocks;
++ int group = -1, i;
++ struct ext3cow_group_desc *desc;
++ struct buffer_head *bh;
++
++ freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter);
++ avefreei = freei / ngroups;
++ freeb = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
++ avefreeb = freeb / ngroups;
++ ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);
++
++ if ((parent == sb->s_root->d_inode) ||
++ (EXT3COW_I(parent)->i_flags & EXT3COW_TOPDIR_FL)) {
++ int best_ndir = inodes_per_group;
++ int best_group = -1;
++
++ get_random_bytes(&group, sizeof(group));
++ parent_group = (unsigned)group % ngroups;
++ for (i = 0; i < ngroups; i++) {
++ group = (parent_group + i) % ngroups;
++ desc = ext3cow_get_group_desc (sb, group, &bh);
++ if (!desc || !desc->bg_free_inodes_count)
++ continue;
++ if (le16_to_cpu(desc->bg_used_dirs_count) >= best_ndir)
++ continue;
++ if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
++ continue;
++ if (le16_to_cpu(desc->bg_free_blocks_count) < avefreeb)
++ continue;
++ best_group = group;
++ best_ndir = le16_to_cpu(desc->bg_used_dirs_count);
++ }
++ if (best_group >= 0)
++ return best_group;
++ goto fallback;
++ }
++
++ blocks_per_dir = (le32_to_cpu(es->s_blocks_count) - freeb) / ndirs;
++
++ max_dirs = ndirs / ngroups + inodes_per_group / 16;
++ min_inodes = avefreei - inodes_per_group / 4;
++ min_blocks = avefreeb - EXT3COW_BLOCKS_PER_GROUP(sb) / 4;
++
++ max_debt = EXT3COW_BLOCKS_PER_GROUP(sb) / max(blocks_per_dir, (ext3cow_fsblk_t)BLOCK_COST);
++ if (max_debt * INODE_COST > inodes_per_group)
++ max_debt = inodes_per_group / INODE_COST;
++ if (max_debt > 255)
++ max_debt = 255;
++ if (max_debt == 0)
++ max_debt = 1;
++
++ for (i = 0; i < ngroups; i++) {
++ group = (parent_group + i) % ngroups;
++ desc = ext3cow_get_group_desc (sb, group, &bh);
++ if (!desc || !desc->bg_free_inodes_count)
++ continue;
++ if (le16_to_cpu(desc->bg_used_dirs_count) >= max_dirs)
++ continue;
++ if (le16_to_cpu(desc->bg_free_inodes_count) < min_inodes)
++ continue;
++ if (le16_to_cpu(desc->bg_free_blocks_count) < min_blocks)
++ continue;
++ return group;
++ }
++
++fallback:
++ for (i = 0; i < ngroups; i++) {
++ group = (parent_group + i) % ngroups;
++ desc = ext3cow_get_group_desc (sb, group, &bh);
++ if (!desc || !desc->bg_free_inodes_count)
++ continue;
++ if (le16_to_cpu(desc->bg_free_inodes_count) >= avefreei)
++ return group;
++ }
++
++ if (avefreei) {
++ /*
++ * The free-inodes counter is approximate, and for really small
++ * filesystems the above test can fail to find any blockgroups
++ */
++ avefreei = 0;
++ goto fallback;
++ }
++
++ return -1;
++}
++
++static int find_group_other(struct super_block *sb, struct inode *parent)
++{
++ int parent_group = EXT3COW_I(parent)->i_block_group;
++ int ngroups = EXT3COW_SB(sb)->s_groups_count;
++ struct ext3cow_group_desc *desc;
++ struct buffer_head *bh;
++ int group, i;
++
++ /*
++ * Try to place the inode in its parent directory
++ */
++ group = parent_group;
++ desc = ext3cow_get_group_desc (sb, group, &bh);
++ if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
++ le16_to_cpu(desc->bg_free_blocks_count))
++ return group;
++
++ /*
++ * We're going to place this inode in a different blockgroup from its
++ * parent. We want to cause files in a common directory to all land in
++ * the same blockgroup. But we want files which are in a different
++ * directory which shares a blockgroup with our parent to land in a
++ * different blockgroup.
++ *
++ * So add our directory's i_ino into the starting point for the hash.
++ */
++ group = (group + parent->i_ino) % ngroups;
++
++ /*
++ * Use a quadratic hash to find a group with a free inode and some free
++ * blocks.
++ */
++ for (i = 1; i < ngroups; i <<= 1) {
++ group += i;
++ if (group >= ngroups)
++ group -= ngroups;
++ desc = ext3cow_get_group_desc (sb, group, &bh);
++ if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
++ le16_to_cpu(desc->bg_free_blocks_count))
++ return group;
++ }
++
++ /*
++ * That failed: try linear search for a free inode, even if that group
++ * has no free blocks.
++ */
++ group = parent_group;
++ for (i = 0; i < ngroups; i++) {
++ if (++group >= ngroups)
++ group = 0;
++ desc = ext3cow_get_group_desc (sb, group, &bh);
++ if (desc && le16_to_cpu(desc->bg_free_inodes_count))
++ return group;
++ }
++
++ return -1;
++}
++
++/*
++ * There are two policies for allocating an inode. If the new inode is
++ * a directory, then a forward search is made for a block group with both
++ * free space and a low directory-to-inode ratio; if that fails, then of
++ * the groups with above-average free space, that group with the fewest
++ * directories already is chosen.
++ *
++ * For other inodes, search forward from the parent directory's block
++ * group to find a free inode.
++ */
++struct inode *ext3cow_new_inode(handle_t *handle, struct inode * dir, int mode)
++{
++ struct super_block *sb;
++ struct buffer_head *bitmap_bh = NULL;
++ struct buffer_head *bh2;
++ int group;
++ unsigned long ino = 0;
++ struct inode * inode;
++ struct ext3cow_group_desc * gdp = NULL;
++ struct ext3cow_super_block * es;
++ struct ext3cow_inode_info *ei;
++ struct ext3cow_sb_info *sbi;
++ int err = 0;
++ struct inode *ret;
++ int i;
++
++ /* Cannot create files in a deleted directory */
++ if (!dir || !dir->i_nlink)
++ return ERR_PTR(-EPERM);
++
++ sb = dir->i_sb;
++ inode = new_inode(sb);
++ if (!inode)
++ return ERR_PTR(-ENOMEM);
++ ei = EXT3COW_I(inode);
++
++ sbi = EXT3COW_SB(sb);
++ es = sbi->s_es;
++ if (S_ISDIR(mode)) {
++ if (test_opt (sb, OLDALLOC))
++ group = find_group_dir(sb, dir);
++ else
++ group = find_group_orlov(sb, dir);
++ } else
++ group = find_group_other(sb, dir);
++
++ err = -ENOSPC;
++ if (group == -1)
++ goto out;
++
++ for (i = 0; i < sbi->s_groups_count; i++) {
++ err = -EIO;
++
++ gdp = ext3cow_get_group_desc(sb, group, &bh2);
++ if (!gdp)
++ goto fail;
++
++ brelse(bitmap_bh);
++ bitmap_bh = read_inode_bitmap(sb, group);
++ if (!bitmap_bh)
++ goto fail;
++
++ ino = 0;
++
++repeat_in_this_group:
++ ino = ext3cow_find_next_zero_bit((unsigned long *)
++ bitmap_bh->b_data, EXT3COW_INODES_PER_GROUP(sb), ino);
++ if (ino < EXT3COW_INODES_PER_GROUP(sb)) {
++
++ BUFFER_TRACE(bitmap_bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, bitmap_bh);
++ if (err)
++ goto fail;
++
++ if (!ext3cow_set_bit_atomic(sb_bgl_lock(sbi, group),
++ ino, bitmap_bh->b_data)) {
++ /* we won it */
++ BUFFER_TRACE(bitmap_bh,
++ "call ext3cow_journal_dirty_metadata");
++ err = ext3cow_journal_dirty_metadata(handle,
++ bitmap_bh);
++ if (err)
++ goto fail;
++ goto got;
++ }
++ /* we lost it */
++ journal_release_buffer(handle, bitmap_bh);
++
++ if (++ino < EXT3COW_INODES_PER_GROUP(sb))
++ goto repeat_in_this_group;
++ }
++
++ /*
++ * This case is possible in concurrent environment. It is very
++ * rare. We cannot repeat the find_group_xxx() call because
++ * that will simply return the same blockgroup, because the
++ * group descriptor metadata has not yet been updated.
++ * So we just go onto the next blockgroup.
++ */
++ if (++group == sbi->s_groups_count)
++ group = 0;
++ }
++ err = -ENOSPC;
++ goto out;
++
++got:
++ ino += group * EXT3COW_INODES_PER_GROUP(sb) + 1;
++ if (ino < EXT3COW_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
++ ext3cow_error (sb, "ext3cow_new_inode",
++ "reserved inode or inode > inodes count - "
++ "block_group = %d, inode=%lu", group, ino);
++ err = -EIO;
++ goto fail;
++ }
++
++ BUFFER_TRACE(bh2, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, bh2);
++ if (err) goto fail;
++ spin_lock(sb_bgl_lock(sbi, group));
++ gdp->bg_free_inodes_count =
++ cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);
++ if (S_ISDIR(mode)) {
++ gdp->bg_used_dirs_count =
++ cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);
++ }
++ spin_unlock(sb_bgl_lock(sbi, group));
++ BUFFER_TRACE(bh2, "call ext3cow_journal_dirty_metadata");
++ err = ext3cow_journal_dirty_metadata(handle, bh2);
++ if (err) goto fail;
++
++ percpu_counter_dec(&sbi->s_freeinodes_counter);
++ if (S_ISDIR(mode))
++ percpu_counter_inc(&sbi->s_dirs_counter);
++ sb->s_dirt = 1;
++
++ inode->i_uid = current->fsuid;
++ if (test_opt (sb, GRPID))
++ inode->i_gid = dir->i_gid;
++ else if (dir->i_mode & S_ISGID) {
++ inode->i_gid = dir->i_gid;
++ if (S_ISDIR(mode))
++ mode |= S_ISGID;
++ } else
++ inode->i_gid = current->fsgid;
++ inode->i_mode = mode;
++
++ inode->i_ino = ino;
++ /* This is the optimal IO size (for stat), not the fs block size */
++ inode->i_blocks = 0;
++ inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
++
++ /* For versioning -znjp */
++ ei->i_cow_bitmap = 0x0000;
++ ei->i_epoch_number = EXT3COW_S_EPOCHNUMBER(dir->i_sb);
++ ei->i_next_inode = 0;
++
++ memset(ei->i_data, 0, sizeof(ei->i_data));
++ ei->i_dir_start_lookup = 0;
++ ei->i_disksize = 0;
++
++ ei->i_flags = EXT3COW_I(dir)->i_flags & ~EXT3COW_INDEX_FL;
++ if (S_ISLNK(mode))
++ ei->i_flags &= ~(EXT3COW_IMMUTABLE_FL|EXT3COW_APPEND_FL);
++ /* dirsync only applies to directories */
++ if (!S_ISDIR(mode))
++ ei->i_flags &= ~EXT3COW_DIRSYNC_FL;
++#ifdef EXT3COW_FRAGMENTS
++ ei->i_faddr = 0;
++ ei->i_frag_no = 0;
++ ei->i_frag_size = 0;
++#endif
++ ei->i_file_acl = 0;
++ ei->i_dir_acl = 0;
++ ei->i_dtime = 0;
++ ei->i_block_alloc_info = NULL;
++ ei->i_block_group = group;
++
++ ext3cow_set_inode_flags(inode);
++ if (IS_DIRSYNC(inode))
++ handle->h_sync = 1;
++ insert_inode_hash(inode);
++ spin_lock(&sbi->s_next_gen_lock);
++ inode->i_generation = sbi->s_next_generation++;
++ spin_unlock(&sbi->s_next_gen_lock);
++
++ ei->i_state = EXT3COW_STATE_NEW;
++ ei->i_extra_isize =
++ (EXT3COW_INODE_SIZE(inode->i_sb) > EXT3COW_GOOD_OLD_INODE_SIZE) ?
++ sizeof(struct ext3cow_inode) - EXT3COW_GOOD_OLD_INODE_SIZE : 0;
++
++ ret = inode;
++ if(DQUOT_ALLOC_INODE(inode)) {
++ err = -EDQUOT;
++ goto fail_drop;
++ }
++
++ err = ext3cow_init_acl(handle, inode, dir);
++ if (err)
++ goto fail_free_drop;
++
++ err = ext3cow_init_security(handle,inode, dir);
++ if (err)
++ goto fail_free_drop;
++
++ err = ext3cow_mark_inode_dirty(handle, inode);
++ if (err) {
++ ext3cow_std_error(sb, err);
++ goto fail_free_drop;
++ }
++
++ ext3cow_debug("allocating inode %lu\n", inode->i_ino);
++ goto really_out;
++fail:
++ ext3cow_std_error(sb, err);
++out:
++ iput(inode);
++ ret = ERR_PTR(err);
++really_out:
++ brelse(bitmap_bh);
++ return ret;
++
++fail_free_drop:
++ DQUOT_FREE_INODE(inode);
++
++fail_drop:
++ DQUOT_DROP(inode);
++ inode->i_flags |= S_NOQUOTA;
++ inode->i_nlink = 0;
++ iput(inode);
++ brelse(bitmap_bh);
++ return ERR_PTR(err);
++}
++
++/* Verify that we are loading a valid orphan from disk */
++struct inode *ext3cow_orphan_get(struct super_block *sb, unsigned long ino)
++{
++ unsigned long max_ino = le32_to_cpu(EXT3COW_SB(sb)->s_es->s_inodes_count);
++ unsigned long block_group;
++ int bit;
++ struct buffer_head *bitmap_bh = NULL;
++ struct inode *inode = NULL;
++
++ /* Error cases - e2fsck has already cleaned up for us */
++ if (ino > max_ino) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "bad orphan ino %lu! e2fsck was run?", ino);
++ goto out;
++ }
++
++ block_group = (ino - 1) / EXT3COW_INODES_PER_GROUP(sb);
++ bit = (ino - 1) % EXT3COW_INODES_PER_GROUP(sb);
++ bitmap_bh = read_inode_bitmap(sb, block_group);
++ if (!bitmap_bh) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "inode bitmap error for orphan %lu", ino);
++ goto out;
++ }
++
++ /* Having the inode bit set should be a 100% indicator that this
++ * is a valid orphan (no e2fsck run on fs). Orphans also include
++ * inodes that were being truncated, so we can't check i_nlink==0.
++ */
++ if (!ext3cow_test_bit(bit, bitmap_bh->b_data) ||
++ !(inode = iget(sb, ino)) || is_bad_inode(inode) ||
++ NEXT_ORPHAN(inode) > max_ino) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "bad orphan inode %lu! e2fsck was run?", ino);
++ printk(KERN_NOTICE "ext3cow_test_bit(bit=%d, block=%llu) = %d\n",
++ bit, (unsigned long long)bitmap_bh->b_blocknr,
++ ext3cow_test_bit(bit, bitmap_bh->b_data));
++ printk(KERN_NOTICE "inode=%p\n", inode);
++ if (inode) {
++ printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
++ is_bad_inode(inode));
++ printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
++ NEXT_ORPHAN(inode));
++ printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
++ }
++ /* Avoid freeing blocks if we got a bad deleted inode */
++ if (inode && inode->i_nlink == 0)
++ inode->i_blocks = 0;
++ iput(inode);
++ inode = NULL;
++ }
++out:
++ brelse(bitmap_bh);
++ return inode;
++}
++
++unsigned long ext3cow_count_free_inodes (struct super_block * sb)
++{
++ unsigned long desc_count;
++ struct ext3cow_group_desc *gdp;
++ int i;
++#ifdef EXT3COWFS_DEBUG
++ struct ext3cow_super_block *es;
++ unsigned long bitmap_count, x;
++ struct buffer_head *bitmap_bh = NULL;
++
++ es = EXT3COW_SB(sb)->s_es;
++ desc_count = 0;
++ bitmap_count = 0;
++ gdp = NULL;
++ for (i = 0; i < EXT3COW_SB(sb)->s_groups_count; i++) {
++ gdp = ext3cow_get_group_desc (sb, i, NULL);
++ if (!gdp)
++ continue;
++ desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
++ brelse(bitmap_bh);
++ bitmap_bh = read_inode_bitmap(sb, i);
++ if (!bitmap_bh)
++ continue;
++
++ x = ext3cow_count_free(bitmap_bh, EXT3COW_INODES_PER_GROUP(sb) / 8);
++ printk("group %d: stored = %d, counted = %lu\n",
++ i, le16_to_cpu(gdp->bg_free_inodes_count), x);
++ bitmap_count += x;
++ }
++ brelse(bitmap_bh);
++ printk("ext3cow_count_free_inodes: stored = %u, computed = %lu, %lu\n",
++ le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
++ return desc_count;
++#else
++ desc_count = 0;
++ for (i = 0; i < EXT3COW_SB(sb)->s_groups_count; i++) {
++ gdp = ext3cow_get_group_desc (sb, i, NULL);
++ if (!gdp)
++ continue;
++ desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
++ cond_resched();
++ }
++ return desc_count;
++#endif
++}
++
++/* Called at mount-time, super-block is locked */
++unsigned long ext3cow_count_dirs (struct super_block * sb)
++{
++ unsigned long count = 0;
++ int i;
++
++ for (i = 0; i < EXT3COW_SB(sb)->s_groups_count; i++) {
++ struct ext3cow_group_desc *gdp = ext3cow_get_group_desc (sb, i, NULL);
++ if (!gdp)
++ continue;
++ count += le16_to_cpu(gdp->bg_used_dirs_count);
++ }
++ return count;
++}
++
+diff -ruN linux-2.6.20.3/fs/ext3cow/inode.c linux-2.6.20.3-ext3cow/fs/ext3cow/inode.c
+--- linux-2.6.20.3/fs/ext3cow/inode.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/inode.c 2007-04-17 11:34:02.000000000 -0400
+@@ -0,0 +1,3474 @@
++/*
++ * linux/fs/ext3cow/inode.c
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/fs/minix/inode.c
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ *
++ * Goal-directed block allocation by Stephen Tweedie
++ * (sct@redhat.com), 1993, 1998
++ * Big-endian to little-endian byte-swapping/bitmaps by
++ * David S. Miller (davem@caip.rutgers.edu), 1995
++ * 64-bit file support on 64-bit platforms by Jakub Jelinek
++ * (jj@sunsite.ms.mff.cuni.cz)
++ *
++ * Assorted race fixes, rewrite of ext3cow_get_block() by Al Viro, 2000
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include "xattr.h"
++#include "acl.h"
++
++static int ext3cow_writepage_trans_blocks(struct inode *inode);
++
++/*
++ * Test whether an inode is a fast symlink.
++ */
++static int ext3cow_inode_is_fast_symlink(struct inode *inode)
++{
++ int ea_blocks = EXT3COW_I(inode)->i_file_acl ?
++ (inode->i_sb->s_blocksize >> 9) : 0;
++
++ return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
++}
++
++/*
++ * The ext3cow forget function must perform a revoke if we are freeing data
++ * which has been journaled. Metadata (eg. indirect blocks) must be
++ * revoked in all cases.
++ *
++ * "bh" may be NULL: a metadata block may have been freed from memory
++ * but there may still be a record of it in the journal, and that record
++ * still needs to be revoked.
++ */
++int ext3cow_forget(handle_t *handle, int is_metadata, struct inode *inode,
++ struct buffer_head *bh, ext3cow_fsblk_t blocknr)
++{
++ int err;
++
++ might_sleep();
++
++ BUFFER_TRACE(bh, "enter");
++
++ jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
++ "data mode %lx\n",
++ bh, is_metadata, inode->i_mode,
++ test_opt(inode->i_sb, DATA_FLAGS));
++
++ /* Never use the revoke function if we are doing full data
++ * journaling: there is no need to, and a V1 superblock won't
++ * support it. Otherwise, only skip the revoke on un-journaled
++ * data blocks. */
++
++ if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3COW_MOUNT_JOURNAL_DATA ||
++ (!is_metadata && !ext3cow_should_journal_data(inode))) {
++ if (bh) {
++ BUFFER_TRACE(bh, "call journal_forget");
++ return ext3cow_journal_forget(handle, bh);
++ }
++ return 0;
++ }
++
++ /*
++ * data!=journal && (is_metadata || should_journal_data(inode))
++ */
++ BUFFER_TRACE(bh, "call ext3cow_journal_revoke");
++ err = ext3cow_journal_revoke(handle, blocknr, bh);
++ if (err)
++ ext3cow_abort(inode->i_sb, __FUNCTION__,
++ "error %d when attempting revoke", err);
++ BUFFER_TRACE(bh, "exit");
++ return err;
++}
++
++/*
++ * Work out how many blocks we need to proceed with the next chunk of a
++ * truncate transaction.
++ */
++static unsigned long blocks_for_truncate(struct inode *inode)
++{
++ unsigned long needed;
++
++ needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9);
++
++ /* Give ourselves just enough room to cope with inodes in which
++ * i_blocks is corrupt: we've seen disk corruptions in the past
++ * which resulted in random data in an inode which looked enough
++ * like a regular file for ext3cow to try to delete it. Things
++ * will go a bit crazy if that happens, but at least we should
++ * try not to panic the whole kernel. */
++ if (needed < 2)
++ needed = 2;
++
++ /* But we need to bound the transaction so we don't overflow the
++ * journal. */
++ if (needed > EXT3COW_MAX_TRANS_DATA)
++ needed = EXT3COW_MAX_TRANS_DATA;
++
++ return EXT3COW_DATA_TRANS_BLOCKS(inode->i_sb) + needed;
++}
++
++/*
++ * Truncate transactions can be complex and absolutely huge. So we need to
++ * be able to restart the transaction at a conventient checkpoint to make
++ * sure we don't overflow the journal.
++ *
++ * start_transaction gets us a new handle for a truncate transaction,
++ * and extend_transaction tries to extend the existing one a bit. If
++ * extend fails, we need to propagate the failure up and restart the
++ * transaction in the top-level truncate loop. --sct
++ */
++static handle_t *start_transaction(struct inode *inode)
++{
++ handle_t *result;
++
++ result = ext3cow_journal_start(inode, blocks_for_truncate(inode));
++ if (!IS_ERR(result))
++ return result;
++
++ ext3cow_std_error(inode->i_sb, PTR_ERR(result));
++ return result;
++}
++
++/*
++ * Try to extend this transaction for the purposes of truncation.
++ *
++ * Returns 0 if we managed to create more room. If we can't create more
++ * room, and the transaction must be restarted we return 1.
++ */
++static int try_to_extend_transaction(handle_t *handle, struct inode *inode)
++{
++ if (handle->h_buffer_credits > EXT3COW_RESERVE_TRANS_BLOCKS)
++ return 0;
++ if (!ext3cow_journal_extend(handle, blocks_for_truncate(inode)))
++ return 0;
++ return 1;
++}
++
++/*
++ * Restart the transaction associated with *handle. This does a commit,
++ * so before we call here everything must be consistently dirtied against
++ * this transaction.
++ */
++static int ext3cow_journal_test_restart(handle_t *handle, struct inode *inode)
++{
++ jbd_debug(2, "restarting handle %p\n", handle);
++ return ext3cow_journal_restart(handle, blocks_for_truncate(inode));
++}
++
++/*
++ * Called at the last iput() if i_nlink is zero.
++ */
++void ext3cow_delete_inode (struct inode * inode)
++{
++ handle_t *handle;
++
++ truncate_inode_pages(&inode->i_data, 0);
++
++ if (is_bad_inode(inode))
++ goto no_delete;
++
++ handle = start_transaction(inode);
++ if (IS_ERR(handle)) {
++ /*
++ * If we're going to skip the normal cleanup, we still need to
++ * make sure that the in-core orphan linked list is properly
++ * cleaned up.
++ */
++ ext3cow_orphan_del(NULL, inode);
++ goto no_delete;
++ }
++
++ if (IS_SYNC(inode))
++ handle->h_sync = 1;
++ inode->i_size = 0;
++ if (inode->i_blocks)
++ ext3cow_truncate(inode);
++ /*
++ * Kill off the orphan record which ext3cow_truncate created.
++ * AKPM: I think this can be inside the above `if'.
++ * Note that ext3cow_orphan_del() has to be able to cope with the
++ * deletion of a non-existent orphan - this is because we don't
++ * know if ext3cow_truncate() actually created an orphan record.
++ * (Well, we could do this if we need to, but heck - it works)
++ */
++ ext3cow_orphan_del(handle, inode);
++ EXT3COW_I(inode)->i_dtime = get_seconds();
++
++ /*
++ * One subtle ordering requirement: if anything has gone wrong
++ * (transaction abort, IO errors, whatever), then we can still
++ * do these next steps (the fs will already have been marked as
++ * having errors), but we can't free the inode if the mark_dirty
++ * fails.
++ */
++ if (ext3cow_mark_inode_dirty(handle, inode))
++ /* If that failed, just do the required in-core inode clear. */
++ clear_inode(inode);
++ else
++ ext3cow_free_inode(handle, inode);
++ ext3cow_journal_stop(handle);
++ return;
++no_delete:
++ clear_inode(inode); /* We must guarantee clearing of inode... */
++}
++
++typedef struct {
++ __le32 *p;
++ __le32 key;
++ struct buffer_head *bh;
++} Indirect;
++
++static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
++{
++ p->key = *(p->p = v);
++ p->bh = bh;
++}
++
++static int verify_chain(Indirect *from, Indirect *to)
++{
++ while (from <= to && from->key == *from->p)
++ from++;
++ return (from > to);
++}
++
++//TODO: Delete at some point
++/* znjp - used for bitmap testing */
++
++ static void printbin(u32 val, int size) {
++ u32 mask;
++
++ mask=(1UL << (size-1));
++ while (mask) {
++ if (mask & val)
++ printk("1");
++ else
++ printk("0");
++ mask /= 2;
++ }
++ printk("\n");
++
++ }
++
++
++/**
++ * ext3cow_block_to_path - parse the block number into array of offsets
++ * @inode: inode in question (we are only interested in its superblock)
++ * @i_block: block number to be parsed
++ * @offsets: array to store the offsets in
++ * @boundary: set this non-zero if the referred-to block is likely to be
++ * followed (on disk) by an indirect block.
++ *
++ * To store the locations of file's data ext3cow uses a data structure common
++ * for UNIX filesystems - tree of pointers anchored in the inode, with
++ * data blocks at leaves and indirect blocks in intermediate nodes.
++ * This function translates the block number into path in that tree -
++ * return value is the path length and @offsets[n] is the offset of
++ * pointer to (n+1)th node in the nth one. If @block is out of range
++ * (negative or too large) warning is printed and zero returned.
++ *
++ * Note: function doesn't find node addresses, so no IO is needed. All
++ * we need to know is the capacity of indirect blocks (taken from the
++ * inode->i_sb).
++ */
++
++/*
++ * Portability note: the last comparison (check that we fit into triple
++ * indirect block) is spelled differently, because otherwise on an
++ * architecture with 32-bit longs and 8Kb pages we might get into trouble
++ * if our filesystem had 8Kb blocks. We might use long long, but that would
++ * kill us on x86. Oh, well, at least the sign propagation does not matter -
++ * i_block would have to be negative in the very beginning, so we would not
++ * get there at all.
++ */
++
++static int ext3cow_block_to_path(struct inode *inode,
++ long i_block, int offsets[4], int *boundary)
++{
++ /* TODO: Check for efficientcy -znjp */
++ int ptrs = EXT3COW_ADDR_PER_BLOCK(inode->i_sb);
++ const long direct_blocks = EXT3COW_NDIR_BLOCKS,
++ indirect_blocks = ptrs,
++ double_blocks = (ptrs * ptrs);
++ //double_blocks = (1 << (ptrs_bits * 2));
++ int n = 0;
++ int final = 0;
++
++ if (i_block < 0) {
++ ext3cow_warning (inode->i_sb, "ext3cow_block_to_path", "block < 0");
++ } else if (i_block < direct_blocks) {
++ offsets[n++] = i_block;
++ final = direct_blocks;
++ } else if ( (i_block -= direct_blocks) < indirect_blocks) {
++ offsets[n++] = EXT3COW_IND_BLOCK;
++ offsets[n++] = i_block;
++ final = ptrs;
++ } else if ((i_block -= indirect_blocks) < double_blocks) {
++ offsets[n++] = EXT3COW_DIND_BLOCK;
++ offsets[n++] = (i_block/ptrs); //i_block >> ptrs_bits;
++ offsets[n++] = (i_block%ptrs); //i_block & (ptrs - 1);
++ final = ptrs;
++ } else if (((i_block -= double_blocks)/(double_blocks)) < ptrs) {
++ // } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
++ offsets[n++] = EXT3COW_TIND_BLOCK;
++ offsets[n++] = (i_block/double_blocks); //i_block >> (ptrs_bits * 2);
++ offsets[n++] = (i_block/double_blocks)%ptrs; //(i_block >> ptrs_bits) & (ptrs - 1);
++ offsets[n++] = i_block%ptrs; //i_block & (ptrs - 1);
++ final = ptrs;
++ } else {
++ ext3cow_warning(inode->i_sb, "ext3cow_block_to_path", "block > big");
++ }
++ if (boundary)
++ *boundary = final - 1 - (i_block & (ptrs - 1));
++ return n;
++}
++
++/**
++ * ext3cow_get_branch - read the chain of indirect blocks leading to data
++ * @inode: inode in question
++ * @depth: depth of the chain (1 - direct pointer, etc.)
++ * @offsets: offsets of pointers in inode/indirect blocks
++ * @chain: place to store the result
++ * @err: here we store the error value
++ *
++ * Function fills the array of triples and returns %NULL
++ * if everything went OK or the pointer to the last filled triple
++ * (incomplete one) otherwise. Upon the return chain[i].key contains
++ * the number of (i+1)-th block in the chain (as it is stored in memory,
++ * i.e. little-endian 32-bit), chain[i].p contains the address of that
++ * number (it points into struct inode for i==0 and into the bh->b_data
++ * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
++ * block for i>0 and NULL for i==0. In other words, it holds the block
++ * numbers of the chain, addresses they were taken from (and where we can
++ * verify that chain did not change) and buffer_heads hosting these
++ * numbers.
++ *
++ * Function stops when it stumbles upon zero pointer (absent block)
++ * (pointer to last triple returned, *@err == 0)
++ * or when it gets an IO error reading an indirect block
++ * (ditto, *@err == -EIO)
++ * or when it notices that chain had been changed while it was reading
++ * (ditto, *@err == -EAGAIN)
++ * or when it reads all @depth-1 indirect blocks successfully and finds
++ * the whole chain, all way to the data (returns %NULL, *err == 0).
++ * If this is COW we set the cow field to 1. We know if it's COW
++ * because there will already be a key. We need this field so we
++ * zero out the data already in the buffer.
++ * The create flag let's us know if were just looking for a block
++ * to read, or a block to write. We only set the bitmap when
++ * we're looking for a block to write, either on new allocation
++ * or on COWing. -znjp
++ */
++static Indirect *ext3cow_get_branch(struct inode *inode, int depth,
++ int *offsets,
++ Indirect chain[4], int *err, int *cow,
++ int create)
++{
++ struct super_block *sb = inode->i_sb;
++ Indirect *p = chain;
++ struct buffer_head *bh;
++ u32* bitmap_w;
++ int ptrs = EXT3COW_ADDR_PER_BLOCK(inode->i_sb);
++ int nbitsperword = (sizeof(u32) * 8);
++
++ *err = 0;
++ *cow = 0;
++ /* i_data is not going away, no lock needed */
++ add_chain (chain, NULL, EXT3COW_I(inode)->i_data + *offsets);
++ if (!p->key){
++ /* Set the bitmap on allocation - znjp */
++ if(create)
++ EXT3COW_I(inode)->i_cow_bitmap |= (1UL << *offsets);
++ goto no_block;
++ }
++
++ /* Are we COWing any direct blocks? -znjp */
++ if(create && !(EXT3COW_I(inode)->i_cow_bitmap & (1UL << *offsets))){
++ printk(KERN_INFO "COWing direct block\n");
++ *(p->p) = 0;
++ p->key = 0;
++ /* Set the bitamp when COWing -znjp */
++ EXT3COW_I(inode)->i_cow_bitmap |= (1UL << *offsets);
++ *cow = 1;
++ goto no_block;
++ }
++
++ while (--depth) {
++ bh = sb_bread(sb, le32_to_cpu(p->key));
++ if (!bh)
++ goto failure;
++
++ /* Reader: pointers */
++ if (!verify_chain(chain, p))
++ goto changed;
++ add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
++ /* Reader: end */
++ /* Find correct bitamp word */
++ bitmap_w = (u32*)bh->b_data + ptrs + (*offsets/nbitsperword);
++ if (!p->key){
++ /* Set the bitmap when allocating -znjp */
++ if(create)
++ *bitmap_w = (u32)*bitmap_w | (u32)(1UL << (int)(*offsets%nbitsperword));
++ goto no_block;
++ }
++
++ /* Are we COWing any indirect blocks? -znjp */
++ if(create && !((1UL << (int)(*offsets%nbitsperword)) &
++ le32_to_cpu((u32)*bitmap_w))){
++ printk(KERN_INFO "COWing indirect block\n");
++ *(p->p) = 0;
++ p->key = 0;
++ /* Set the bitmap -znjp */
++ *bitmap_w = (u32)*bitmap_w | (u32)(1UL << (int)(*offsets%nbitsperword));
++ *cow = 1;
++ goto no_block;
++ }
++ }
++ return NULL;
++
++changed:
++ brelse(bh);
++ *err = -EAGAIN;
++ goto no_block;
++failure:
++ *err = -EIO;
++no_block:
++ return p;
++}
++
++/**
++ * ext3cow_find_near - find a place for allocation with sufficient locality
++ * @inode: owner
++ * @ind: descriptor of indirect block.
++ *
++ * This function returns the prefered place for block allocation.
++ * It is used when heuristic for sequential allocation fails.
++ * Rules are:
++ * + if there is a block to the left of our position - allocate near it.
++ * + if pointer will live in indirect block - allocate near that block.
++ * + if pointer will live in inode - allocate in the same
++ * cylinder group.
++ *
++ * In the latter case we colour the starting block by the callers PID to
++ * prevent it from clashing with concurrent allocations for a different inode
++ * in the same block group. The PID is used here so that functionally related
++ * files will be close-by on-disk.
++ *
++ * Caller must make sure that @ind is valid and will stay that way.
++ */
++static ext3cow_fsblk_t ext3cow_find_near(struct inode *inode, Indirect *ind)
++{
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
++ __le32 *p;
++ ext3cow_fsblk_t bg_start;
++ ext3cow_grpblk_t colour;
++
++ /* Try to find previous block */
++ for (p = ind->p - 1; p >= start; p--) {
++ if (*p)
++ return le32_to_cpu(*p);
++ }
++
++ /* No such thing, so let's try location of indirect block */
++ if (ind->bh)
++ return ind->bh->b_blocknr;
++
++ /*
++ * It is going to be referred to from the inode itself? OK, just put it
++ * into the same cylinder group then.
++ */
++ bg_start = ext3cow_group_first_block_no(inode->i_sb, ei->i_block_group);
++ colour = (current->pid % 16) *
++ (EXT3COW_BLOCKS_PER_GROUP(inode->i_sb) / 16);
++ return bg_start + colour;
++}
++
++/**
++ * ext3cow_find_goal - find a prefered place for allocation.
++ * @inode: owner
++ * @block: block we want
++ * @chain: chain of indirect blocks
++ * @partial: pointer to the last triple within a chain
++ * @goal: place to store the result.
++ *
++ * Normally this function find the prefered place for block allocation,
++ * stores it in *@goal and returns zero.
++ */
++
++static ext3cow_fsblk_t ext3cow_find_goal(struct inode *inode, long block,
++ Indirect chain[4], Indirect *partial)
++{
++ struct ext3cow_block_alloc_info *block_i;
++
++ block_i = EXT3COW_I(inode)->i_block_alloc_info;
++
++ /*
++ * try the heuristic for sequential allocation,
++ * failing that at least try to get decent locality.
++ */
++ if (block_i && (block == block_i->last_alloc_logical_block + 1)
++ && (block_i->last_alloc_physical_block != 0)) {
++ return block_i->last_alloc_physical_block + 1;
++ }
++
++ return ext3cow_find_near(inode, partial);
++}
++
++/**
++ * ext3cow_blks_to_allocate: Look up the block map and count the number
++ * of direct blocks need to be allocated for the given branch.
++ *
++ * @branch: chain of indirect blocks
++ * @k: number of blocks need for indirect blocks
++ * @blks: number of data blocks to be mapped.
++ * @blocks_to_boundary: the offset in the indirect block
++ *
++ * return the total number of blocks to be allocate, including the
++ * direct and indirect blocks.
++ */
++static int ext3cow_blks_to_allocate(Indirect *branch, int k, unsigned long blks,
++ int blocks_to_boundary)
++{
++ unsigned long count = 0;
++
++ /*
++ * Simple case, [t,d]Indirect block(s) has not allocated yet
++ * then it's clear blocks on that path have not allocated
++ */
++ if (k > 0) {
++ /* right now we don't handle cross boundary allocation */
++ if (blks < blocks_to_boundary + 1)
++ count += blks;
++ else
++ count += blocks_to_boundary + 1;
++ return count;
++ }
++
++ count++;
++ while (count < blks && count <= blocks_to_boundary &&
++ le32_to_cpu(*(branch[0].p + count)) == 0) {
++ count++;
++ }
++ return count;
++}
++
++/**
++ * ext3cow_alloc_blocks: multiple allocate blocks needed for a branch
++ * @indirect_blks: the number of blocks need to allocate for indirect
++ * blocks
++ *
++ * @new_blocks: on return it will store the new block numbers for
++ * the indirect blocks(if needed) and the first direct block,
++ * @blks: on return it will store the total number of allocated
++ * direct blocks
++ */
++static int ext3cow_alloc_blocks(handle_t *handle, struct inode *inode,
++ ext3cow_fsblk_t goal, int indirect_blks, int blks,
++ ext3cow_fsblk_t new_blocks[4], int *err)
++{
++ int target, i;
++ unsigned long count = 0;
++ int index = 0;
++ ext3cow_fsblk_t current_block = 0;
++ int ret = 0;
++
++ /*
++ * Here we try to allocate the requested multiple blocks at once,
++ * on a best-effort basis.
++ * To build a branch, we should allocate blocks for
++ * the indirect blocks(if not allocated yet), and at least
++ * the first direct block of this branch. That's the
++ * minimum number of blocks need to allocate(required)
++ */
++ target = blks + indirect_blks;
++
++ while (1) {
++ count = target;
++ /* allocating blocks for indirect blocks and direct blocks */
++ current_block = ext3cow_new_blocks(handle,inode,goal,&count,err);
++ if (*err)
++ goto failed_out;
++
++ target -= count;
++ /* allocate blocks for indirect blocks */
++ while (index < indirect_blks && count) {
++ new_blocks[index++] = current_block++;
++ count--;
++ }
++
++ if (count > 0)
++ break;
++ }
++
++ /* save the new block number for the first direct block */
++ new_blocks[index] = current_block;
++
++ /* total number of blocks allocated for direct blocks */
++ ret = count;
++ *err = 0;
++ return ret;
++failed_out:
++ for (i = 0; i key). Upon the exit we have the same
++ * picture as after the successful ext3cow_get_block(), except that in one
++ * place chain is disconnected - *branch->p is still zero (we did not
++ * set the last link), but branch->key contains the number that should
++ * be placed into *branch->p to fill that gap.
++ *
++ * If allocation fails we free all blocks we've allocated (and forget
++ * their buffer_heads) and return the error value the from failed
++ * ext3cow_alloc_block() (normally -ENOSPC). Otherwise we set the chain
++ * as described above and return 0.
++ */
++static int ext3cow_alloc_branch(handle_t *handle, struct inode *inode,
++ int indirect_blks, int *blks, ext3cow_fsblk_t goal,
++ int *offsets, Indirect *branch)
++{
++ int blocksize = inode->i_sb->s_blocksize;
++ int i, n = 0;
++ int err = 0;
++ struct buffer_head *bh;
++ int num;
++ ext3cow_fsblk_t new_blocks[4];
++ ext3cow_fsblk_t current_block;
++
++ num = ext3cow_alloc_blocks(handle, inode, goal, indirect_blks,
++ *blks, new_blocks, &err);
++ if (err)
++ return err;
++
++ branch[0].key = cpu_to_le32(new_blocks[0]);
++ /*
++ * metadata blocks and data blocks are allocated.
++ */
++ for (n = 1; n <= indirect_blks; n++) {
++ /*
++ * Get buffer_head for parent block, zero it out
++ * and set the pointer to new one, then send
++ * parent to disk.
++ */
++ bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
++ branch[n].bh = bh;
++ lock_buffer(bh);
++ BUFFER_TRACE(bh, "call get_create_access");
++ err = ext3cow_journal_get_create_access(handle, bh);
++ if (err) {
++ unlock_buffer(bh);
++ brelse(bh);
++ goto failed;
++ }
++
++ memset(bh->b_data, 0, blocksize);
++ branch[n].p = (__le32 *) bh->b_data + offsets[n];
++ branch[n].key = cpu_to_le32(new_blocks[n]);
++ *branch[n].p = branch[n].key;
++ if ( n == indirect_blks) {
++ current_block = new_blocks[n];
++ /*
++ * End of chain, update the last new metablock of
++ * the chain to point to the new allocated
++ * data blocks numbers
++ */
++ for (i=1; i < num; i++)
++ *(branch[n].p + i) = cpu_to_le32(++current_block);
++ }
++ BUFFER_TRACE(bh, "marking uptodate");
++ set_buffer_uptodate(bh);
++ unlock_buffer(bh);
++
++ BUFFER_TRACE(bh, "call ext3cow_journal_dirty_metadata");
++ err = ext3cow_journal_dirty_metadata(handle, bh);
++ if (err)
++ goto failed;
++ }
++ *blks = num;
++ return err;
++failed:
++ /* Allocation failed, free what we already allocated */
++ for (i = 1; i <= n ; i++) {
++ BUFFER_TRACE(branch[i].bh, "call journal_forget");
++ ext3cow_journal_forget(handle, branch[i].bh);
++ }
++ for (i = 0; i i_blocks, etc.). In case of success we end up with the full
++ * chain to new block and return 0.
++ */
++static int ext3cow_splice_branch(handle_t *handle, struct inode *inode,
++ long block, Indirect *where, int num, int blks)
++{
++ int i;
++ int err = 0;
++ struct ext3cow_block_alloc_info *block_i;
++ ext3cow_fsblk_t current_block;
++
++ block_i = EXT3COW_I(inode)->i_block_alloc_info;
++ /*
++ * If we're splicing into a [td]indirect block (as opposed to the
++ * inode) then we need to get write access to the [td]indirect block
++ * before the splice.
++ */
++ if (where->bh) {
++ BUFFER_TRACE(where->bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, where->bh);
++ if (err)
++ goto err_out;
++ }
++ /* That's it */
++
++ *where->p = where->key;
++
++ /*
++ * Update the host buffer_head or inode to point to more just allocated
++ * direct blocks blocks
++ */
++ if (num == 0 && blks > 1) {
++ current_block = le32_to_cpu(where->key) + 1;
++ for (i = 1; i < blks; i++)
++ *(where->p + i ) = cpu_to_le32(current_block++);
++ }
++
++ /*
++ * update the most recently allocated logical & physical block
++ * in i_block_alloc_info, to assist find the proper goal block for next
++ * allocation
++ */
++ if (block_i) {
++ block_i->last_alloc_logical_block = block + blks - 1;
++ block_i->last_alloc_physical_block =
++ le32_to_cpu(where[num].key) + blks - 1;
++ }
++
++ /* We are done with atomic stuff, now do the rest of housekeeping */
++
++ inode->i_ctime = CURRENT_TIME_SEC;
++ ext3cow_mark_inode_dirty(handle, inode);
++
++ /* had we spliced it onto indirect block? */
++ if (where->bh) {
++ /*
++ * If we spliced it onto an indirect block, we haven't
++ * altered the inode. Note however that if it is being spliced
++ * onto an indirect block at the very end of the file (the
++ * file is growing) then we *will* alter the inode to reflect
++ * the new i_size. But that is not done here - it is done in
++ * generic_commit_write->__mark_inode_dirty->ext3cow_dirty_inode.
++ */
++ jbd_debug(5, "splicing indirect only\n");
++ BUFFER_TRACE(where->bh, "call ext3cow_journal_dirty_metadata");
++ err = ext3cow_journal_dirty_metadata(handle, where->bh);
++ if (err)
++ goto err_out;
++ } else {
++ /*
++ * OK, we spliced it into the inode itself on a direct block.
++ * Inode was dirtied above.
++ */
++ jbd_debug(5, "splicing direct\n");
++ }
++ return err;
++
++err_out:
++ for (i = 1; i <= num; i++) {
++ BUFFER_TRACE(where[i].bh, "call journal_forget");
++ ext3cow_journal_forget(handle, where[i].bh);
++ ext3cow_free_blocks(handle,inode,le32_to_cpu(where[i-1].key),1);
++ }
++ ext3cow_free_blocks(handle, inode, le32_to_cpu(where[num].key), blks);
++
++ return err;
++}
++
++/*
++ * Allocation strategy is simple: if we have to allocate something, we will
++ * have to go the whole way to leaf. So let's do it before attaching anything
++ * to tree, set linkage between the newborn blocks, write them if sync is
++ * required, recheck the path, free and repeat if check fails, otherwise
++ * set the last missing link (that will protect us from any truncate-generated
++ * removals - all blocks on the path are immune now) and possibly force the
++ * write on the parent block.
++ * That has a nice additional property: no special recovery from the failed
++ * allocations is needed - we simply release blocks and do not touch anything
++ * reachable from inode.
++ *
++ * `handle' can be NULL if create == 0.
++ *
++ * The BKL may not be held on entry here. Be sure to take it early.
++ * return > 0, # of blocks mapped or allocated.
++ * return = 0, if plain lookup failed.
++ * return < 0, error case.
++ */
++int ext3cow_get_blocks_handle(handle_t *handle, struct inode *inode,
++ sector_t iblock, unsigned long maxblocks,
++ struct buffer_head *bh_result,
++ int create, int extend_disksize)
++{
++ int err = -EIO;
++ int offsets[4];
++ Indirect chain[4];
++ Indirect *partial;
++ ext3cow_fsblk_t goal;
++ int indirect_blks;
++ int blocks_to_boundary = 0;
++ int depth;
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ int count = 0;
++ ext3cow_fsblk_t first_block = 0;
++ int cow = 0; /* To determine wether we clear the buffer of not -znjp */
++
++
++ J_ASSERT(handle != NULL || create == 0);
++ depth = ext3cow_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
++
++ if (depth == 0)
++ goto out;
++
++ partial = ext3cow_get_branch(inode, depth, offsets,
++ chain, &err, &cow, create);
++
++ /* Simplest case - block found, no allocation needed */
++ if (!partial) {
++ first_block = le32_to_cpu(chain[depth - 1].key);
++ if(!cow) /* Don't clear the buffer if it's a COW allocation -znjp */
++ clear_buffer_new(bh_result);
++ count++;
++ /*map more blocks*/
++ while (count < maxblocks && count <= blocks_to_boundary) {
++ ext3cow_fsblk_t blk;
++
++ if (!verify_chain(chain, partial)) {
++ /*
++ * Indirect block might be removed by
++ * truncate while we were reading it.
++ * Handling of that case: forget what we've
++ * got now. Flag the err as EAGAIN, so it
++ * will reread.
++ */
++ err = -EAGAIN;
++ count = 0;
++ break;
++ }
++ blk = le32_to_cpu(*(chain[depth-1].p + count));
++
++ if (blk == first_block + count)
++ count++;
++ else
++ break;
++ }
++ if (err != -EAGAIN)
++ goto got_it;
++ }
++
++ /* Next simple case - plain lookup or failed read of indirect block */
++ if (!create || err == -EIO)
++ goto cleanup;
++
++ mutex_lock(&ei->truncate_mutex);
++
++ /*
++ * If the indirect block is missing while we are reading
++ * the chain(ext3cow_get_branch() returns -EAGAIN err), or
++ * if the chain has been changed after we grab the semaphore,
++ * (either because another process truncated this branch, or
++ * another get_block allocated this branch) re-grab the chain to see if
++ * the request block has been allocated or not.
++ *
++ * Since we already block the truncate/other get_block
++ * at this point, we will have the current copy of the chain when we
++ * splice the branch into the tree.
++ */
++ if (err == -EAGAIN || !verify_chain(chain, partial)) {
++ while (partial > chain) {
++ brelse(partial->bh);
++ partial--;
++ }
++ partial = ext3cow_get_branch(inode, depth, offsets,
++ chain, &err, &cow, create);
++ if (!partial) {
++ count++;
++ mutex_unlock(&ei->truncate_mutex);
++ if (err)
++ goto cleanup;
++ /* Don't clear the buffer if we're COWing it -znjp */
++ if(!cow)
++ clear_buffer_new(bh_result);
++ goto got_it;
++ }
++ }
++
++ /*
++ * Okay, we need to do block allocation. Lazily initialize the block
++ * allocation info here if necessary
++ */
++ if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
++ ext3cow_init_block_alloc_info(inode);
++
++ goal = ext3cow_find_goal(inode, iblock, chain, partial);
++
++ /* the number of blocks need to allocate for [d,t]indirect blocks */
++ indirect_blks = (chain + depth) - partial - 1;
++
++ /*
++ * Next look up the indirect map to count the totoal number of
++ * direct blocks to allocate for this branch.
++ */
++ count = ext3cow_blks_to_allocate(partial, indirect_blks,
++ maxblocks, blocks_to_boundary);
++ /*
++ * Block out ext3cow_truncate while we alter the tree
++ */
++ err = ext3cow_alloc_branch(handle, inode, indirect_blks, &count, goal,
++ offsets + (partial - chain), partial);
++
++ /*
++ * The ext3cow_splice_branch call will free and forget any buffers
++ * on the new chain if there is a failure, but that risks using
++ * up transaction credits, especially for bitmaps where the
++ * credits cannot be returned. Can we handle this somehow? We
++ * may need to return -EAGAIN upwards in the worst case. --sct
++ */
++ if (!err)
++ err = ext3cow_splice_branch(handle, inode, iblock,
++ partial, indirect_blks, count);
++ /*
++ * i_disksize growing is protected by truncate_mutex. Don't forget to
++ * protect it if you're about to implement concurrent
++ * ext3cow_get_block() -bzzz
++ */
++ if (!err && extend_disksize && inode->i_size > ei->i_disksize)
++ ei->i_disksize = inode->i_size;
++ mutex_unlock(&ei->truncate_mutex);
++ if (err)
++ goto cleanup;
++
++ set_buffer_new(bh_result);
++got_it:
++ map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
++ if (count > blocks_to_boundary)
++ set_buffer_boundary(bh_result);
++ err = count;
++ /* Clean up and exit */
++ partial = chain + depth - 1; /* the whole chain */
++cleanup:
++ while (partial > chain) {
++ BUFFER_TRACE(partial->bh, "call brelse");
++ brelse(partial->bh);
++ partial--;
++ }
++ BUFFER_TRACE(bh_result, "returned");
++out:
++ return err;
++}
++
++#define DIO_CREDITS (EXT3COW_RESERVE_TRANS_BLOCKS + 32)
++
++static int ext3cow_get_block(struct inode *inode, sector_t iblock,
++ struct buffer_head *bh_result, int create)
++{
++ handle_t *handle = journal_current_handle();
++ int ret = 0;
++ unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
++
++ if (!create)
++ goto get_block; /* A read */
++
++ if (max_blocks == 1)
++ goto get_block; /* A single block get */
++
++ if (handle->h_transaction->t_state == T_LOCKED) {
++ /*
++ * Huge direct-io writes can hold off commits for long
++ * periods of time. Let this commit run.
++ */
++ ext3cow_journal_stop(handle);
++ handle = ext3cow_journal_start(inode, DIO_CREDITS);
++ if (IS_ERR(handle))
++ ret = PTR_ERR(handle);
++ goto get_block;
++ }
++
++ if (handle->h_buffer_credits <= EXT3COW_RESERVE_TRANS_BLOCKS) {
++ /*
++ * Getting low on buffer credits...
++ */
++ ret = ext3cow_journal_extend(handle, DIO_CREDITS);
++ if (ret > 0) {
++ /*
++ * Couldn't extend the transaction. Start a new one.
++ */
++ ret = ext3cow_journal_restart(handle, DIO_CREDITS);
++ }
++ }
++
++get_block:
++ if (ret == 0) {
++ ret = ext3cow_get_blocks_handle(handle, inode, iblock,
++ max_blocks, bh_result, create, 0);
++ if (ret > 0) {
++ bh_result->b_size = (ret << inode->i_blkbits);
++ ret = 0;
++ }
++ }
++ return ret;
++}
++
++/*
++ * `handle' can be NULL if create is zero
++ */
++struct buffer_head *ext3cow_getblk(handle_t *handle, struct inode *inode,
++ long block, int create, int *errp)
++{
++ struct buffer_head dummy;
++ int fatal = 0, err;
++
++ J_ASSERT(handle != NULL || create == 0);
++
++ dummy.b_state = 0;
++ dummy.b_blocknr = -1000;
++ buffer_trace_init(&dummy.b_history);
++ err = ext3cow_get_blocks_handle(handle, inode, block, 1,
++ &dummy, create, 1);
++ /*
++ * ext3cow_get_blocks_handle() returns number of blocks
++ * mapped. 0 in case of a HOLE.
++ */
++ if (err > 0) {
++ if (err > 1)
++ WARN_ON(1);
++ err = 0;
++ }
++ *errp = err;
++ if (!err && buffer_mapped(&dummy)) {
++ struct buffer_head *bh;
++ bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
++ if (!bh) {
++ *errp = -EIO;
++ goto err;
++ }
++ if (buffer_new(&dummy)) {
++ J_ASSERT(create != 0);
++ J_ASSERT(handle != 0);
++
++ /*
++ * Now that we do not always journal data, we should
++ * keep in mind whether this should always journal the
++ * new buffer as metadata. For now, regular file
++ * writes use ext3cow_get_block instead, so it's not a
++ * problem.
++ */
++ lock_buffer(bh);
++ BUFFER_TRACE(bh, "call get_create_access");
++ fatal = ext3cow_journal_get_create_access(handle, bh);
++ if (!fatal && !buffer_uptodate(bh)) {
++ memset(bh->b_data,0,inode->i_sb->s_blocksize);
++ set_buffer_uptodate(bh);
++ }
++ unlock_buffer(bh);
++ BUFFER_TRACE(bh, "call ext3cow_journal_dirty_metadata");
++ err = ext3cow_journal_dirty_metadata(handle, bh);
++ if (!fatal)
++ fatal = err;
++ } else {
++ BUFFER_TRACE(bh, "not a new buffer");
++ }
++ if (fatal) {
++ *errp = fatal;
++ brelse(bh);
++ bh = NULL;
++ }
++ return bh;
++ }
++err:
++ return NULL;
++}
++
++struct buffer_head *ext3cow_bread(handle_t *handle, struct inode *inode,
++ int block, int create, int *err)
++{
++ struct buffer_head * bh;
++
++ bh = ext3cow_getblk(handle, inode, block, create, err);
++ if (!bh)
++ return bh;
++ if (buffer_uptodate(bh))
++ return bh;
++ ll_rw_block(READ_META, 1, &bh);
++ wait_on_buffer(bh);
++ if (buffer_uptodate(bh))
++ return bh;
++ put_bh(bh);
++ *err = -EIO;
++ return NULL;
++}
++
++static int walk_page_buffers( handle_t *handle,
++ struct buffer_head *head,
++ unsigned from,
++ unsigned to,
++ int *partial,
++ int (*fn)( handle_t *handle,
++ struct buffer_head *bh))
++{
++ struct buffer_head *bh;
++ unsigned block_start, block_end;
++ unsigned blocksize = head->b_size;
++ int err, ret = 0;
++ struct buffer_head *next;
++
++ for ( bh = head, block_start = 0;
++ ret == 0 && (bh != head || !block_start);
++ block_start = block_end, bh = next)
++ {
++ next = bh->b_this_page;
++ block_end = block_start + blocksize;
++ if (block_end <= from || block_start >= to) {
++ if (partial && !buffer_uptodate(bh))
++ *partial = 1;
++ continue;
++ }
++ err = (*fn)(handle, bh);
++ if (!ret)
++ ret = err;
++ }
++ return ret;
++}
++
++/*
++ * To preserve ordering, it is essential that the hole instantiation and
++ * the data write be encapsulated in a single transaction. We cannot
++ * close off a transaction and start a new one between the ext3cow_get_block()
++ * and the commit_write(). So doing the journal_start at the start of
++ * prepare_write() is the right place.
++ *
++ * Also, this function can nest inside ext3cow_writepage() ->
++ * block_write_full_page(). In that case, we *know* that ext3cow_writepage()
++ * has generated enough buffer credits to do the whole page. So we won't
++ * block on the journal in that case, which is good, because the caller may
++ * be PF_MEMALLOC.
++ *
++ * By accident, ext3cow can be reentered when a transaction is open via
++ * quota file writes. If we were to commit the transaction while thus
++ * reentered, there can be a deadlock - we would be holding a quota
++ * lock, and the commit would never complete if another thread had a
++ * transaction open and was blocking on the quota lock - a ranking
++ * violation.
++ *
++ * So what we do is to rely on the fact that journal_stop/journal_start
++ * will _not_ run commit under these circumstances because handle->h_ref
++ * is elevated. We'll still have enough credits for the tiny quotafile
++ * write.
++ */
++static int do_journal_get_write_access(handle_t *handle,
++ struct buffer_head *bh)
++{
++ if (!buffer_mapped(bh) || buffer_freed(bh))
++ return 0;
++ return ext3cow_journal_get_write_access(handle, bh);
++}
++
++/*
++ * The idea of this helper function is following:
++ * if prepare_write has allocated some blocks, but not all of them, the
++ * transaction must include the content of the newly allocated blocks.
++ * This content is expected to be set to zeroes by block_prepare_write().
++ * 2006/10/14 SAW
++ */
++static int ext3cow_prepare_failure(struct file *file, struct page *page,
++ unsigned from, unsigned to)
++{
++ struct address_space *mapping;
++ struct buffer_head *bh, *head, *next;
++ unsigned block_start, block_end;
++ unsigned blocksize;
++ int ret;
++ handle_t *handle = ext3cow_journal_current_handle();
++
++ mapping = page->mapping;
++ if (ext3cow_should_writeback_data(mapping->host)) {
++ /* optimization: no constraints about data */
++skip:
++ return ext3cow_journal_stop(handle);
++ }
++
++ head = page_buffers(page);
++ blocksize = head->b_size;
++ for ( bh = head, block_start = 0;
++ bh != head || !block_start;
++ block_start = block_end, bh = next)
++ {
++ next = bh->b_this_page;
++ block_end = block_start + blocksize;
++ if (block_end <= from)
++ continue;
++ if (block_start >= to) {
++ block_start = to;
++ break;
++ }
++ if (!buffer_mapped(bh))
++ /* prepare_write failed on this bh */
++ break;
++ if (ext3cow_should_journal_data(mapping->host)) {
++ ret = do_journal_get_write_access(handle, bh);
++ if (ret) {
++ ext3cow_journal_stop(handle);
++ return ret;
++ }
++ }
++ /*
++ * block_start here becomes the first block where the current iteration
++ * of prepare_write failed.
++ */
++ }
++ if (block_start <= from)
++ goto skip;
++
++ /* commit allocated and zeroed buffers */
++ return mapping->a_ops->commit_write(file, page, from, block_start);
++}
++
++/* Used to quickly unmap all buffers in a page for COWing -znjp */
++static int ext3cow_clear_buffer_mapped(handle_t *handle,
++ struct buffer_head *bh)
++{
++ clear_buffer_mapped(bh);
++ return 0;
++}
++
++static int ext3cow_prepare_write(struct file *file, struct page *page,
++ unsigned from, unsigned to)
++{
++ struct inode *inode = page->mapping->host;
++ int ret, ret2;
++ int needed_blocks = ext3cow_writepage_trans_blocks(inode);
++ handle_t *handle;
++ int retries = 0;
++
++retry:
++ handle = ext3cow_journal_start(inode, needed_blocks);
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ /* Unset the BH_Mapped flag so get_block is always called -znjp */
++ if(page_has_buffers(page))
++ ret = walk_page_buffers(handle, page_buffers(page),
++ from, to, NULL, ext3cow_clear_buffer_mapped);
++
++ if (test_opt(inode->i_sb, NOBH) && ext3cow_should_writeback_data(inode))
++ ret = nobh_prepare_write(page, from, to, ext3cow_get_block);
++ else
++ ret = block_prepare_write(page, from, to, ext3cow_get_block);
++ if (ret)
++ goto failure;
++
++ if (ext3cow_should_journal_data(inode)) {
++ ret = walk_page_buffers(handle, page_buffers(page),
++ from, to, NULL, do_journal_get_write_access);
++ if (ret)
++ /* fatal error, just put the handle and return */
++ journal_stop(handle);
++ }
++ return ret;
++
++failure:
++ ret2 = ext3cow_prepare_failure(file, page, from, to);
++ if (ret2 < 0)
++ return ret2;
++ if (ret == -ENOSPC && ext3cow_should_retry_alloc(inode->i_sb, &retries))
++ goto retry;
++ /* retry number exceeded, or other error like -EDQUOT */
++ return ret;
++}
++
++int ext3cow_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
++{
++ int err = journal_dirty_data(handle, bh);
++ if (err)
++ ext3cow_journal_abort_handle(__FUNCTION__, __FUNCTION__,
++ bh, handle,err);
++ return err;
++}
++
++/* For commit_write() in data=journal mode */
++static int commit_write_fn(handle_t *handle, struct buffer_head *bh)
++{
++ if (!buffer_mapped(bh) || buffer_freed(bh))
++ return 0;
++ set_buffer_uptodate(bh);
++ return ext3cow_journal_dirty_metadata(handle, bh);
++}
++
++/*
++ * We need to pick up the new inode size which generic_commit_write gave us
++ * `file' can be NULL - eg, when called from page_symlink().
++ *
++ * ext3cow never places buffers on inode->i_mapping->private_list. metadata
++ * buffers are managed internally.
++ */
++static int ext3cow_ordered_commit_write(struct file *file, struct page *page,
++ unsigned from, unsigned to)
++{
++ handle_t *handle = ext3cow_journal_current_handle();
++ struct inode *inode = page->mapping->host;
++ int ret = 0, ret2;
++
++ ret = walk_page_buffers(handle, page_buffers(page),
++ from, to, NULL, ext3cow_journal_dirty_data);
++
++ if (ret == 0) {
++ /*
++ * generic_commit_write() will run mark_inode_dirty() if i_size
++ * changes. So let's piggyback the i_disksize mark_inode_dirty
++ * into that.
++ */
++ loff_t new_i_size;
++
++ new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
++ if (new_i_size > EXT3COW_I(inode)->i_disksize)
++ EXT3COW_I(inode)->i_disksize = new_i_size;
++ ret = generic_commit_write(file, page, from, to);
++ }
++ ret2 = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = ret2;
++ return ret;
++}
++
++static int ext3cow_writeback_commit_write(struct file *file, struct page *page,
++ unsigned from, unsigned to)
++{
++ handle_t *handle = ext3cow_journal_current_handle();
++ struct inode *inode = page->mapping->host;
++ int ret = 0, ret2;
++ loff_t new_i_size;
++
++ new_i_size = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
++ if (new_i_size > EXT3COW_I(inode)->i_disksize)
++ EXT3COW_I(inode)->i_disksize = new_i_size;
++
++ if (test_opt(inode->i_sb, NOBH) && ext3cow_should_writeback_data(inode))
++ ret = nobh_commit_write(file, page, from, to);
++ else
++ ret = generic_commit_write(file, page, from, to);
++
++ ret2 = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = ret2;
++ return ret;
++}
++
++static int ext3cow_journalled_commit_write(struct file *file,
++ struct page *page, unsigned from, unsigned to)
++{
++ handle_t *handle = ext3cow_journal_current_handle();
++ struct inode *inode = page->mapping->host;
++ int ret = 0, ret2;
++ int partial = 0;
++ loff_t pos;
++
++ /*
++ * Here we duplicate the generic_commit_write() functionality
++ */
++ pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
++
++ ret = walk_page_buffers(handle, page_buffers(page), from,
++ to, &partial, commit_write_fn);
++ if (!partial)
++ SetPageUptodate(page);
++ if (pos > inode->i_size)
++ i_size_write(inode, pos);
++ EXT3COW_I(inode)->i_state |= EXT3COW_STATE_JDATA;
++ if (inode->i_size > EXT3COW_I(inode)->i_disksize) {
++ EXT3COW_I(inode)->i_disksize = inode->i_size;
++ ret2 = ext3cow_mark_inode_dirty(handle, inode);
++ if (!ret)
++ ret = ret2;
++ }
++ ret2 = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = ret2;
++ return ret;
++}
++
++/*
++ * bmap() is special. It gets used by applications such as lilo and by
++ * the swapper to find the on-disk block of a specific piece of data.
++ *
++ * Naturally, this is dangerous if the block concerned is still in the
++ * journal. If somebody makes a swapfile on an ext3cow data-journaling
++ * filesystem and enables swap, then they may get a nasty shock when the
++ * data getting swapped to that swapfile suddenly gets overwritten by
++ * the original zero's written out previously to the journal and
++ * awaiting writeback in the kernel's buffer cache.
++ *
++ * So, if we see any bmap calls here on a modified, data-journaled file,
++ * take extra steps to flush any blocks which might be in the cache.
++ */
++static sector_t ext3cow_bmap(struct address_space *mapping, sector_t block)
++{
++ struct inode *inode = mapping->host;
++ journal_t *journal;
++ int err;
++
++ if (EXT3COW_I(inode)->i_state & EXT3COW_STATE_JDATA) {
++ /*
++ * This is a REALLY heavyweight approach, but the use of
++ * bmap on dirty files is expected to be extremely rare:
++ * only if we run lilo or swapon on a freshly made file
++ * do we expect this to happen.
++ *
++ * (bmap requires CAP_SYS_RAWIO so this does not
++ * represent an unprivileged user DOS attack --- we'd be
++ * in trouble if mortal users could trigger this path at
++ * will.)
++ *
++ * NB. EXT3COW_STATE_JDATA is not set on files other than
++ * regular files. If somebody wants to bmap a directory
++ * or symlink and gets confused because the buffer
++ * hasn't yet been flushed to disk, they deserve
++ * everything they get.
++ */
++
++ EXT3COW_I(inode)->i_state &= ~EXT3COW_STATE_JDATA;
++ journal = EXT3COW_JOURNAL(inode);
++ journal_lock_updates(journal);
++ err = journal_flush(journal);
++ journal_unlock_updates(journal);
++
++ if (err)
++ return 0;
++ }
++
++ return generic_block_bmap(mapping,block,ext3cow_get_block);
++}
++
++static int bget_one(handle_t *handle, struct buffer_head *bh)
++{
++ get_bh(bh);
++ return 0;
++}
++
++static int bput_one(handle_t *handle, struct buffer_head *bh)
++{
++ put_bh(bh);
++ return 0;
++}
++
++static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
++{
++ if (buffer_mapped(bh))
++ return ext3cow_journal_dirty_data(handle, bh);
++ return 0;
++}
++
++/*
++ * Note that we always start a transaction even if we're not journalling
++ * data. This is to preserve ordering: any hole instantiation within
++ * __block_write_full_page -> ext3cow_get_block() should be journalled
++ * along with the data so we don't crash and then get metadata which
++ * refers to old data.
++ *
++ * In all journalling modes block_write_full_page() will start the I/O.
++ *
++ * Problem:
++ *
++ * ext3cow_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
++ * ext3cow_writepage()
++ *
++ * Similar for:
++ *
++ * ext3cow_file_write() -> generic_file_write() -> __alloc_pages() -> ...
++ *
++ * Same applies to ext3cow_get_block(). We will deadlock on various things like
++ * lock_journal and i_truncate_mutex.
++ *
++ * Setting PF_MEMALLOC here doesn't work - too many internal memory
++ * allocations fail.
++ *
++ * 16May01: If we're reentered then journal_current_handle() will be
++ * non-zero. We simply *return*.
++ *
++ * 1 July 2001: @@@ FIXME:
++ * In journalled data mode, a data buffer may be metadata against the
++ * current transaction. But the same file is part of a shared mapping
++ * and someone does a writepage() on it.
++ *
++ * We will move the buffer onto the async_data list, but *after* it has
++ * been dirtied. So there's a small window where we have dirty data on
++ * BJ_Metadata.
++ *
++ * Note that this only applies to the last partial page in the file. The
++ * bit which block_write_full_page() uses prepare/commit for. (That's
++ * broken code anyway: it's wrong for msync()).
++ *
++ * It's a rare case: affects the final partial page, for journalled data
++ * where the file is subject to bith write() and writepage() in the same
++ * transction. To fix it we'll need a custom block_write_full_page().
++ * We'll probably need that anyway for journalling writepage() output.
++ *
++ * We don't honour synchronous mounts for writepage(). That would be
++ * disastrous. Any write() or metadata operation will sync the fs for
++ * us.
++ *
++ * AKPM2: if all the page's buffers are mapped to disk and !data=journal,
++ * we don't need to open a transaction here.
++ */
++static int ext3cow_ordered_writepage(struct page *page,
++ struct writeback_control *wbc)
++{
++ struct inode *inode = page->mapping->host;
++ struct buffer_head *page_bufs;
++ handle_t *handle = NULL;
++ int ret = 0;
++ int err;
++
++ J_ASSERT(PageLocked(page));
++
++ /*
++ * We give up here if we're reentered, because it might be for a
++ * different filesystem.
++ */
++ if (ext3cow_journal_current_handle())
++ goto out_fail;
++
++ handle = ext3cow_journal_start(inode, ext3cow_writepage_trans_blocks(inode));
++
++ if (IS_ERR(handle)) {
++ ret = PTR_ERR(handle);
++ goto out_fail;
++ }
++
++ if (!page_has_buffers(page)) {
++ create_empty_buffers(page, inode->i_sb->s_blocksize,
++ (1 << BH_Dirty)|(1 << BH_Uptodate));
++ }
++ page_bufs = page_buffers(page);
++ walk_page_buffers(handle, page_bufs, 0,
++ PAGE_CACHE_SIZE, NULL, bget_one);
++
++ ret = block_write_full_page(page, ext3cow_get_block, wbc);
++
++ /*
++ * The page can become unlocked at any point now, and
++ * truncate can then come in and change things. So we
++ * can't touch *page from now on. But *page_bufs is
++ * safe due to elevated refcount.
++ */
++
++ /*
++ * And attach them to the current transaction. But only if
++ * block_write_full_page() succeeded. Otherwise they are unmapped,
++ * and generally junk.
++ */
++ if (ret == 0) {
++ err = walk_page_buffers(handle, page_bufs, 0, PAGE_CACHE_SIZE,
++ NULL, journal_dirty_data_fn);
++ if (!ret)
++ ret = err;
++ }
++ walk_page_buffers(handle, page_bufs, 0,
++ PAGE_CACHE_SIZE, NULL, bput_one);
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++ return ret;
++
++out_fail:
++ redirty_page_for_writepage(wbc, page);
++ unlock_page(page);
++ return ret;
++}
++
++static int ext3cow_writeback_writepage(struct page *page,
++ struct writeback_control *wbc)
++{
++ struct inode *inode = page->mapping->host;
++ handle_t *handle = NULL;
++ int ret = 0;
++ int err;
++
++ if (ext3cow_journal_current_handle())
++ goto out_fail;
++
++ handle = ext3cow_journal_start(inode, ext3cow_writepage_trans_blocks(inode));
++ if (IS_ERR(handle)) {
++ ret = PTR_ERR(handle);
++ goto out_fail;
++ }
++
++ if (test_opt(inode->i_sb, NOBH) && ext3cow_should_writeback_data(inode))
++ ret = nobh_writepage(page, ext3cow_get_block, wbc);
++ else
++ ret = block_write_full_page(page, ext3cow_get_block, wbc);
++
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++ return ret;
++
++out_fail:
++ redirty_page_for_writepage(wbc, page);
++ unlock_page(page);
++ return ret;
++}
++
++static int ext3cow_journalled_writepage(struct page *page,
++ struct writeback_control *wbc)
++{
++ struct inode *inode = page->mapping->host;
++ handle_t *handle = NULL;
++ int ret = 0;
++ int err;
++
++ if (ext3cow_journal_current_handle())
++ goto no_write;
++
++ handle = ext3cow_journal_start(inode, ext3cow_writepage_trans_blocks(inode));
++ if (IS_ERR(handle)) {
++ ret = PTR_ERR(handle);
++ goto no_write;
++ }
++
++ if (!page_has_buffers(page) || PageChecked(page)) {
++ /*
++ * It's mmapped pagecache. Add buffers and journal it. There
++ * doesn't seem much point in redirtying the page here.
++ */
++ ClearPageChecked(page);
++ ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
++ ext3cow_get_block);
++ if (ret != 0) {
++ ext3cow_journal_stop(handle);
++ goto out_unlock;
++ }
++ ret = walk_page_buffers(handle, page_buffers(page), 0,
++ PAGE_CACHE_SIZE, NULL, do_journal_get_write_access);
++
++ err = walk_page_buffers(handle, page_buffers(page), 0,
++ PAGE_CACHE_SIZE, NULL, commit_write_fn);
++ if (ret == 0)
++ ret = err;
++ EXT3COW_I(inode)->i_state |= EXT3COW_STATE_JDATA;
++ unlock_page(page);
++ } else {
++ /*
++ * It may be a page full of checkpoint-mode buffers. We don't
++ * really know unless we go poke around in the buffer_heads.
++ * But block_write_full_page will do the right thing.
++ */
++ ret = block_write_full_page(page, ext3cow_get_block, wbc);
++ }
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++out:
++ return ret;
++
++no_write:
++ redirty_page_for_writepage(wbc, page);
++out_unlock:
++ unlock_page(page);
++ goto out;
++}
++
++static int ext3cow_readpage(struct file *file, struct page *page)
++{
++ return mpage_readpage(page, ext3cow_get_block);
++}
++
++static int
++ext3cow_readpages(struct file *file, struct address_space *mapping,
++ struct list_head *pages, unsigned nr_pages)
++{
++ return mpage_readpages(mapping, pages, nr_pages, ext3cow_get_block);
++}
++
++static void ext3cow_invalidatepage(struct page *page, unsigned long offset)
++{
++ journal_t *journal = EXT3COW_JOURNAL(page->mapping->host);
++
++ /*
++ * If it's a full truncate we just forget about the pending dirtying
++ */
++ if (offset == 0)
++ ClearPageChecked(page);
++
++ journal_invalidatepage(journal, page, offset);
++}
++
++static int ext3cow_releasepage(struct page *page, gfp_t wait)
++{
++ journal_t *journal = EXT3COW_JOURNAL(page->mapping->host);
++
++ WARN_ON(PageChecked(page));
++ if (!page_has_buffers(page))
++ return 0;
++ return journal_try_to_free_buffers(journal, page, wait);
++}
++
++/*
++ * If the O_DIRECT write will extend the file then add this inode to the
++ * orphan list. So recovery will truncate it back to the original size
++ * if the machine crashes during the write.
++ *
++ * If the O_DIRECT write is intantiating holes inside i_size and the machine
++ * crashes then stale disk data _may_ be exposed inside the file.
++ */
++static ssize_t ext3cow_direct_IO(int rw, struct kiocb *iocb,
++ const struct iovec *iov, loff_t offset,
++ unsigned long nr_segs)
++{
++ struct file *file = iocb->ki_filp;
++ struct inode *inode = file->f_mapping->host;
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ handle_t *handle = NULL;
++ ssize_t ret;
++ int orphan = 0;
++ size_t count = iov_length(iov, nr_segs);
++
++ if (rw == WRITE) {
++ loff_t final_size = offset + count;
++
++ handle = ext3cow_journal_start(inode, DIO_CREDITS);
++ if (IS_ERR(handle)) {
++ ret = PTR_ERR(handle);
++ goto out;
++ }
++ if (final_size > inode->i_size) {
++ ret = ext3cow_orphan_add(handle, inode);
++ if (ret)
++ goto out_stop;
++ orphan = 1;
++ ei->i_disksize = inode->i_size;
++ }
++ }
++
++ ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
++ offset, nr_segs,
++ ext3cow_get_block, NULL);
++
++ /*
++ * Reacquire the handle: ext3cow_get_block() can restart the transaction
++ */
++ handle = journal_current_handle();
++
++out_stop:
++ if (handle) {
++ int err;
++
++ if (orphan && inode->i_nlink)
++ ext3cow_orphan_del(handle, inode);
++ if (orphan && ret > 0) {
++ loff_t end = offset + ret;
++ if (end > inode->i_size) {
++ ei->i_disksize = end;
++ i_size_write(inode, end);
++ /*
++ * We're going to return a positive `ret'
++ * here due to non-zero-length I/O, so there's
++ * no way of reporting error returns from
++ * ext3cow_mark_inode_dirty() to userspace. So
++ * ignore it.
++ */
++ ext3cow_mark_inode_dirty(handle, inode);
++ }
++ }
++ err = ext3cow_journal_stop(handle);
++ if (ret == 0)
++ ret = err;
++ }
++out:
++ return ret;
++}
++
++/*
++ * Pages can be marked dirty completely asynchronously from ext3cow's journalling
++ * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
++ * much here because ->set_page_dirty is called under VFS locks. The page is
++ * not necessarily locked.
++ *
++ * We cannot just dirty the page and leave attached buffers clean, because the
++ * buffers' dirty state is "definitive". We cannot just set the buffers dirty
++ * or jbddirty because all the journalling code will explode.
++ *
++ * So what we do is to mark the page "pending dirty" and next time writepage
++ * is called, propagate that into the buffers appropriately.
++ */
++static int ext3cow_journalled_set_page_dirty(struct page *page)
++{
++ SetPageChecked(page);
++ return __set_page_dirty_nobuffers(page);
++}
++
++static const struct address_space_operations ext3cow_ordered_aops = {
++ .readpage = ext3cow_readpage,
++ .readpages = ext3cow_readpages,
++ .writepage = ext3cow_ordered_writepage,
++ .sync_page = block_sync_page,
++ .prepare_write = ext3cow_prepare_write,
++ .commit_write = ext3cow_ordered_commit_write,
++ .bmap = ext3cow_bmap,
++ .invalidatepage = ext3cow_invalidatepage,
++ .releasepage = ext3cow_releasepage,
++ .direct_IO = ext3cow_direct_IO,
++ .migratepage = buffer_migrate_page,
++};
++
++static const struct address_space_operations ext3cow_writeback_aops = {
++ .readpage = ext3cow_readpage,
++ .readpages = ext3cow_readpages,
++ .writepage = ext3cow_writeback_writepage,
++ .sync_page = block_sync_page,
++ .prepare_write = ext3cow_prepare_write,
++ .commit_write = ext3cow_writeback_commit_write,
++ .bmap = ext3cow_bmap,
++ .invalidatepage = ext3cow_invalidatepage,
++ .releasepage = ext3cow_releasepage,
++ .direct_IO = ext3cow_direct_IO,
++ .migratepage = buffer_migrate_page,
++};
++
++static const struct address_space_operations ext3cow_journalled_aops = {
++ .readpage = ext3cow_readpage,
++ .readpages = ext3cow_readpages,
++ .writepage = ext3cow_journalled_writepage,
++ .sync_page = block_sync_page,
++ .prepare_write = ext3cow_prepare_write,
++ .commit_write = ext3cow_journalled_commit_write,
++ .set_page_dirty = ext3cow_journalled_set_page_dirty,
++ .bmap = ext3cow_bmap,
++ .invalidatepage = ext3cow_invalidatepage,
++ .releasepage = ext3cow_releasepage,
++};
++
++void ext3cow_set_aops(struct inode *inode)
++{
++ if (ext3cow_should_order_data(inode))
++ inode->i_mapping->a_ops = &ext3cow_ordered_aops;
++ else if (ext3cow_should_writeback_data(inode))
++ inode->i_mapping->a_ops = &ext3cow_writeback_aops;
++ else
++ inode->i_mapping->a_ops = &ext3cow_journalled_aops;
++}
++
++/*
++ * ext3cow_block_truncate_page() zeroes out a mapping from file offset `from'
++ * up to the end of the block which corresponds to `from'.
++ * This required during truncate. We need to physically zero the tail end
++ * of that block so it doesn't yield old data if the file is later grown.
++ */
++static int ext3cow_block_truncate_page(handle_t *handle, struct page *page,
++ struct address_space *mapping, loff_t from)
++{
++ ext3cow_fsblk_t index = from >> PAGE_CACHE_SHIFT;
++ unsigned offset = from & (PAGE_CACHE_SIZE-1);
++ unsigned blocksize, iblock, length, pos;
++ struct inode *inode = mapping->host;
++ struct buffer_head *bh;
++ int err = 0;
++ void *kaddr;
++
++ blocksize = inode->i_sb->s_blocksize;
++ length = blocksize - (offset & (blocksize - 1));
++ iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
++
++ /*
++ * For "nobh" option, we can only work if we don't need to
++ * read-in the page - otherwise we create buffers to do the IO.
++ */
++ if (!page_has_buffers(page) && test_opt(inode->i_sb, NOBH) &&
++ ext3cow_should_writeback_data(inode) && PageUptodate(page)) {
++ kaddr = kmap_atomic(page, KM_USER0);
++ memset(kaddr + offset, 0, length);
++ flush_dcache_page(page);
++ kunmap_atomic(kaddr, KM_USER0);
++ set_page_dirty(page);
++ goto unlock;
++ }
++
++ if (!page_has_buffers(page))
++ create_empty_buffers(page, blocksize, 0);
++
++ /* Find the buffer that contains "offset" */
++ bh = page_buffers(page);
++ pos = blocksize;
++ while (offset >= pos) {
++ bh = bh->b_this_page;
++ iblock++;
++ pos += blocksize;
++ }
++
++ err = 0;
++ if (buffer_freed(bh)) {
++ BUFFER_TRACE(bh, "freed: skip");
++ goto unlock;
++ }
++
++ if (!buffer_mapped(bh)) {
++ BUFFER_TRACE(bh, "unmapped");
++ ext3cow_get_block(inode, iblock, bh, 0);
++ /* unmapped? It's a hole - nothing to do */
++ if (!buffer_mapped(bh)) {
++ BUFFER_TRACE(bh, "still unmapped");
++ goto unlock;
++ }
++ }
++
++ /* Ok, it's mapped. Make sure it's up-to-date */
++ if (PageUptodate(page))
++ set_buffer_uptodate(bh);
++
++ if (!buffer_uptodate(bh)) {
++ err = -EIO;
++ ll_rw_block(READ, 1, &bh);
++ wait_on_buffer(bh);
++ /* Uhhuh. Read error. Complain and punt. */
++ if (!buffer_uptodate(bh))
++ goto unlock;
++ }
++
++ if (ext3cow_should_journal_data(inode)) {
++ BUFFER_TRACE(bh, "get write access");
++ err = ext3cow_journal_get_write_access(handle, bh);
++ if (err)
++ goto unlock;
++ }
++
++ kaddr = kmap_atomic(page, KM_USER0);
++ memset(kaddr + offset, 0, length);
++ flush_dcache_page(page);
++ kunmap_atomic(kaddr, KM_USER0);
++
++ BUFFER_TRACE(bh, "zeroed end of block");
++
++ err = 0;
++ if (ext3cow_should_journal_data(inode)) {
++ err = ext3cow_journal_dirty_metadata(handle, bh);
++ } else {
++ if (ext3cow_should_order_data(inode))
++ err = ext3cow_journal_dirty_data(handle, bh);
++ mark_buffer_dirty(bh);
++ }
++
++unlock:
++ unlock_page(page);
++ page_cache_release(page);
++ return err;
++}
++
++/*
++ * Probably it should be a library function... search for first non-zero word
++ * or memcmp with zero_page, whatever is better for particular architecture.
++ * Linus?
++ */
++static inline int all_zeroes(__le32 *p, __le32 *q)
++{
++ while (p < q)
++ if (*p++)
++ return 0;
++ return 1;
++}
++
++/**
++ * ext3cow_find_shared - find the indirect blocks for partial truncation.
++ * @inode: inode in question
++ * @depth: depth of the affected branch
++ * @offsets: offsets of pointers in that branch (see ext3cow_block_to_path)
++ * @chain: place to store the pointers to partial indirect blocks
++ * @top: place to the (detached) top of branch
++ *
++ * This is a helper function used by ext3cow_truncate().
++ *
++ * When we do truncate() we may have to clean the ends of several
++ * indirect blocks but leave the blocks themselves alive. Block is
++ * partially truncated if some data below the new i_size is refered
++ * from it (and it is on the path to the first completely truncated
++ * data block, indeed). We have to free the top of that path along
++ * with everything to the right of the path. Since no allocation
++ * past the truncation point is possible until ext3cow_truncate()
++ * finishes, we may safely do the latter, but top of branch may
++ * require special attention - pageout below the truncation point
++ * might try to populate it.
++ *
++ * We atomically detach the top of branch from the tree, store the
++ * block number of its root in *@top, pointers to buffer_heads of
++ * partially truncated blocks - in @chain[].bh and pointers to
++ * their last elements that should not be removed - in
++ * @chain[].p. Return value is the pointer to last filled element
++ * of @chain.
++ *
++ * The work left to caller to do the actual freeing of subtrees:
++ * a) free the subtree starting from *@top
++ * b) free the subtrees whose roots are stored in
++ * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
++ * c) free the subtrees growing from the inode past the @chain[0].
++ * (no partially truncated stuff there). */
++
++static Indirect *ext3cow_find_shared(struct inode *inode, int depth,
++ int offsets[4], Indirect chain[4], __le32 *top)
++{
++ Indirect *partial, *p;
++ int k, err, cow;
++
++ *top = 0;
++ /* Make k index the deepest non-null offest + 1 */
++ for (k = depth; k > 1 && !offsets[k-1]; k--)
++ ;
++ partial = ext3cow_get_branch(inode, k, offsets, chain, &err, &cow, 0);
++ /* Writer: pointers */
++ if (!partial)
++ partial = chain + k-1;
++ /*
++ * If the branch acquired continuation since we've looked at it -
++ * fine, it should all survive and (new) top doesn't belong to us.
++ */
++ if (!partial->key && *partial->p)
++ /* Writer: end */
++ goto no_top;
++ for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
++ ;
++ /*
++ * OK, we've found the last block that must survive. The rest of our
++ * branch should be detached before unlocking. However, if that rest
++ * of branch is all ours and does not grow immediately from the inode
++ * it's easier to cheat and just decrement partial->p.
++ */
++ if (p == chain + k - 1 && p > chain) {
++ p->p--;
++ } else {
++ *top = *p->p;
++ /* Nope, don't do this in ext3cow. Must leave the tree intact */
++#if 0
++ *p->p = 0;
++#endif
++ }
++ /* Writer: end */
++
++ while(partial > p) {
++ brelse(partial->bh);
++ partial--;
++ }
++no_top:
++ return partial;
++}
++
++/*
++ * Zero a number of block pointers in either an inode or an indirect block.
++ * If we restart the transaction we must again get write access to the
++ * indirect block for further modification.
++ *
++ * We release `count' blocks on disk, but (last - first) may be greater
++ * than `count' because there can be holes in there.
++ */
++static void ext3cow_clear_blocks(handle_t *handle, struct inode *inode,
++ struct buffer_head *bh, ext3cow_fsblk_t block_to_free,
++ unsigned long count, __le32 *first, __le32 *last)
++{
++ __le32 *p;
++ if (try_to_extend_transaction(handle, inode)) {
++ if (bh) {
++ BUFFER_TRACE(bh, "call ext3cow_journal_dirty_metadata");
++ ext3cow_journal_dirty_metadata(handle, bh);
++ }
++ ext3cow_mark_inode_dirty(handle, inode);
++ ext3cow_journal_test_restart(handle, inode);
++ if (bh) {
++ BUFFER_TRACE(bh, "retaking write access");
++ ext3cow_journal_get_write_access(handle, bh);
++ }
++ }
++
++ /*
++ * Any buffers which are on the journal will be in memory. We find
++ * them on the hash table so journal_revoke() will run journal_forget()
++ * on them. We've already detached each block from the file, so
++ * bforget() in journal_forget() should be safe.
++ *
++ * AKPM: turn on bforget in journal_forget()!!!
++ */
++ for (p = first; p < last; p++) {
++ u32 nr = le32_to_cpu(*p);
++ if (nr) {
++ struct buffer_head *bh;
++
++ *p = 0;
++ bh = sb_find_get_block(inode->i_sb, nr);
++ ext3cow_forget(handle, 0, inode, bh, nr);
++ }
++ }
++
++ ext3cow_free_blocks(handle, inode, block_to_free, count);
++}
++
++/**
++ * ext3cow_free_data - free a list of data blocks
++ * @handle: handle for this transaction
++ * @inode: inode we are dealing with
++ * @this_bh: indirect buffer_head which contains *@first and *@last
++ * @first: array of block numbers
++ * @last: points immediately past the end of array
++ *
++ * We are freeing all blocks refered from that array (numbers are stored as
++ * little-endian 32-bit) and updating @inode->i_blocks appropriately.
++ *
++ * We accumulate contiguous runs of blocks to free. Conveniently, if these
++ * blocks are contiguous then releasing them at one time will only affect one
++ * or two bitmap blocks (+ group descriptor(s) and superblock) and we won't
++ * actually use a lot of journal space.
++ *
++ * @this_bh will be %NULL if @first and @last point into the inode's direct
++ * block pointers.
++ */
++static void ext3cow_free_data(handle_t *handle, struct inode *inode,
++ struct buffer_head *this_bh,
++ __le32 *first, __le32 *last)
++{
++ ext3cow_fsblk_t block_to_free = 0; /* Starting block # of a run */
++ unsigned long count = 0; /* Number of blocks in the run */
++ __le32 *block_to_free_p = NULL; /* Pointer into inode/ind
++ corresponding to
++ block_to_free */
++ ext3cow_fsblk_t nr; /* Current block # */
++ __le32 *p; /* Pointer into inode/ind
++ for current block */
++ int err;
++
++ if (this_bh) { /* For indirect block */
++ BUFFER_TRACE(this_bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, this_bh);
++ /* Important: if we can't update the indirect pointers
++ * to the blocks, we can't free them. */
++ if (err)
++ return;
++ }
++
++ for (p = first; p < last; p++) {
++ nr = le32_to_cpu(*p);
++ if (nr) {
++ /* accumulate blocks to free if they're contiguous */
++ if (count == 0) {
++ block_to_free = nr;
++ block_to_free_p = p;
++ count = 1;
++ } else if (nr == block_to_free + count) {
++ count++;
++ } else {
++ ext3cow_clear_blocks(handle, inode, this_bh,
++ block_to_free,
++ count, block_to_free_p, p);
++ block_to_free = nr;
++ block_to_free_p = p;
++ count = 1;
++ }
++ }
++ }
++
++ if (count > 0)
++ ext3cow_clear_blocks(handle, inode, this_bh, block_to_free,
++ count, block_to_free_p, p);
++
++ if (this_bh) {
++ BUFFER_TRACE(this_bh, "call ext3cow_journal_dirty_metadata");
++ ext3cow_journal_dirty_metadata(handle, this_bh);
++ }
++}
++
++/**
++ * ext3cow_free_branches - free an array of branches
++ * @handle: JBD handle for this transaction
++ * @inode: inode we are dealing with
++ * @parent_bh: the buffer_head which contains *@first and *@last
++ * @first: array of block numbers
++ * @last: pointer immediately past the end of array
++ * @depth: depth of the branches to free
++ *
++ * We are freeing all blocks refered from these branches (numbers are
++ * stored as little-endian 32-bit) and updating @inode->i_blocks
++ * appropriately.
++ */
++static void ext3cow_free_branches(handle_t *handle, struct inode *inode,
++ struct buffer_head *parent_bh,
++ __le32 *first, __le32 *last, int depth)
++{
++ ext3cow_fsblk_t nr;
++ __le32 *p;
++
++ if (is_handle_aborted(handle))
++ return;
++
++ if (depth--) {
++ struct buffer_head *bh;
++ int addr_per_block = EXT3COW_ADDR_PER_BLOCK(inode->i_sb);
++ u32 *bitmap_word = NULL, *first_block = NULL;
++ unsigned int count = 0, cur = 0, bcount = 0;
++ int i = 0;
++ p = last;
++ while (--p >= first) {
++ nr = le32_to_cpu(*p);
++ if (!nr)
++ continue; /* A hole */
++
++ /* Go read the buffer for the next level down */
++ bh = sb_bread(inode->i_sb, nr);
++
++ /*
++ * A read failure? Report error and clear slot
++ * (should be rare).
++ */
++ if (!bh) {
++ ext3cow_error(inode->i_sb, "ext3cow_free_branches",
++ "Read failure, inode=%lu, block="E3FSBLK,
++ inode->i_ino, nr);
++ continue;
++ }
++ /* Only free the branches that have been newly allocated - znjp */
++ cur = 0;
++ count = 0;
++ bitmap_word = (u32*)bh->b_data + addr_per_block;
++
++ for(bcount = 0; bcount < EXT3COW_COWBITMAPS_PER_IBLOCK(inode->i_sb);
++ bcount++){
++ for(i = 0; i < EXT3COW_COWBITMAP_SIZE; i++, cur++){
++ if(cur >= addr_per_block)
++ goto free;
++ if(le32_to_cpu(*bitmap_word) & (1UL << i)){
++ if(count == 0){
++ first_block = (u32*)bh->b_data + cur;
++ count = 1;
++ }else if((u32*)first_block + count == (u32*)bh->b_data + cur){
++ count++;
++ }else{
++ BUFFER_TRACE(bh, "free child branches");
++ ext3cow_free_branches(handle, inode, bh, (u32*)first_block,
++ (u32*)first_block + count, depth);
++ first_block = (u32*)bh->b_data + cur;
++ count = 1;
++ }
++ }
++ }
++ (u32*)bitmap_word++;
++ }
++ free:
++ if(count){
++ BUFFER_TRACE(bh, "free child branches");
++ ext3cow_free_branches(handle, inode, bh, (u32*)first_block,
++ (u32*)first_block + count, depth);
++ }
++
++ /*
++ * We've probably journalled the indirect block several
++ * times during the truncate. But it's no longer
++ * needed and we now drop it from the transaction via
++ * journal_revoke().
++ *
++ * That's easy if it's exclusively part of this
++ * transaction. But if it's part of the committing
++ * transaction then journal_forget() will simply
++ * brelse() it. That means that if the underlying
++ * block is reallocated in ext3cow_get_block(),
++ * unmap_underlying_metadata() will find this block
++ * and will try to get rid of it. damn, damn.
++ *
++ * If this block has already been committed to the
++ * journal, a revoke record will be written. And
++ * revoke records must be emitted *before* clearing
++ * this block's bit in the bitmaps.
++ */
++ ext3cow_forget(handle, 1, inode, bh, bh->b_blocknr);
++
++ /*
++ * Everything below this this pointer has been
++ * released. Now let this top-of-subtree go.
++ *
++ * We want the freeing of this indirect block to be
++ * atomic in the journal with the updating of the
++ * bitmap block which owns it. So make some room in
++ * the journal.
++ *
++ * We zero the parent pointer *after* freeing its
++ * pointee in the bitmaps, so if extend_transaction()
++ * for some reason fails to put the bitmap changes and
++ * the release into the same transaction, recovery
++ * will merely complain about releasing a free block,
++ * rather than leaking blocks.
++ */
++ if (is_handle_aborted(handle))
++ return;
++ if (try_to_extend_transaction(handle, inode)) {
++ ext3cow_mark_inode_dirty(handle, inode);
++ ext3cow_journal_test_restart(handle, inode);
++ }
++
++ ext3cow_free_blocks(handle, inode, nr, 1);
++
++ if (parent_bh) {
++ /*
++ * The block which we have just freed is
++ * pointed to by an indirect block: journal it
++ */
++ BUFFER_TRACE(parent_bh, "get_write_access");
++ if (!ext3cow_journal_get_write_access(handle,
++ parent_bh)){
++ *p = 0;
++ BUFFER_TRACE(parent_bh,
++ "call ext3cow_journal_dirty_metadata");
++ ext3cow_journal_dirty_metadata(handle,
++ parent_bh);
++ }
++ }
++ }
++ } else {
++ /* We have reached the bottom of the tree. */
++ BUFFER_TRACE(parent_bh, "free data blocks");
++ ext3cow_free_data(handle, inode, parent_bh, first, last);
++ }
++}
++
++/*
++ * ext3cow_truncate()
++ *
++ * We block out ext3cow_get_block() block instantiations across the entire
++ * transaction, and VFS/VM ensures that ext3cow_truncate() cannot run
++ * simultaneously on behalf of the same inode.
++ *
++ * As we work through the truncate and commmit bits of it to the journal there
++ * is one core, guiding principle: the file's tree must always be consistent on
++ * disk. We must be able to restart the truncate after a crash.
++ *
++ * The file's tree may be transiently inconsistent in memory (although it
++ * probably isn't), but whenever we close off and commit a journal transaction,
++ * the contents of (the filesystem + the journal) must be consistent and
++ * restartable. It's pretty simple, really: bottom up, right to left (although
++ * left-to-right works OK too).
++ *
++ * Note that at recovery time, journal replay occurs *before* the restart of
++ * truncate against the orphan inode list.
++ *
++ * The committed inode has the new, desired i_size (which is the same as
++ * i_disksize in this case). After a crash, ext3cow_orphan_cleanup() will see
++ * that this inode's truncate did not complete and it will again call
++ * ext3cow_truncate() to have another go. So there will be instantiated blocks
++ * to the right of the truncation point in a crashed ext3cow filesystem. But
++ * that's fine - as long as they are linked from the inode, the post-crash
++ * ext3cow_truncate() run will find them and release them.
++ */
++void ext3cow_truncate(struct inode *inode)
++{
++ handle_t *handle;
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ __le32 *i_data = ei->i_data;
++ int addr_per_block = EXT3COW_ADDR_PER_BLOCK(inode->i_sb);
++ struct address_space *mapping = inode->i_mapping;
++ int offsets[4];
++ Indirect chain[4];
++ Indirect *partial;
++ __le32 nr = 0;
++ int n;
++ long last_block;
++ unsigned blocksize = inode->i_sb->s_blocksize;
++ struct page *page;
++
++
++ if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
++ S_ISLNK(inode->i_mode)))
++ return;
++ if (ext3cow_inode_is_fast_symlink(inode))
++ return;
++ if (IS_APPEND(inode) || IS_IMMUTABLE(inode) ||
++ EXT3COW_IS_UNCHANGEABLE(inode)) /* znjp */
++ return;
++
++ /* If the inode needs to be dup'd, then there are no blocks
++ * to truncate; they all are part of the previous version.
++ * - znjp */
++ if(EXT3COW_S_EPOCHNUMBER(inode->i_sb) > EXT3COW_I_EPOCHNUMBER(inode)){
++ ext3cow_dup_inode(NULL, inode);
++ return;
++ }
++
++ /*
++ * We have to lock the EOF page here, because lock_page() nests
++ * outside journal_start().
++ */
++ if ((inode->i_size & (blocksize - 1)) == 0) {
++ /* Block boundary? Nothing to do */
++ page = NULL;
++ } else {
++ page = grab_cache_page(mapping,
++ inode->i_size >> PAGE_CACHE_SHIFT);
++ if (!page)
++ return;
++ }
++
++ handle = start_transaction(inode);
++ if (IS_ERR(handle)) {
++ if (page) {
++ clear_highpage(page);
++ flush_dcache_page(page);
++ unlock_page(page);
++ page_cache_release(page);
++ }
++ return; /* AKPM: return what? */
++ }
++
++ last_block = (inode->i_size + blocksize-1)
++ >> EXT3COW_BLOCK_SIZE_BITS(inode->i_sb);
++
++ if (page)
++ ext3cow_block_truncate_page(handle, page, mapping, inode->i_size);
++
++ n = ext3cow_block_to_path(inode, last_block, offsets, NULL);
++ if (n == 0)
++ goto out_stop; /* error */
++
++ /*
++ * OK. This truncate is going to happen. We add the inode to the
++ * orphan list, so that if this truncate spans multiple transactions,
++ * and we crash, we will resume the truncate when the filesystem
++ * recovers. It also marks the inode dirty, to catch the new size.
++ *
++ * Implication: the file must always be in a sane, consistent
++ * truncatable state while each transaction commits.
++ */
++ if (ext3cow_orphan_add(handle, inode))
++ goto out_stop;
++
++ /*
++ * The orphan list entry will now protect us from any crash which
++ * occurs before the truncate completes, so it is now safe to propagate
++ * the new, shorter inode size (held for now in i_size) into the
++ * on-disk inode. We do this via i_disksize, which is the value which
++ * ext3cow *really* writes onto the disk inode.
++ */
++ ei->i_disksize = inode->i_size;
++
++ /*
++ * From here we block out all ext3cow_get_block() callers who want to
++ * modify the block allocation tree.
++ */
++ mutex_lock(&ei->truncate_mutex);
++
++ if (n == 1) { /* direct blocks */
++ unsigned int count = 0;
++ unsigned long block_to_free = 0;
++ unsigned long b = 0;
++
++ /* We only want to remove blocks that were allocated in this
++ * epoch, i.e., have 1 bit in the bitmap. -znjp */
++ for(b = offsets[0]; b < EXT3COW_NDIR_BLOCKS; b++){
++ if(EXT3COW_I(inode)->i_cow_bitmap & (1UL << b)){
++ if(count == 0){
++ block_to_free = b;
++ count = 1;
++ }else if(b == block_to_free + count){
++ count++;
++ }else{
++ ext3cow_free_data(handle, inode, NULL, i_data + (int)block_to_free,
++ i_data + (int)(block_to_free + count));
++ block_to_free = b;
++ count = 1;
++ }
++ }
++ }
++ if(count > 0)
++ ext3cow_free_data(handle, inode, NULL, i_data+(int)block_to_free,
++ i_data + (int)(block_to_free + count));
++ goto do_indirects;
++ }
++
++ partial = ext3cow_find_shared(inode, n, offsets, chain, &nr);
++ /* Kill the top of shared branch (not detached) */
++ if (nr) {
++ if (partial == chain) {
++ /* Shared branch grows from the inode */
++ ext3cow_free_branches(handle, inode, NULL,
++ &nr, &nr+1, (chain+n-1) - partial);
++ *partial->p = 0;
++ /*
++ * We mark the inode dirty prior to restart,
++ * and prior to stop. No need for it here.
++ */
++ } else {
++ /* Shared branch grows from an indirect block */
++ BUFFER_TRACE(partial->bh, "get_write_access");
++ ext3cow_free_branches(handle, inode, partial->bh,
++ partial->p,
++ partial->p+1, (chain+n-1) - partial);
++ }
++ }
++ /* Clear the ends of indirect blocks on the shared branch */
++ while (partial > chain) {
++ ext3cow_free_branches(handle, inode, partial->bh, partial->p + 1,
++ (__le32*)partial->bh->b_data+addr_per_block,
++ (chain+n-1) - partial);
++ BUFFER_TRACE(partial->bh, "call brelse");
++ brelse (partial->bh);
++ partial--;
++ }
++do_indirects:
++ /* Kill the remaining (whole) subtrees */
++ /* Unless we don't have to. If the indirect block has a 0 bit
++ * then all of the children do too, so we can skip the branch - znjp
++ */
++ switch (offsets[0]) {
++ default:
++ if(EXT3COW_I(inode)->i_cow_bitmap & (1UL << EXT3COW_IND_BLOCK)){
++ nr = i_data[EXT3COW_IND_BLOCK];
++ if (nr) {
++ ext3cow_free_branches(handle, inode, NULL, &nr, &nr+1, 1);
++ i_data[EXT3COW_IND_BLOCK] = 0;
++ }
++ }
++ case EXT3COW_IND_BLOCK:
++ if(EXT3COW_I(inode)->i_cow_bitmap & (1UL << EXT3COW_DIND_BLOCK)){
++ nr = i_data[EXT3COW_DIND_BLOCK];
++ if (nr) {
++ ext3cow_free_branches(handle, inode, NULL, &nr, &nr+1, 2);
++ i_data[EXT3COW_DIND_BLOCK] = 0;
++ }
++ }
++ case EXT3COW_DIND_BLOCK:
++ if(EXT3COW_I(inode)->i_cow_bitmap & (1UL << EXT3COW_TIND_BLOCK)){
++ nr = i_data[EXT3COW_TIND_BLOCK];
++ if (nr) {
++ ext3cow_free_branches(handle, inode, NULL, &nr, &nr+1, 3);
++ i_data[EXT3COW_TIND_BLOCK] = 0;
++ }
++ }
++ case EXT3COW_TIND_BLOCK:
++ ;
++ }
++
++ ext3cow_discard_reservation(inode);
++
++ mutex_unlock(&ei->truncate_mutex);
++ inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
++ ext3cow_mark_inode_dirty(handle, inode);
++
++ /*
++ * In a multi-transaction truncate, we only make the final transaction
++ * synchronous
++ */
++ if (IS_SYNC(inode))
++ handle->h_sync = 1;
++out_stop:
++ /*
++ * If this was a simple ftruncate(), and the file will remain alive
++ * then we need to clear up the orphan record which we created above.
++ * However, if this was a real unlink then we were called by
++ * ext3cow_delete_inode(), and we allow that function to clean up the
++ * orphan info for us.
++ */
++ if (inode->i_nlink)
++ ext3cow_orphan_del(handle, inode);
++
++ ext3cow_journal_stop(handle);
++}
++
++static ext3cow_fsblk_t ext3cow_get_inode_block(struct super_block *sb,
++ unsigned long ino, struct ext3cow_iloc *iloc)
++{
++ unsigned long desc, group_desc, block_group;
++ unsigned long offset;
++ ext3cow_fsblk_t block;
++ struct buffer_head *bh;
++ struct ext3cow_group_desc * gdp;
++
++ if (!ext3cow_valid_inum(sb, ino)) {
++ /*
++ * This error is already checked for in namei.c unless we are
++ * looking at an NFS filehandle, in which case no error
++ * report is needed
++ */
++ return 0;
++ }
++
++ block_group = (ino - 1) / EXT3COW_INODES_PER_GROUP(sb);
++ if (block_group >= EXT3COW_SB(sb)->s_groups_count) {
++ ext3cow_error(sb,"ext3cow_get_inode_block","group >= groups count");
++ return 0;
++ }
++ smp_rmb();
++ group_desc = block_group >> EXT3COW_DESC_PER_BLOCK_BITS(sb);
++ desc = block_group & (EXT3COW_DESC_PER_BLOCK(sb) - 1);
++ bh = EXT3COW_SB(sb)->s_group_desc[group_desc];
++ if (!bh) {
++ ext3cow_error (sb, "ext3cow_get_inode_block",
++ "Descriptor not loaded");
++ return 0;
++ }
++
++ gdp = (struct ext3cow_group_desc *)bh->b_data;
++ /*
++ * Figure out the offset within the block group inode table
++ */
++ offset = ((ino - 1) % EXT3COW_INODES_PER_GROUP(sb)) *
++ EXT3COW_INODE_SIZE(sb);
++ block = le32_to_cpu(gdp[desc].bg_inode_table) +
++ (offset >> EXT3COW_BLOCK_SIZE_BITS(sb));
++
++ iloc->block_group = block_group;
++ iloc->offset = offset & (EXT3COW_BLOCK_SIZE(sb) - 1);
++ return block;
++}
++
++/*
++ * ext3cow_get_inode_loc returns with an extra refcount against the inode's
++ * underlying buffer_head on success. If 'in_mem' is true, we have all
++ * data in memory that is needed to recreate the on-disk version of this
++ * inode.
++ */
++static int __ext3cow_get_inode_loc(struct inode *inode,
++ struct ext3cow_iloc *iloc, int in_mem)
++{
++ ext3cow_fsblk_t block;
++ struct buffer_head *bh;
++
++ block = ext3cow_get_inode_block(inode->i_sb, inode->i_ino, iloc);
++ if (!block)
++ return -EIO;
++
++ bh = sb_getblk(inode->i_sb, block);
++ if (!bh) {
++ ext3cow_error (inode->i_sb, "ext3cow_get_inode_loc",
++ "unable to read inode block - "
++ "inode=%lu, block="E3FSBLK,
++ inode->i_ino, block);
++ return -EIO;
++ }
++ if (!buffer_uptodate(bh)) {
++ lock_buffer(bh);
++ if (buffer_uptodate(bh)) {
++ /* someone brought it uptodate while we waited */
++ unlock_buffer(bh);
++ goto has_buffer;
++ }
++
++ /*
++ * If we have all information of the inode in memory and this
++ * is the only valid inode in the block, we need not read the
++ * block.
++ */
++ if (in_mem) {
++ struct buffer_head *bitmap_bh;
++ struct ext3cow_group_desc *desc;
++ int inodes_per_buffer;
++ int inode_offset, i;
++ int block_group;
++ int start;
++
++ block_group = (inode->i_ino - 1) /
++ EXT3COW_INODES_PER_GROUP(inode->i_sb);
++ inodes_per_buffer = bh->b_size /
++ EXT3COW_INODE_SIZE(inode->i_sb);
++ inode_offset = ((inode->i_ino - 1) %
++ EXT3COW_INODES_PER_GROUP(inode->i_sb));
++ start = inode_offset & ~(inodes_per_buffer - 1);
++
++ /* Is the inode bitmap in cache? */
++ desc = ext3cow_get_group_desc(inode->i_sb,
++ block_group, NULL);
++ if (!desc)
++ goto make_io;
++
++ bitmap_bh = sb_getblk(inode->i_sb,
++ le32_to_cpu(desc->bg_inode_bitmap));
++ if (!bitmap_bh)
++ goto make_io;
++
++ /*
++ * If the inode bitmap isn't in cache then the
++ * optimisation may end up performing two reads instead
++ * of one, so skip it.
++ */
++ if (!buffer_uptodate(bitmap_bh)) {
++ brelse(bitmap_bh);
++ goto make_io;
++ }
++ for (i = start; i < start + inodes_per_buffer; i++) {
++ if (i == inode_offset)
++ continue;
++ if (ext3cow_test_bit(i, bitmap_bh->b_data))
++ break;
++ }
++ brelse(bitmap_bh);
++ if (i == start + inodes_per_buffer) {
++ /* all other inodes are free, so skip I/O */
++ memset(bh->b_data, 0, bh->b_size);
++ set_buffer_uptodate(bh);
++ unlock_buffer(bh);
++ goto has_buffer;
++ }
++ }
++
++make_io:
++ /*
++ * There are other valid inodes in the buffer, this inode
++ * has in-inode xattrs, or we don't have this inode in memory.
++ * Read the block from disk.
++ */
++ get_bh(bh);
++ bh->b_end_io = end_buffer_read_sync;
++ submit_bh(READ_META, bh);
++ wait_on_buffer(bh);
++ if (!buffer_uptodate(bh)) {
++ ext3cow_error(inode->i_sb, "ext3cow_get_inode_loc",
++ "unable to read inode block - "
++ "inode=%lu, block="E3FSBLK,
++ inode->i_ino, block);
++ brelse(bh);
++ return -EIO;
++ }
++ }
++has_buffer:
++ iloc->bh = bh;
++ return 0;
++}
++
++int ext3cow_get_inode_loc(struct inode *inode, struct ext3cow_iloc *iloc)
++{
++ /* We have all inode data except xattrs in memory here. */
++ return __ext3cow_get_inode_loc(inode, iloc,
++ !(EXT3COW_I(inode)->i_state & EXT3COW_STATE_XATTR));
++}
++
++void ext3cow_set_inode_flags(struct inode *inode)
++{
++ unsigned int flags = EXT3COW_I(inode)->i_flags;
++
++ inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
++ if (flags & EXT3COW_SYNC_FL)
++ inode->i_flags |= S_SYNC;
++ if (flags & EXT3COW_APPEND_FL)
++ inode->i_flags |= S_APPEND;
++ if (flags & EXT3COW_IMMUTABLE_FL)
++ inode->i_flags |= S_IMMUTABLE;
++ if (flags & EXT3COW_NOATIME_FL)
++ inode->i_flags |= S_NOATIME;
++ if (flags & EXT3COW_DIRSYNC_FL)
++ inode->i_flags |= S_DIRSYNC;
++}
++
++void ext3cow_read_inode(struct inode * inode)
++{
++ struct ext3cow_iloc iloc;
++ struct ext3cow_inode *raw_inode;
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ struct buffer_head *bh;
++ int block;
++
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++ ei->i_acl = EXT3COW_ACL_NOT_CACHED;
++ ei->i_default_acl = EXT3COW_ACL_NOT_CACHED;
++#endif
++ ei->i_block_alloc_info = NULL;
++
++ if (__ext3cow_get_inode_loc(inode, &iloc, 0))
++ goto bad_inode;
++ bh = iloc.bh;
++ raw_inode = ext3cow_raw_inode(&iloc);
++ inode->i_mode = le16_to_cpu(raw_inode->i_mode);
++ inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
++ inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
++ /* Taken out for versioning -znjp
++ if(!(test_opt (inode->i_sb, NO_UID32))) {
++ inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
++ inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
++ }
++ */
++ inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
++ inode->i_size = le32_to_cpu(raw_inode->i_size);
++ inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
++ inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
++ inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
++ inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
++
++ ei->i_state = 0;
++ ei->i_dir_start_lookup = 0;
++ ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
++ /* We now have enough fields to check if the inode was active or not.
++ * This is needed because nfsd might try to access dead inodes
++ * the test is that same one that e2fsck uses
++ * NeilBrown 1999oct15
++ */
++ if (inode->i_nlink == 0) {
++ if (inode->i_mode == 0 ||
++ !(EXT3COW_SB(inode->i_sb)->s_mount_state & EXT3COW_ORPHAN_FS)) {
++ /* this inode is deleted */
++ brelse (bh);
++ goto bad_inode;
++ }
++ /* The only unlinked inodes we let through here have
++ * valid i_mode and are being read by the orphan
++ * recovery code: that's fine, we're about to complete
++ * the process of deleting those. */
++ }
++ inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
++ ei->i_flags = le32_to_cpu(raw_inode->i_flags);
++ /* For versioning -znjp */
++ ei->i_cow_bitmap = le32_to_cpu(raw_inode->i_cowbitmap);
++ ei->i_epoch_number = le32_to_cpu(raw_inode->i_epch_number);
++ ei->i_next_inode = le32_to_cpu(raw_inode->i_nxt_inode);
++
++#ifdef EXT3COW_FRAGMENTS
++ ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
++ ei->i_frag_no = raw_inode->i_frag;
++ ei->i_frag_size = raw_inode->i_fsize;
++#endif
++ ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
++ if (!S_ISREG(inode->i_mode)) {
++ ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
++ } else {
++ inode->i_size |=
++ ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
++ }
++ ei->i_disksize = inode->i_size;
++ inode->i_generation = le32_to_cpu(raw_inode->i_generation);
++ ei->i_block_group = iloc.block_group;
++ /*
++ * NOTE! The in-memory inode i_data array is in little-endian order
++ * even on big-endian machines: we do NOT byteswap the block numbers!
++ */
++ for (block = 0; block < EXT3COW_N_BLOCKS; block++)
++ ei->i_data[block] = raw_inode->i_block[block];
++ INIT_LIST_HEAD(&ei->i_orphan);
++
++ if (inode->i_ino >= EXT3COW_FIRST_INO(inode->i_sb) + 1 &&
++ EXT3COW_INODE_SIZE(inode->i_sb) > EXT3COW_GOOD_OLD_INODE_SIZE) {
++ /*
++ * When mke2fs creates big inodes it does not zero out
++ * the unused bytes above EXT3COW_GOOD_OLD_INODE_SIZE,
++ * so ignore those first few inodes.
++ */
++ ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
++ if (EXT3COW_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
++ EXT3COW_INODE_SIZE(inode->i_sb))
++ goto bad_inode;
++ if (ei->i_extra_isize == 0) {
++ /* The extra space is currently unused. Use it. */
++ ei->i_extra_isize = sizeof(struct ext3cow_inode) -
++ EXT3COW_GOOD_OLD_INODE_SIZE;
++ } else {
++ __le32 *magic = (void *)raw_inode +
++ EXT3COW_GOOD_OLD_INODE_SIZE +
++ ei->i_extra_isize;
++ if (*magic == cpu_to_le32(EXT3COW_XATTR_MAGIC))
++ ei->i_state |= EXT3COW_STATE_XATTR;
++ }
++ } else
++ ei->i_extra_isize = 0;
++
++ if (S_ISREG(inode->i_mode)) {
++ inode->i_op = &ext3cow_file_inode_operations;
++ inode->i_fop = &ext3cow_file_operations;
++ ext3cow_set_aops(inode);
++ } else if (S_ISDIR(inode->i_mode)) {
++ inode->i_op = &ext3cow_dir_inode_operations;
++ inode->i_fop = &ext3cow_dir_operations;
++ } else if (S_ISLNK(inode->i_mode)) {
++ if (ext3cow_inode_is_fast_symlink(inode))
++ inode->i_op = &ext3cow_fast_symlink_inode_operations;
++ else {
++ inode->i_op = &ext3cow_symlink_inode_operations;
++ ext3cow_set_aops(inode);
++ }
++ } else {
++ inode->i_op = &ext3cow_special_inode_operations;
++ if (raw_inode->i_block[0])
++ init_special_inode(inode, inode->i_mode,
++ old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
++ else
++ init_special_inode(inode, inode->i_mode,
++ new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
++ }
++ brelse (iloc.bh);
++ ext3cow_set_inode_flags(inode);
++ return;
++
++bad_inode:
++ make_bad_inode(inode);
++ return;
++}
++
++/*
++ * Post the struct inode info into an on-disk inode location in the
++ * buffer-cache. This gobbles the caller's reference to the
++ * buffer_head in the inode location struct.
++ *
++ * The caller must have write access to iloc->bh.
++ */
++static int ext3cow_do_update_inode(handle_t *handle,
++ struct inode *inode,
++ struct ext3cow_iloc *iloc)
++{
++ struct ext3cow_inode *raw_inode = ext3cow_raw_inode(iloc);
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ struct buffer_head *bh = iloc->bh;
++ int err = 0, rc, block;
++
++ /* For fields not not tracking in the in-memory inode,
++ * initialise them to zero for new inodes. */
++ if (ei->i_state & EXT3COW_STATE_NEW)
++ memset(raw_inode, 0, EXT3COW_SB(inode->i_sb)->s_inode_size);
++
++ raw_inode->i_mode = cpu_to_le16(inode->i_mode);
++
++ /* Taken out for versioning -znjp
++ if(!(test_opt(inode->i_sb, NO_UID32))) {
++ raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
++ raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
++*
++ * Fix up interoperability with old kernels. Otherwise, old inodes get
++ * re-used with the upper 16 bits of the uid/gid intact
++ *
++
++ if(!ei->i_dtime) {
++ raw_inode->i_uid_high =
++ cpu_to_le16(high_16_bits(inode->i_uid));
++ raw_inode->i_gid_high =
++ cpu_to_le16(high_16_bits(inode->i_gid));
++ } else {
++ raw_inode->i_uid_high = 0;
++ raw_inode->i_gid_high = 0;
++ }
++
++ } else {
++ raw_inode->i_uid_low =
++ cpu_to_le16(fs_high2lowuid(inode->i_uid));
++ raw_inode->i_gid_low =
++ cpu_to_le16(fs_high2lowgid(inode->i_gid));
++ raw_inode->i_uid_high = 0;
++ raw_inode->i_gid_high = 0;
++ }
++ */
++ raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
++ raw_inode->i_size = cpu_to_le32(ei->i_disksize);
++ raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
++ raw_inode->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
++ raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
++ raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
++ raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
++ raw_inode->i_flags = cpu_to_le32(ei->i_flags);
++ /* For versioning -znjp */
++ raw_inode->i_cowbitmap = cpu_to_le16(EXT3COW_I(inode)->i_cow_bitmap);
++ raw_inode->i_epch_number = cpu_to_le32(EXT3COW_I(inode)->i_epoch_number);
++ raw_inode->i_nxt_inode = cpu_to_le32(EXT3COW_I(inode)->i_next_inode);
++
++#ifdef EXT3COW_FRAGMENTS
++ raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
++ raw_inode->i_frag = ei->i_frag_no;
++ raw_inode->i_fsize = ei->i_frag_size;
++#endif
++ raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
++ if (!S_ISREG(inode->i_mode)) {
++ raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
++ } else {
++ raw_inode->i_size_high =
++ cpu_to_le32(ei->i_disksize >> 32);
++ if (ei->i_disksize > 0x7fffffffULL) {
++ struct super_block *sb = inode->i_sb;
++ if (!EXT3COW_HAS_RO_COMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_RO_COMPAT_LARGE_FILE) ||
++ EXT3COW_SB(sb)->s_es->s_rev_level ==
++ cpu_to_le32(EXT3COW_GOOD_OLD_REV)) {
++ /* If this is the first large file
++ * created, add a flag to the superblock.
++ */
++ err = ext3cow_journal_get_write_access(handle,
++ EXT3COW_SB(sb)->s_sbh);
++ if (err)
++ goto out_brelse;
++ ext3cow_update_dynamic_rev(sb);
++ EXT3COW_SET_RO_COMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_RO_COMPAT_LARGE_FILE);
++ sb->s_dirt = 1;
++ handle->h_sync = 1;
++ err = ext3cow_journal_dirty_metadata(handle,
++ EXT3COW_SB(sb)->s_sbh);
++ }
++ }
++ }
++ raw_inode->i_generation = cpu_to_le32(inode->i_generation);
++ if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
++ if (old_valid_dev(inode->i_rdev)) {
++ raw_inode->i_block[0] =
++ cpu_to_le32(old_encode_dev(inode->i_rdev));
++ raw_inode->i_block[1] = 0;
++ } else {
++ raw_inode->i_block[0] = 0;
++ raw_inode->i_block[1] =
++ cpu_to_le32(new_encode_dev(inode->i_rdev));
++ raw_inode->i_block[2] = 0;
++ }
++ } else for (block = 0; block < EXT3COW_N_BLOCKS; block++)
++ raw_inode->i_block[block] = ei->i_data[block];
++
++ if (ei->i_extra_isize)
++ raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
++
++ BUFFER_TRACE(bh, "call ext3cow_journal_dirty_metadata");
++ rc = ext3cow_journal_dirty_metadata(handle, bh);
++ if (!err)
++ err = rc;
++ ei->i_state &= ~EXT3COW_STATE_NEW;
++
++out_brelse:
++ brelse (bh);
++ ext3cow_std_error(inode->i_sb, err);
++ return err;
++}
++
++/*
++ * ext3cow_write_inode()
++ *
++ * We are called from a few places:
++ *
++ * - Within generic_file_write() for O_SYNC files.
++ * Here, there will be no transaction running. We wait for any running
++ * trasnaction to commit.
++ *
++ * - Within sys_sync(), kupdate and such.
++ * We wait on commit, if tol to.
++ *
++ * - Within prune_icache() (PF_MEMALLOC == true)
++ * Here we simply return. We can't afford to block kswapd on the
++ * journal commit.
++ *
++ * In all cases it is actually safe for us to return without doing anything,
++ * because the inode has been copied into a raw inode buffer in
++ * ext3cow_mark_inode_dirty(). This is a correctness thing for O_SYNC and for
++ * knfsd.
++ *
++ * Note that we are absolutely dependent upon all inode dirtiers doing the
++ * right thing: they *must* call mark_inode_dirty() after dirtying info in
++ * which we are interested.
++ *
++ * It would be a bug for them to not do this. The code:
++ *
++ * mark_inode_dirty(inode)
++ * stuff();
++ * inode->i_size = expr;
++ *
++ * is in error because a kswapd-driven write_inode() could occur while
++ * `stuff()' is running, and the new i_size will be lost. Plus the inode
++ * will no longer be on the superblock's dirty inode list.
++ */
++int ext3cow_write_inode(struct inode *inode, int wait)
++{
++ if (current->flags & PF_MEMALLOC)
++ return 0;
++
++ if (ext3cow_journal_current_handle()) {
++ jbd_debug(0, "called recursively, non-PF_MEMALLOC!\n");
++ dump_stack();
++ return -EIO;
++ }
++
++ if (!wait)
++ return 0;
++
++ return ext3cow_force_commit(inode->i_sb);
++}
++
++/*
++ * ext3cow_setattr()
++ *
++ * Called from notify_change.
++ *
++ * We want to trap VFS attempts to truncate the file as soon as
++ * possible. In particular, we want to make sure that when the VFS
++ * shrinks i_size, we put the inode on the orphan list and modify
++ * i_disksize immediately, so that during the subsequent flushing of
++ * dirty pages and freeing of disk blocks, we can guarantee that any
++ * commit will leave the blocks being flushed in an unused state on
++ * disk. (On recovery, the inode will get truncated and the blocks will
++ * be freed, so we have a strong guarantee that no future commit will
++ * leave these blocks visible to the user.)
++ *
++ * Called with inode->sem down.
++ */
++int ext3cow_setattr(struct dentry *dentry, struct iattr *attr)
++{
++ struct inode *inode = dentry->d_inode;
++ int error, rc = 0;
++ const unsigned int ia_valid = attr->ia_valid;
++
++ error = inode_change_ok(inode, attr);
++ if (error)
++ return error;
++
++ /* For versioning -znjp */
++ if(is_unchangeable(inode, dentry)){
++ error = -EROFS;
++ goto err_out;
++ }
++
++ if(EXT3COW_S_EPOCHNUMBER(inode->i_sb) > EXT3COW_I_EPOCHNUMBER(inode)){
++ error = ext3cow_dup_inode(dentry->d_parent->d_inode, inode);
++ if(error)
++ goto err_out;
++ }
++
++ if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
++ (ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
++ handle_t *handle;
++
++ /* (user+group)*(old+new) structure, inode write (sb,
++ * inode block, ? - but truncate inode update has it) */
++ handle = ext3cow_journal_start(inode, 2*(EXT3COW_QUOTA_INIT_BLOCKS(inode->i_sb)+
++ EXT3COW_QUOTA_DEL_BLOCKS(inode->i_sb))+3);
++ if (IS_ERR(handle)) {
++ error = PTR_ERR(handle);
++ goto err_out;
++ }
++ error = DQUOT_TRANSFER(inode, attr) ? -EDQUOT : 0;
++ if (error) {
++ ext3cow_journal_stop(handle);
++ return error;
++ }
++ /* Update corresponding info in inode so that everything is in
++ * one transaction */
++ if (attr->ia_valid & ATTR_UID)
++ inode->i_uid = attr->ia_uid;
++ if (attr->ia_valid & ATTR_GID)
++ inode->i_gid = attr->ia_gid;
++ error = ext3cow_mark_inode_dirty(handle, inode);
++ ext3cow_journal_stop(handle);
++ }
++
++ if (S_ISREG(inode->i_mode) &&
++ attr->ia_valid & ATTR_SIZE && attr->ia_size < inode->i_size) {
++ handle_t *handle;
++
++ handle = ext3cow_journal_start(inode, 3);
++ if (IS_ERR(handle)) {
++ error = PTR_ERR(handle);
++ goto err_out;
++ }
++
++ error = ext3cow_orphan_add(handle, inode);
++ EXT3COW_I(inode)->i_disksize = attr->ia_size;
++ rc = ext3cow_mark_inode_dirty(handle, inode);
++ if (!error)
++ error = rc;
++ ext3cow_journal_stop(handle);
++ }
++
++ rc = inode_setattr(inode, attr);
++
++ /* If inode_setattr's call to ext3cow_truncate failed to get a
++ * transaction handle at all, we need to clean up the in-core
++ * orphan list manually. */
++ if (inode->i_nlink)
++ ext3cow_orphan_del(NULL, inode);
++
++ if (!rc && (ia_valid & ATTR_MODE))
++ rc = ext3cow_acl_chmod(inode);
++
++err_out:
++ ext3cow_std_error(inode->i_sb, error);
++ if (!error)
++ error = rc;
++ return error;
++}
++
++
++/*
++ * How many blocks doth make a writepage()?
++ *
++ * With N blocks per page, it may be:
++ * N data blocks
++ * 2 indirect block
++ * 2 dindirect
++ * 1 tindirect
++ * N+5 bitmap blocks (from the above)
++ * N+5 group descriptor summary blocks
++ * 1 inode block
++ * 1 superblock.
++ * 2 * EXT3COW_SINGLEDATA_TRANS_BLOCKS for the quote files
++ *
++ * 3 * (N + 5) + 2 + 2 * EXT3COW_SINGLEDATA_TRANS_BLOCKS
++ *
++ * With ordered or writeback data it's the same, less the N data blocks.
++ *
++ * If the inode's direct blocks can hold an integral number of pages then a
++ * page cannot straddle two indirect blocks, and we can only touch one indirect
++ * and dindirect block, and the "5" above becomes "3".
++ *
++ * This still overestimates under most circumstances. If we were to pass the
++ * start and end offsets in here as well we could do block_to_path() on each
++ * block and work out the exact number of indirects which are touched. Pah.
++ */
++
++static int ext3cow_writepage_trans_blocks(struct inode *inode)
++{
++ int bpp = ext3cow_journal_blocks_per_page(inode);
++ int indirects = (EXT3COW_NDIR_BLOCKS % bpp) ? 5 : 3;
++ int ret;
++
++ if (ext3cow_should_journal_data(inode))
++ ret = 3 * (bpp + indirects) + 2;
++ else
++ ret = 2 * (bpp + indirects) + 2;
++
++#ifdef CONFIG_QUOTA
++ /* We know that structure was already allocated during DQUOT_INIT so
++ * we will be updating only the data blocks + inodes */
++ ret += 2*EXT3COW_QUOTA_TRANS_BLOCKS(inode->i_sb);
++#endif
++
++ return ret;
++}
++
++/*
++ * The caller must have previously called ext3cow_reserve_inode_write().
++ * Give this, we know that the caller already has write access to iloc->bh.
++ */
++int ext3cow_mark_iloc_dirty(handle_t *handle,
++ struct inode *inode, struct ext3cow_iloc *iloc)
++{
++ int err = 0;
++
++ /* the do_update_inode consumes one bh->b_count */
++ get_bh(iloc->bh);
++
++ /* ext3cow_do_update_inode() does journal_dirty_metadata */
++ err = ext3cow_do_update_inode(handle, inode, iloc);
++ put_bh(iloc->bh);
++ return err;
++}
++
++/*
++ * On success, We end up with an outstanding reference count against
++ * iloc->bh. This _must_ be cleaned up later.
++ */
++
++int
++ext3cow_reserve_inode_write(handle_t *handle, struct inode *inode,
++ struct ext3cow_iloc *iloc)
++{
++ int err = 0;
++ if (handle) {
++ err = ext3cow_get_inode_loc(inode, iloc);
++ if (!err) {
++ BUFFER_TRACE(iloc->bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, iloc->bh);
++ if (err) {
++ brelse(iloc->bh);
++ iloc->bh = NULL;
++ }
++ }
++ }
++ ext3cow_std_error(inode->i_sb, err);
++ return err;
++}
++
++/*
++ * What we do here is to mark the in-core inode as clean with respect to inode
++ * dirtiness (it may still be data-dirty).
++ * This means that the in-core inode may be reaped by prune_icache
++ * without having to perform any I/O. This is a very good thing,
++ * because *any* task may call prune_icache - even ones which
++ * have a transaction open against a different journal.
++ *
++ * Is this cheating? Not really. Sure, we haven't written the
++ * inode out, but prune_icache isn't a user-visible syncing function.
++ * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
++ * we start and wait on commits.
++ *
++ * Is this efficient/effective? Well, we're being nice to the system
++ * by cleaning up our inodes proactively so they can be reaped
++ * without I/O. But we are potentially leaving up to five seconds'
++ * worth of inodes floating about which prune_icache wants us to
++ * write out. One way to fix that would be to get prune_icache()
++ * to do a write_super() to free up some memory. It has the desired
++ * effect.
++ */
++int ext3cow_mark_inode_dirty(handle_t *handle, struct inode *inode)
++{
++ struct ext3cow_iloc iloc;
++ int err;
++
++ if(EXT3COW_IS_FAKEINODE(inode))
++ return 0;
++
++ might_sleep();
++ err = ext3cow_reserve_inode_write(handle, inode, &iloc);
++ if (!err)
++ err = ext3cow_mark_iloc_dirty(handle, inode, &iloc);
++ return err;
++}
++
++/*
++ * ext3cow_dirty_inode() is called from __mark_inode_dirty()
++ *
++ * We're really interested in the case where a file is being extended.
++ * i_size has been changed by generic_commit_write() and we thus need
++ * to include the updated inode in the current transaction.
++ *
++ * Also, DQUOT_ALLOC_SPACE() will always dirty the inode when blocks
++ * are allocated to the file.
++ *
++ * If the inode is marked synchronous, we don't honour that here - doing
++ * so would cause a commit on atime updates, which we don't bother doing.
++ * We handle synchronous inodes at the highest possible level.
++ */
++void ext3cow_dirty_inode(struct inode *inode)
++{
++ handle_t *current_handle = ext3cow_journal_current_handle();
++ handle_t *handle;
++
++ handle = ext3cow_journal_start(inode, 2);
++ if (IS_ERR(handle))
++ goto out;
++ if (current_handle &&
++ current_handle->h_transaction != handle->h_transaction) {
++ /* This task has a transaction open against a different fs */
++ printk(KERN_EMERG "%s: transactions do not match!\n",
++ __FUNCTION__);
++ } else {
++ jbd_debug(5, "marking dirty. outer handle=%p\n",
++ current_handle);
++ ext3cow_mark_inode_dirty(handle, inode);
++ }
++ ext3cow_journal_stop(handle);
++out:
++ return;
++}
++
++#if 0
++/*
++ * Bind an inode's backing buffer_head into this transaction, to prevent
++ * it from being flushed to disk early. Unlike
++ * ext3cow_reserve_inode_write, this leaves behind no bh reference and
++ * returns no iloc structure, so the caller needs to repeat the iloc
++ * lookup to mark the inode dirty later.
++ */
++static int ext3cow_pin_inode(handle_t *handle, struct inode *inode)
++{
++ struct ext3cow_iloc iloc;
++
++ int err = 0;
++ if (handle) {
++ err = ext3cow_get_inode_loc(inode, &iloc);
++ if (!err) {
++ BUFFER_TRACE(iloc.bh, "get_write_access");
++ err = journal_get_write_access(handle, iloc.bh);
++ if (!err)
++ err = ext3cow_journal_dirty_metadata(handle,
++ iloc.bh);
++ brelse(iloc.bh);
++ }
++ }
++ ext3cow_std_error(inode->i_sb, err);
++ return err;
++}
++#endif
++
++int ext3cow_change_inode_journal_flag(struct inode *inode, int val)
++{
++ journal_t *journal;
++ handle_t *handle;
++ int err;
++
++ /*
++ * We have to be very careful here: changing a data block's
++ * journaling status dynamically is dangerous. If we write a
++ * data block to the journal, change the status and then delete
++ * that block, we risk forgetting to revoke the old log record
++ * from the journal and so a subsequent replay can corrupt data.
++ * So, first we make sure that the journal is empty and that
++ * nobody is changing anything.
++ */
++
++ journal = EXT3COW_JOURNAL(inode);
++ if (is_journal_aborted(journal) || IS_RDONLY(inode))
++ return -EROFS;
++
++ journal_lock_updates(journal);
++ journal_flush(journal);
++
++ /*
++ * OK, there are no updates running now, and all cached data is
++ * synced to disk. We are now in a completely consistent state
++ * which doesn't have anything in the journal, and we know that
++ * no filesystem updates are running, so it is safe to modify
++ * the inode's in-core data-journaling state flag now.
++ */
++
++ if (val)
++ EXT3COW_I(inode)->i_flags |= EXT3COW_JOURNAL_DATA_FL;
++ else
++ EXT3COW_I(inode)->i_flags &= ~EXT3COW_JOURNAL_DATA_FL;
++ ext3cow_set_aops(inode);
++
++ journal_unlock_updates(journal);
++
++ /* Finally we can mark the inode as dirty. */
++
++ handle = ext3cow_journal_start(inode, 1);
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ err = ext3cow_mark_inode_dirty(handle, inode);
++ handle->h_sync = 1;
++ ext3cow_journal_stop(handle);
++ ext3cow_std_error(inode->i_sb, err);
++
++ return err;
++}
+diff -ruN linux-2.6.20.3/fs/ext3cow/ioctl.c linux-2.6.20.3-ext3cow/fs/ext3cow/ioctl.c
+--- linux-2.6.20.3/fs/ext3cow/ioctl.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/ioctl.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,312 @@
++/*
++ * linux/fs/ext3cow/ioctl.c
++ *
++ * Copyright (C) 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++
++int ext3cow_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
++ unsigned long arg)
++{
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ unsigned int flags;
++ unsigned short rsv_window_size;
++
++ ext3cow_debug ("cmd = %u, arg = %lu\n", cmd, arg);
++
++ switch (cmd) {
++ /* Some IOCTLs for version */
++ case EXT3COW_IOC_TAKESNAPSHOT:
++ return (unsigned int)ext3cow_take_snapshot(inode->i_sb);
++ case EXT3COW_IOC_GETEPOCH:
++ return (unsigned int)EXT3COW_S_EPOCHNUMBER(inode->i_sb);
++ case EXT3COW_IOC_GETFLAGS:
++ flags = ei->i_flags & EXT3COW_FL_USER_VISIBLE;
++ return put_user(flags, (int __user *) arg);
++ case EXT3COW_IOC_SETFLAGS: {
++ handle_t *handle = NULL;
++ int err;
++ struct ext3cow_iloc iloc;
++ unsigned int oldflags;
++ unsigned int jflag;
++
++ if (IS_RDONLY(inode))
++ return -EROFS;
++
++ if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
++ return -EACCES;
++
++ if (get_user(flags, (int __user *) arg))
++ return -EFAULT;
++
++ if (!S_ISDIR(inode->i_mode))
++ flags &= ~EXT3COW_DIRSYNC_FL;
++
++ mutex_lock(&inode->i_mutex);
++ oldflags = ei->i_flags;
++
++ /* The JOURNAL_DATA flag is modifiable only by root */
++ jflag = flags & EXT3COW_JOURNAL_DATA_FL;
++
++ /*
++ * The IMMUTABLE and APPEND_ONLY flags can only be changed by
++ * the relevant capability.
++ *
++ * This test looks nicer. Thanks to Pauline Middelink
++ */
++ if ((flags ^ oldflags) & (EXT3COW_APPEND_FL | EXT3COW_IMMUTABLE_FL)) {
++ if (!capable(CAP_LINUX_IMMUTABLE)) {
++ mutex_unlock(&inode->i_mutex);
++ return -EPERM;
++ }
++ }
++
++ /*
++ * The JOURNAL_DATA flag can only be changed by
++ * the relevant capability.
++ */
++ if ((jflag ^ oldflags) & (EXT3COW_JOURNAL_DATA_FL)) {
++ if (!capable(CAP_SYS_RESOURCE)) {
++ mutex_unlock(&inode->i_mutex);
++ return -EPERM;
++ }
++ }
++
++
++ handle = ext3cow_journal_start(inode, 1);
++ if (IS_ERR(handle)) {
++ mutex_unlock(&inode->i_mutex);
++ return PTR_ERR(handle);
++ }
++ if (IS_SYNC(inode))
++ handle->h_sync = 1;
++ err = ext3cow_reserve_inode_write(handle, inode, &iloc);
++ if (err)
++ goto flags_err;
++
++ flags = flags & EXT3COW_FL_USER_MODIFIABLE;
++ flags |= oldflags & ~EXT3COW_FL_USER_MODIFIABLE;
++ ei->i_flags = flags;
++
++ ext3cow_set_inode_flags(inode);
++ inode->i_ctime = CURRENT_TIME_SEC;
++
++ err = ext3cow_mark_iloc_dirty(handle, inode, &iloc);
++flags_err:
++ ext3cow_journal_stop(handle);
++ if (err) {
++ mutex_unlock(&inode->i_mutex);
++ return err;
++ }
++
++ if ((jflag ^ oldflags) & (EXT3COW_JOURNAL_DATA_FL))
++ err = ext3cow_change_inode_journal_flag(inode, jflag);
++ mutex_unlock(&inode->i_mutex);
++ return err;
++ }
++ case EXT3COW_IOC_GETVERSION:
++ case EXT3COW_IOC_GETVERSION_OLD:
++ return put_user(inode->i_generation, (int __user *) arg);
++ case EXT3COW_IOC_SETVERSION:
++ case EXT3COW_IOC_SETVERSION_OLD: {
++ handle_t *handle;
++ struct ext3cow_iloc iloc;
++ __u32 generation;
++ int err;
++
++ if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
++ return -EPERM;
++ if (IS_RDONLY(inode))
++ return -EROFS;
++ if (get_user(generation, (int __user *) arg))
++ return -EFAULT;
++
++ handle = ext3cow_journal_start(inode, 1);
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ err = ext3cow_reserve_inode_write(handle, inode, &iloc);
++ if (err == 0) {
++ inode->i_ctime = CURRENT_TIME_SEC;
++ inode->i_generation = generation;
++ err = ext3cow_mark_iloc_dirty(handle, inode, &iloc);
++ }
++ ext3cow_journal_stop(handle);
++ return err;
++ }
++#ifdef CONFIG_JBD_DEBUG
++ case EXT3COW_IOC_WAIT_FOR_READONLY:
++ /*
++ * This is racy - by the time we're woken up and running,
++ * the superblock could be released. And the module could
++ * have been unloaded. So sue me.
++ *
++ * Returns 1 if it slept, else zero.
++ */
++ {
++ struct super_block *sb = inode->i_sb;
++ DECLARE_WAITQUEUE(wait, current);
++ int ret = 0;
++
++ set_current_state(TASK_INTERRUPTIBLE);
++ add_wait_queue(&EXT3COW_SB(sb)->ro_wait_queue, &wait);
++ if (timer_pending(&EXT3COW_SB(sb)->turn_ro_timer)) {
++ schedule();
++ ret = 1;
++ }
++ remove_wait_queue(&EXT3COW_SB(sb)->ro_wait_queue, &wait);
++ return ret;
++ }
++#endif
++ case EXT3COW_IOC_GETRSVSZ:
++ if (test_opt(inode->i_sb, RESERVATION)
++ && S_ISREG(inode->i_mode)
++ && ei->i_block_alloc_info) {
++ rsv_window_size = ei->i_block_alloc_info->rsv_window_node.rsv_goal_size;
++ return put_user(rsv_window_size, (int __user *)arg);
++ }
++ return -ENOTTY;
++ case EXT3COW_IOC_SETRSVSZ: {
++
++ if (!test_opt(inode->i_sb, RESERVATION) ||!S_ISREG(inode->i_mode))
++ return -ENOTTY;
++
++ if (IS_RDONLY(inode))
++ return -EROFS;
++
++ if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
++ return -EACCES;
++
++ if (get_user(rsv_window_size, (int __user *)arg))
++ return -EFAULT;
++
++ if (rsv_window_size > EXT3COW_MAX_RESERVE_BLOCKS)
++ rsv_window_size = EXT3COW_MAX_RESERVE_BLOCKS;
++
++ /*
++ * need to allocate reservation structure for this inode
++ * before set the window size
++ */
++ mutex_lock(&ei->truncate_mutex);
++ if (!ei->i_block_alloc_info)
++ ext3cow_init_block_alloc_info(inode);
++
++ if (ei->i_block_alloc_info){
++ struct ext3cow_reserve_window_node *rsv = &ei->i_block_alloc_info->rsv_window_node;
++ rsv->rsv_goal_size = rsv_window_size;
++ }
++ mutex_unlock(&ei->truncate_mutex);
++ return 0;
++ }
++ case EXT3COW_IOC_GROUP_EXTEND: {
++ ext3cow_fsblk_t n_blocks_count;
++ struct super_block *sb = inode->i_sb;
++ int err;
++
++ if (!capable(CAP_SYS_RESOURCE))
++ return -EPERM;
++
++ if (IS_RDONLY(inode))
++ return -EROFS;
++
++ if (get_user(n_blocks_count, (__u32 __user *)arg))
++ return -EFAULT;
++
++ err = ext3cow_group_extend(sb, EXT3COW_SB(sb)->s_es, n_blocks_count);
++ journal_lock_updates(EXT3COW_SB(sb)->s_journal);
++ journal_flush(EXT3COW_SB(sb)->s_journal);
++ journal_unlock_updates(EXT3COW_SB(sb)->s_journal);
++
++ return err;
++ }
++ case EXT3COW_IOC_GROUP_ADD: {
++ struct ext3cow_new_group_data input;
++ struct super_block *sb = inode->i_sb;
++ int err;
++
++ if (!capable(CAP_SYS_RESOURCE))
++ return -EPERM;
++
++ if (IS_RDONLY(inode))
++ return -EROFS;
++
++ if (copy_from_user(&input, (struct ext3cow_new_group_input __user *)arg,
++ sizeof(input)))
++ return -EFAULT;
++
++ err = ext3cow_group_add(sb, &input);
++ journal_lock_updates(EXT3COW_SB(sb)->s_journal);
++ journal_flush(EXT3COW_SB(sb)->s_journal);
++ journal_unlock_updates(EXT3COW_SB(sb)->s_journal);
++
++ return err;
++ }
++
++
++ default:
++ return -ENOTTY;
++ }
++}
++
++#ifdef CONFIG_COMPAT
++long ext3cow_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
++{
++ struct inode *inode = file->f_path.dentry->d_inode;
++ int ret;
++
++ /* These are just misnamed, they actually get/put from/to user an int */
++ switch (cmd) {
++ case EXT3COW_IOC32_GETFLAGS:
++ cmd = EXT3COW_IOC_GETFLAGS;
++ break;
++ case EXT3COW_IOC32_SETFLAGS:
++ cmd = EXT3COW_IOC_SETFLAGS;
++ break;
++ case EXT3COW_IOC32_GETVERSION:
++ cmd = EXT3COW_IOC_GETVERSION;
++ break;
++ case EXT3COW_IOC32_SETVERSION:
++ cmd = EXT3COW_IOC_SETVERSION;
++ break;
++ case EXT3COW_IOC32_GROUP_EXTEND:
++ cmd = EXT3COW_IOC_GROUP_EXTEND;
++ break;
++ case EXT3COW_IOC32_GETVERSION_OLD:
++ cmd = EXT3COW_IOC_GETVERSION_OLD;
++ break;
++ case EXT3COW_IOC32_SETVERSION_OLD:
++ cmd = EXT3COW_IOC_SETVERSION_OLD;
++ break;
++#ifdef CONFIG_JBD_DEBUG
++ case EXT3COW_IOC32_WAIT_FOR_READONLY:
++ cmd = EXT3COW_IOC_WAIT_FOR_READONLY;
++ break;
++#endif
++ case EXT3COW_IOC32_GETRSVSZ:
++ cmd = EXT3COW_IOC_GETRSVSZ;
++ break;
++ case EXT3COW_IOC32_SETRSVSZ:
++ cmd = EXT3COW_IOC_SETRSVSZ;
++ break;
++ case EXT3COW_IOC_GROUP_ADD:
++ break;
++ default:
++ return -ENOIOCTLCMD;
++ }
++ lock_kernel();
++ ret = ext3cow_ioctl(inode, file, cmd, (unsigned long) compat_ptr(arg));
++ unlock_kernel();
++ return ret;
++}
++#endif
+diff -ruN linux-2.6.20.3/fs/ext3cow/namei.c linux-2.6.20.3-ext3cow/fs/ext3cow/namei.c
+--- linux-2.6.20.3/fs/ext3cow/namei.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/namei.c 2007-04-16 22:44:05.000000000 -0400
+@@ -0,0 +1,2960 @@
++/*
++ * linux/fs/ext3cow/namei.c
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/fs/minix/namei.c
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ *
++ * Big-endian to little-endian byte-swapping/bitmaps by
++ * David S. Miller (davem@caip.rutgers.edu), 1995
++ * Directory entry file type support and forward compatibility hooks
++ * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
++ * Hash Tree Directory indexing (c)
++ * Daniel Phillips, 2001
++ * Hash Tree Directory indexing porting
++ * Christopher Li, 2002
++ * Hash Tree Directory indexing cleanup
++ * Theodore Ts'o, 2002
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++
++#include "namei.h"
++#include "xattr.h"
++#include "acl.h"
++
++/*
++ * define how far ahead to read directories while searching them.
++ */
++#define NAMEI_RA_CHUNKS 2
++#define NAMEI_RA_BLOCKS 4
++#define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
++#define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b))
++
++/* is the inode marked unchangeable or does the name
++ contain an epoch less than the current system epoch -znjp */
++int is_unchangeable(struct inode *inode, struct dentry *dentry){
++
++ char *at = NULL;
++
++ if (inode && (EXT3COW_IS_UNCHANGEABLE(inode) || IS_IMMUTABLE(inode)))
++ return 1;
++ if(dentry)
++ at = strrchr(dentry->d_name.name, EXT3COW_FLUX_TOKEN);
++ if(at && (simple_strtol(&at[1], (char **)NULL, 10) > 0))
++ return 1;
++
++ return 0;
++}
++
++static struct buffer_head *ext3cow_append(handle_t *handle,
++ struct inode *inode,
++ u32 *block, int *err)
++{
++ struct buffer_head *bh;
++
++ *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
++
++ if ((bh = ext3cow_bread(handle, inode, *block, 1, err))) {
++ inode->i_size += inode->i_sb->s_blocksize;
++ EXT3COW_I(inode)->i_disksize = inode->i_size;
++ ext3cow_journal_get_write_access(handle,bh);
++ }
++ return bh;
++}
++
++#ifndef assert
++#define assert(test) J_ASSERT(test)
++#endif
++
++#ifndef swap
++#define swap(x, y) do { typeof(x) z = x; x = y; y = z; } while (0)
++#endif
++
++#ifdef DX_DEBUG
++#define dxtrace(command) command
++#else
++#define dxtrace(command)
++#endif
++
++struct fake_dirent
++{
++ __le32 inode;
++ __le16 rec_len;
++ u8 name_len;
++ u8 file_type;
++};
++
++struct dx_countlimit
++{
++ __le16 limit;
++ __le16 count;
++};
++
++struct dx_entry
++{
++ __le32 hash;
++ __le32 block;
++};
++
++/*
++ * dx_root_info is laid out so that if it should somehow get overlaid by a
++ * dirent the two low bits of the hash version will be zero. Therefore, the
++ * hash version mod 4 should never be 0. Sincerely, the paranoia department.
++ */
++
++struct dx_root
++{
++ struct fake_dirent dot;
++ char dot_name[4];
++ struct fake_dirent dotdot;
++ char dotdot_name[4];
++ struct dx_root_info
++ {
++ __le32 reserved_zero;
++ u8 hash_version;
++ u8 info_length; /* 8 */
++ u8 indirect_levels;
++ u8 unused_flags;
++ }
++ info;
++ struct dx_entry entries[0];
++};
++
++struct dx_node
++{
++ struct fake_dirent fake;
++ struct dx_entry entries[0];
++};
++
++
++struct dx_frame
++{
++ struct buffer_head *bh;
++ struct dx_entry *entries;
++ struct dx_entry *at;
++};
++
++struct dx_map_entry
++{
++ u32 hash;
++ u32 offs;
++};
++
++#ifdef CONFIG_EXT3COW_INDEX
++static inline unsigned dx_get_block (struct dx_entry *entry);
++static void dx_set_block (struct dx_entry *entry, unsigned value);
++static inline unsigned dx_get_hash (struct dx_entry *entry);
++static void dx_set_hash (struct dx_entry *entry, unsigned value);
++static unsigned dx_get_count (struct dx_entry *entries);
++static unsigned dx_get_limit (struct dx_entry *entries);
++static void dx_set_count (struct dx_entry *entries, unsigned value);
++static void dx_set_limit (struct dx_entry *entries, unsigned value);
++static unsigned dx_root_limit (struct inode *dir, unsigned infosize);
++static unsigned dx_node_limit (struct inode *dir);
++static struct dx_frame *dx_probe(struct dentry *dentry,
++ struct inode *dir,
++ struct dx_hash_info *hinfo,
++ struct dx_frame *frame,
++ int *err);
++static void dx_release (struct dx_frame *frames);
++static int dx_make_map (struct ext3cow_dir_entry_2 *de, int size,
++ struct dx_hash_info *hinfo, struct dx_map_entry map[]);
++static void dx_sort_map(struct dx_map_entry *map, unsigned count);
++static struct ext3cow_dir_entry_2 *dx_move_dirents (char *from, char *to,
++ struct dx_map_entry *offsets, int count);
++static struct ext3cow_dir_entry_2* dx_pack_dirents (char *base, int size);
++static void dx_insert_block (struct dx_frame *frame, u32 hash, u32 block);
++static int ext3cow_htree_next_block(struct inode *dir, __u32 hash,
++ struct dx_frame *frame,
++ struct dx_frame *frames,
++ __u32 *start_hash);
++static struct buffer_head * ext3cow_dx_find_entry(struct dentry *dentry,
++ struct ext3cow_dir_entry_2 **res_dir, int *err);
++static int ext3cow_dx_add_entry(handle_t *handle, struct dentry *dentry,
++ struct inode *inode);
++
++/*
++ * Future: use high four bits of block for coalesce-on-delete flags
++ * Mask them off for now.
++ */
++
++static inline unsigned dx_get_block (struct dx_entry *entry)
++{
++ return le32_to_cpu(entry->block) & 0x00ffffff;
++}
++
++static inline void dx_set_block (struct dx_entry *entry, unsigned value)
++{
++ entry->block = cpu_to_le32(value);
++}
++
++static inline unsigned dx_get_hash (struct dx_entry *entry)
++{
++ return le32_to_cpu(entry->hash);
++}
++
++static inline void dx_set_hash (struct dx_entry *entry, unsigned value)
++{
++ entry->hash = cpu_to_le32(value);
++}
++
++static inline unsigned dx_get_count (struct dx_entry *entries)
++{
++ return le16_to_cpu(((struct dx_countlimit *) entries)->count);
++}
++
++static inline unsigned dx_get_limit (struct dx_entry *entries)
++{
++ return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
++}
++
++static inline void dx_set_count (struct dx_entry *entries, unsigned value)
++{
++ ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
++}
++
++static inline void dx_set_limit (struct dx_entry *entries, unsigned value)
++{
++ ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
++}
++
++static inline unsigned dx_root_limit (struct inode *dir, unsigned infosize)
++{
++ unsigned entry_space = dir->i_sb->s_blocksize - EXT3COW_DIR_REC_LEN(1) -
++ EXT3COW_DIR_REC_LEN(2) - infosize;
++ return 0? 20: entry_space / sizeof(struct dx_entry);
++}
++
++static inline unsigned dx_node_limit (struct inode *dir)
++{
++ unsigned entry_space = dir->i_sb->s_blocksize - EXT3COW_DIR_REC_LEN(0);
++ return 0? 22: entry_space / sizeof(struct dx_entry);
++}
++
++/*
++ * Debug
++ */
++#ifdef DX_DEBUG
++static void dx_show_index (char * label, struct dx_entry *entries)
++{
++ int i, n = dx_get_count (entries);
++ printk("%s index ", label);
++ for (i = 0; i < n; i++)
++ {
++ printk("%x->%u ", i? dx_get_hash(entries + i): 0, dx_get_block(entries + i));
++ }
++ printk("\n");
++}
++
++struct stats
++{
++ unsigned names;
++ unsigned space;
++ unsigned bcount;
++};
++
++static struct stats dx_show_leaf(struct dx_hash_info *hinfo, struct ext3cow_dir_entry_2 *de,
++ int size, int show_names)
++{
++ unsigned names = 0, space = 0;
++ char *base = (char *) de;
++ struct dx_hash_info h = *hinfo;
++
++ printk("names: ");
++ while ((char *) de < base + size)
++ {
++ if (de->inode)
++ {
++ if (show_names)
++ {
++ int len = de->name_len;
++ char *name = de->name;
++ while (len--) printk("%c", *name++);
++ ext3cowfs_dirhash(de->name, de->name_len, &h);
++ printk(":%x.%u ", h.hash,
++ ((char *) de - base));
++ }
++ space += EXT3COW_DIR_REC_LEN(de->name_len);
++ names++;
++ }
++ de = (struct ext3cow_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
++ }
++ printk("(%i)\n", names);
++ return (struct stats) { names, space, 1 };
++}
++
++struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
++ struct dx_entry *entries, int levels)
++{
++ unsigned blocksize = dir->i_sb->s_blocksize;
++ unsigned count = dx_get_count (entries), names = 0, space = 0, i;
++ unsigned bcount = 0;
++ struct buffer_head *bh;
++ int err;
++ printk("%i indexed blocks...\n", count);
++ for (i = 0; i < count; i++, entries++)
++ {
++ u32 block = dx_get_block(entries), hash = i? dx_get_hash(entries): 0;
++ u32 range = i < count - 1? (dx_get_hash(entries + 1) - hash): ~hash;
++ struct stats stats;
++ printk("%s%3u:%03u hash %8x/%8x ",levels?"":" ", i, block, hash, range);
++ if (!(bh = ext3cow_bread (NULL,dir, block, 0,&err))) continue;
++ stats = levels?
++ dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
++ dx_show_leaf(hinfo, (struct ext3cow_dir_entry_2 *) bh->b_data, blocksize, 0);
++ names += stats.names;
++ space += stats.space;
++ bcount += stats.bcount;
++ brelse (bh);
++ }
++ if (bcount)
++ printk("%snames %u, fullness %u (%u%%)\n", levels?"":" ",
++ names, space/bcount,(space/bcount)*100/blocksize);
++ return (struct stats) { names, space, bcount};
++}
++#endif /* DX_DEBUG */
++
++/*
++ * Probe for a directory leaf block to search.
++ *
++ * dx_probe can return ERR_BAD_DX_DIR, which means there was a format
++ * error in the directory index, and the caller should fall back to
++ * searching the directory normally. The callers of dx_probe **MUST**
++ * check for this error code, and make sure it never gets reflected
++ * back to userspace.
++ */
++static struct dx_frame *
++dx_probe(struct dentry *dentry, struct inode *dir,
++ struct dx_hash_info *hinfo, struct dx_frame *frame_in, int *err)
++{
++ unsigned count, indirect;
++ struct dx_entry *at, *entries, *p, *q, *m;
++ struct dx_root *root;
++ struct buffer_head *bh;
++ struct dx_frame *frame = frame_in;
++ u32 hash;
++
++ frame->bh = NULL;
++ if (dentry)
++ dir = dentry->d_parent->d_inode;
++ if (!(bh = ext3cow_bread (NULL,dir, 0, 0, err)))
++ goto fail;
++ root = (struct dx_root *) bh->b_data;
++ if (root->info.hash_version != DX_HASH_TEA &&
++ root->info.hash_version != DX_HASH_HALF_MD4 &&
++ root->info.hash_version != DX_HASH_LEGACY) {
++ ext3cow_warning(dir->i_sb, __FUNCTION__,
++ "Unrecognised inode hash code %d",
++ root->info.hash_version);
++ brelse(bh);
++ *err = ERR_BAD_DX_DIR;
++ goto fail;
++ }
++ hinfo->hash_version = root->info.hash_version;
++ hinfo->seed = EXT3COW_SB(dir->i_sb)->s_hash_seed;
++ if (dentry)
++ ext3cowfs_dirhash(dentry->d_name.name, dentry->d_name.len, hinfo);
++ hash = hinfo->hash;
++
++ if (root->info.unused_flags & 1) {
++ ext3cow_warning(dir->i_sb, __FUNCTION__,
++ "Unimplemented inode hash flags: %#06x",
++ root->info.unused_flags);
++ brelse(bh);
++ *err = ERR_BAD_DX_DIR;
++ goto fail;
++ }
++
++ if ((indirect = root->info.indirect_levels) > 1) {
++ ext3cow_warning(dir->i_sb, __FUNCTION__,
++ "Unimplemented inode hash depth: %#06x",
++ root->info.indirect_levels);
++ brelse(bh);
++ *err = ERR_BAD_DX_DIR;
++ goto fail;
++ }
++
++ entries = (struct dx_entry *) (((char *)&root->info) +
++ root->info.info_length);
++ assert(dx_get_limit(entries) == dx_root_limit(dir,
++ root->info.info_length));
++ dxtrace (printk("Look up %x", hash));
++ while (1)
++ {
++ count = dx_get_count(entries);
++ assert (count && count <= dx_get_limit(entries));
++ p = entries + 1;
++ q = entries + count - 1;
++ while (p <= q)
++ {
++ m = p + (q - p)/2;
++ dxtrace(printk("."));
++ if (dx_get_hash(m) > hash)
++ q = m - 1;
++ else
++ p = m + 1;
++ }
++
++ if (0) // linear search cross check
++ {
++ unsigned n = count - 1;
++ at = entries;
++ while (n--)
++ {
++ dxtrace(printk(","));
++ if (dx_get_hash(++at) > hash)
++ {
++ at--;
++ break;
++ }
++ }
++ assert (at == p - 1);
++ }
++
++ at = p - 1;
++ dxtrace(printk(" %x->%u\n", at == entries? 0: dx_get_hash(at), dx_get_block(at)));
++ frame->bh = bh;
++ frame->entries = entries;
++ frame->at = at;
++ if (!indirect--) return frame;
++ if (!(bh = ext3cow_bread (NULL,dir, dx_get_block(at), 0, err)))
++ goto fail2;
++ at = entries = ((struct dx_node *) bh->b_data)->entries;
++ assert (dx_get_limit(entries) == dx_node_limit (dir));
++ frame++;
++ }
++fail2:
++ while (frame >= frame_in) {
++ brelse(frame->bh);
++ frame--;
++ }
++fail:
++ return NULL;
++}
++
++static void dx_release (struct dx_frame *frames)
++{
++ if (frames[0].bh == NULL)
++ return;
++
++ if (((struct dx_root *) frames[0].bh->b_data)->info.indirect_levels)
++ brelse(frames[1].bh);
++ brelse(frames[0].bh);
++}
++
++/*
++ * This function increments the frame pointer to search the next leaf
++ * block, and reads in the necessary intervening nodes if the search
++ * should be necessary. Whether or not the search is necessary is
++ * controlled by the hash parameter. If the hash value is even, then
++ * the search is only continued if the next block starts with that
++ * hash value. This is used if we are searching for a specific file.
++ *
++ * If the hash value is HASH_NB_ALWAYS, then always go to the next block.
++ *
++ * This function returns 1 if the caller should continue to search,
++ * or 0 if it should not. If there is an error reading one of the
++ * index blocks, it will a negative error code.
++ *
++ * If start_hash is non-null, it will be filled in with the starting
++ * hash of the next page.
++ */
++static int ext3cow_htree_next_block(struct inode *dir, __u32 hash,
++ struct dx_frame *frame,
++ struct dx_frame *frames,
++ __u32 *start_hash)
++{
++ struct dx_frame *p;
++ struct buffer_head *bh;
++ int err, num_frames = 0;
++ __u32 bhash;
++
++ p = frame;
++ /*
++ * Find the next leaf page by incrementing the frame pointer.
++ * If we run out of entries in the interior node, loop around and
++ * increment pointer in the parent node. When we break out of
++ * this loop, num_frames indicates the number of interior
++ * nodes need to be read.
++ */
++ while (1) {
++ if (++(p->at) < p->entries + dx_get_count(p->entries))
++ break;
++ if (p == frames)
++ return 0;
++ num_frames++;
++ p--;
++ }
++
++ /*
++ * If the hash is 1, then continue only if the next page has a
++ * continuation hash of any value. This is used for readdir
++ * handling. Otherwise, check to see if the hash matches the
++ * desired contiuation hash. If it doesn't, return since
++ * there's no point to read in the successive index pages.
++ */
++ bhash = dx_get_hash(p->at);
++ if (start_hash)
++ *start_hash = bhash;
++ if ((hash & 1) == 0) {
++ if ((bhash & ~1) != hash)
++ return 0;
++ }
++ /*
++ * If the hash is HASH_NB_ALWAYS, we always go to the next
++ * block so no check is necessary
++ */
++ while (num_frames--) {
++ if (!(bh = ext3cow_bread(NULL, dir, dx_get_block(p->at),
++ 0, &err)))
++ return err; /* Failure */
++ p++;
++ brelse (p->bh);
++ p->bh = bh;
++ p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
++ }
++ return 1;
++}
++
++
++/*
++ * p is at least 6 bytes before the end of page
++ */
++static inline struct ext3cow_dir_entry_2 *ext3cow_next_entry(struct ext3cow_dir_entry_2 *p)
++{
++ return (struct ext3cow_dir_entry_2 *)((char*)p + le16_to_cpu(p->rec_len));
++}
++
++/*
++ * This function fills a red-black tree with information from a
++ * directory block. It returns the number directory entries loaded
++ * into the tree. If there is an error it is returned in err.
++ */
++static int htree_dirblock_to_tree(struct file *dir_file,
++ struct inode *dir, int block,
++ struct dx_hash_info *hinfo,
++ __u32 start_hash, __u32 start_minor_hash)
++{
++ struct buffer_head *bh;
++ struct ext3cow_dir_entry_2 *de, *top;
++ int err, count = 0;
++
++ dxtrace(printk("In htree dirblock_to_tree: block %d\n", block));
++ if (!(bh = ext3cow_bread (NULL, dir, block, 0, &err)))
++ return err;
++
++ de = (struct ext3cow_dir_entry_2 *) bh->b_data;
++ top = (struct ext3cow_dir_entry_2 *) ((char *) de +
++ dir->i_sb->s_blocksize -
++ EXT3COW_DIR_REC_LEN(0));
++ for (; de < top; de = ext3cow_next_entry(de)) {
++ if (!ext3cow_check_dir_entry("htree_dirblock_to_tree", dir, de, bh,
++ (block<i_sb))
++ +((char *)de - bh->b_data))) {
++ /* On error, skip the f_pos to the next block. */
++ dir_file->f_pos = (dir_file->f_pos |
++ (dir->i_sb->s_blocksize - 1)) + 1;
++ brelse (bh);
++ return count;
++ }
++ ext3cowfs_dirhash(de->name, de->name_len, hinfo);
++ if ((hinfo->hash < start_hash) ||
++ ((hinfo->hash == start_hash) &&
++ (hinfo->minor_hash < start_minor_hash)))
++ continue;
++ if (de->inode == 0)
++ continue;
++ if ((err = ext3cow_htree_store_dirent(dir_file,
++ hinfo->hash, hinfo->minor_hash, de)) != 0) {
++ brelse(bh);
++ return err;
++ }
++ count++;
++ }
++ brelse(bh);
++ return count;
++}
++
++
++/*
++ * This function fills a red-black tree with information from a
++ * directory. We start scanning the directory in hash order, starting
++ * at start_hash and start_minor_hash.
++ *
++ * This function returns the number of entries inserted into the tree,
++ * or a negative error code.
++ */
++int ext3cow_htree_fill_tree(struct file *dir_file, __u32 start_hash,
++ __u32 start_minor_hash, __u32 *next_hash)
++{
++ struct dx_hash_info hinfo;
++ struct ext3cow_dir_entry_2 *de;
++ struct dx_frame frames[2], *frame;
++ struct inode *dir;
++ int block, err;
++ int count = 0;
++ int ret;
++ __u32 hashval;
++
++ dxtrace(printk("In htree_fill_tree, start hash: %x:%x\n", start_hash,
++ start_minor_hash));
++ dir = dir_file->f_path.dentry->d_inode;
++ if (!(EXT3COW_I(dir)->i_flags & EXT3COW_INDEX_FL)) {
++ hinfo.hash_version = EXT3COW_SB(dir->i_sb)->s_def_hash_version;
++ hinfo.seed = EXT3COW_SB(dir->i_sb)->s_hash_seed;
++ count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
++ start_hash, start_minor_hash);
++ *next_hash = ~0;
++ return count;
++ }
++ hinfo.hash = start_hash;
++ hinfo.minor_hash = 0;
++ frame = dx_probe(NULL, dir_file->f_path.dentry->d_inode, &hinfo, frames, &err);
++ if (!frame)
++ return err;
++
++ /* Add '.' and '..' from the htree header */
++ if (!start_hash && !start_minor_hash) {
++ de = (struct ext3cow_dir_entry_2 *) frames[0].bh->b_data;
++ if ((err = ext3cow_htree_store_dirent(dir_file, 0, 0, de)) != 0)
++ goto errout;
++ count++;
++ }
++ if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
++ de = (struct ext3cow_dir_entry_2 *) frames[0].bh->b_data;
++ de = ext3cow_next_entry(de);
++ if ((err = ext3cow_htree_store_dirent(dir_file, 2, 0, de)) != 0)
++ goto errout;
++ count++;
++ }
++
++ while (1) {
++ block = dx_get_block(frame->at);
++ ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
++ start_hash, start_minor_hash);
++ if (ret < 0) {
++ err = ret;
++ goto errout;
++ }
++ count += ret;
++ hashval = ~0;
++ ret = ext3cow_htree_next_block(dir, HASH_NB_ALWAYS,
++ frame, frames, &hashval);
++ *next_hash = hashval;
++ if (ret < 0) {
++ err = ret;
++ goto errout;
++ }
++ /*
++ * Stop if: (a) there are no more entries, or
++ * (b) we have inserted at least one entry and the
++ * next hash value is not a continuation
++ */
++ if ((ret == 0) ||
++ (count && ((hashval & 1) == 0)))
++ break;
++ }
++ dx_release(frames);
++ dxtrace(printk("Fill tree: returned %d entries, next hash: %x\n",
++ count, *next_hash));
++ return count;
++errout:
++ dx_release(frames);
++ return (err);
++}
++
++
++/*
++ * Directory block splitting, compacting
++ */
++
++static int dx_make_map (struct ext3cow_dir_entry_2 *de, int size,
++ struct dx_hash_info *hinfo, struct dx_map_entry *map_tail)
++{
++ int count = 0;
++ char *base = (char *) de;
++ struct dx_hash_info h = *hinfo;
++
++ while ((char *) de < base + size)
++ {
++ if (de->name_len && de->inode) {
++ ext3cowfs_dirhash(de->name, de->name_len, &h);
++ map_tail--;
++ map_tail->hash = h.hash;
++ map_tail->offs = (u32) ((char *) de - base);
++ count++;
++ cond_resched();
++ }
++ /* XXX: do we need to check rec_len == 0 case? -Chris */
++ de = (struct ext3cow_dir_entry_2 *) ((char *) de + le16_to_cpu(de->rec_len));
++ }
++ return count;
++}
++
++static void dx_sort_map (struct dx_map_entry *map, unsigned count)
++{
++ struct dx_map_entry *p, *q, *top = map + count - 1;
++ int more;
++ /* Combsort until bubble sort doesn't suck */
++ while (count > 2)
++ {
++ count = count*10/13;
++ if (count - 9 < 2) /* 9, 10 -> 11 */
++ count = 11;
++ for (p = top, q = p - count; q >= map; p--, q--)
++ if (p->hash < q->hash)
++ swap(*p, *q);
++ }
++ /* Garden variety bubble sort */
++ do {
++ more = 0;
++ q = top;
++ while (q-- > map)
++ {
++ if (q[1].hash >= q[0].hash)
++ continue;
++ swap(*(q+1), *q);
++ more = 1;
++ }
++ } while(more);
++}
++
++static void dx_insert_block(struct dx_frame *frame, u32 hash, u32 block)
++{
++ struct dx_entry *entries = frame->entries;
++ struct dx_entry *old = frame->at, *new = old + 1;
++ int count = dx_get_count(entries);
++
++ assert(count < dx_get_limit(entries));
++ assert(old < entries + count);
++ memmove(new + 1, new, (char *)(entries + count) - (char *)(new));
++ dx_set_hash(new, hash);
++ dx_set_block(new, block);
++ dx_set_count(entries, count + 1);
++}
++#endif
++
++
++static void ext3cow_update_dx_flag(struct inode *inode)
++{
++ if (!EXT3COW_HAS_COMPAT_FEATURE(inode->i_sb,
++ EXT3COW_FEATURE_COMPAT_DIR_INDEX))
++ EXT3COW_I(inode)->i_flags &= ~EXT3COW_INDEX_FL;
++}
++
++/*
++ * NOTE! unlike strncmp, ext3cow_match returns 1 for success, 0 for failure.
++ *
++ * `len <= EXT3COW_NAME_LEN' is guaranteed by caller.
++ * `de != NULL' is guaranteed by caller.
++ */
++static inline int ext3cow_match (int len, const char * const name,
++ struct ext3cow_dir_entry_2 * de)
++{
++ if (len != de->name_len)
++ return 0;
++ if (!de->inode)
++ return 0;
++ return !memcmp(name, de->name, len);
++}
++
++/*
++ * Returns 0 if not found, -1 on failure, and 1 on success
++ */
++/* For versioning - this is the function used when looking for
++ * names. We now handle names which include the flux token,
++ * strip it off and continue looking -znjp */
++static inline int search_dirblock(struct buffer_head * bh,
++ struct inode *dir,
++ struct dentry *dentry,
++ unsigned long offset,
++ struct ext3cow_dir_entry_2 ** res_dir)
++{
++ struct ext3cow_dir_entry_2 * de;
++ char * dlimit, * flux = NULL;
++ int de_len;
++ char name[EXT3COW_NAME_LEN];
++ int namelen = dentry->d_name.len;
++ unsigned int epoch_number = EXT3COW_I_EPOCHNUMBER(dir);
++
++ /* Get the name for the dentry */
++ memcpy(name, dentry->d_name.name, namelen);
++ name[namelen] = '\0';
++
++ /* Check to see if the flux token is in the name */
++ flux = strrchr(dentry->d_name.name, EXT3COW_FLUX_TOKEN);
++ if(NULL != flux){
++ /* If we're here, the name we want is in the past. */
++ int new_namelen = strlen(dentry->d_name.name) - strlen(flux);
++ /* Get the epoch number */
++ epoch_number = simple_strtol(&flux[1], (char **)NULL, 10) - 1;
++ /* If there's a valid epoch number or if we're version listing
++ * we need the name seperately, otherwise the FLUX_TOKEN exists
++ * in the file name */
++ if(epoch_number + 1 == 0 && (strlen(flux) > 1)){
++ /* EXT3COW_FLUX_TOKEN exists in the file name */
++ epoch_number = EXT3COW_S_EPOCHNUMBER(dir->i_sb);
++ }else{
++ /* Grab the correct name and length */
++ memcpy(name, dentry->d_name.name, new_namelen);
++ name[new_namelen] = '\0';
++ namelen = strlen(name);
++ }
++ }
++
++
++ de = (struct ext3cow_dir_entry_2 *) bh->b_data;
++ dlimit = bh->b_data + dir->i_sb->s_blocksize;
++ while ((char *) de < dlimit) {
++ /* this code is executed quadratically often */
++ /* do minimal checking `by hand' */
++
++ /* Can't just return first entry of something;
++ * may exist twice if died and same name appears again. - znjp
++ */
++ if ((char *) de + namelen <= dlimit &&
++ ext3cow_match (namelen, name, de) &&
++ EXT3COW_IS_DIRENT_SCOPED(de, epoch_number)) {
++ /* found a match - just to be sure, do a full check */
++ if (!ext3cow_check_dir_entry("ext3cow_find_entry",
++ dir, de, bh, offset))
++ return -1;
++ *res_dir = de;
++ return 1;
++ }
++ /* prevent looping on a bad block */
++ de_len = le16_to_cpu(de->rec_len);
++ if (de_len <= 0)
++ return -1;
++ offset += de_len;
++ de = (struct ext3cow_dir_entry_2 *) ((char *) de + de_len);
++ }
++ return 0;
++}
++
++
++/*
++ * ext3cow_find_entry()
++ *
++ * finds an entry in the specified directory with the wanted name. It
++ * returns the cache buffer in which the entry was found, and the entry
++ * itself (as a parameter - res_dir). It does NOT read the inode of the
++ * entry - you'll have to do that yourself if you want to.
++ *
++ * The returned buffer_head has ->b_count elevated. The caller is expected
++ * to brelse() it when appropriate.
++ */
++static struct buffer_head * ext3cow_find_entry (struct dentry *dentry,
++ struct ext3cow_dir_entry_2 ** res_dir)
++{
++ struct super_block * sb;
++ struct buffer_head * bh_use[NAMEI_RA_SIZE];
++ struct buffer_head * bh, *ret = NULL;
++ unsigned long start, block, b;
++ int ra_max = 0; /* Number of bh's in the readahead
++ buffer, bh_use[] */
++ int ra_ptr = 0; /* Current index into readahead
++ buffer */
++ int num = 0;
++ int nblocks, i, err;
++ struct inode *dir = dentry->d_parent->d_inode;
++ int namelen;
++ const u8 *name;
++ unsigned blocksize;
++
++ *res_dir = NULL;
++ sb = dir->i_sb;
++ blocksize = sb->s_blocksize;
++ namelen = dentry->d_name.len;
++ name = dentry->d_name.name;
++ if (namelen > EXT3COW_NAME_LEN)
++ return NULL;
++#ifdef CONFIG_EXT3COW_INDEX
++ if (is_dx(dir)) {
++ bh = ext3cow_dx_find_entry(dentry, res_dir, &err);
++ /*
++ * On success, or if the error was file not found,
++ * return. Otherwise, fall back to doing a search the
++ * old fashioned way.
++ */
++ if (bh || (err != ERR_BAD_DX_DIR))
++ return bh;
++ dxtrace(printk("ext3cow_find_entry: dx failed, falling back\n"));
++ }
++#endif
++ nblocks = dir->i_size >> EXT3COW_BLOCK_SIZE_BITS(sb);
++ start = EXT3COW_I(dir)->i_dir_start_lookup;
++ if (start >= nblocks)
++ start = 0;
++ block = start;
++restart:
++ do {
++ /*
++ * We deal with the read-ahead logic here.
++ */
++ if (ra_ptr >= ra_max) {
++ /* Refill the readahead buffer */
++ ra_ptr = 0;
++ b = block;
++ for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
++ /*
++ * Terminate if we reach the end of the
++ * directory and must wrap, or if our
++ * search has finished at this block.
++ */
++ if (b >= nblocks || (num && block == start)) {
++ bh_use[ra_max] = NULL;
++ break;
++ }
++ num++;
++ bh = ext3cow_getblk(NULL, dir, b++, 0, &err);
++ bh_use[ra_max] = bh;
++ if (bh)
++ ll_rw_block(READ_META, 1, &bh);
++ }
++ }
++ if ((bh = bh_use[ra_ptr++]) == NULL)
++ goto next;
++ wait_on_buffer(bh);
++ if (!buffer_uptodate(bh)) {
++ /* read error, skip block & hope for the best */
++ ext3cow_error(sb, __FUNCTION__, "reading directory #%lu "
++ "offset %lu", dir->i_ino, block);
++ brelse(bh);
++ goto next;
++ }
++ i = search_dirblock(bh, dir, dentry,
++ block << EXT3COW_BLOCK_SIZE_BITS(sb), res_dir);
++ if (i == 1) {
++ EXT3COW_I(dir)->i_dir_start_lookup = block;
++ ret = bh;
++ goto cleanup_and_exit;
++ } else {
++ brelse(bh);
++ if (i < 0)
++ goto cleanup_and_exit;
++ }
++ next:
++ if (++block >= nblocks)
++ block = 0;
++ } while (block != start);
++
++ /*
++ * If the directory has grown while we were searching, then
++ * search the last part of the directory before giving up.
++ */
++ block = nblocks;
++ nblocks = dir->i_size >> EXT3COW_BLOCK_SIZE_BITS(sb);
++ if (block < nblocks) {
++ start = 0;
++ goto restart;
++ }
++
++cleanup_and_exit:
++ /* Clean up the read-ahead blocks */
++ for (; ra_ptr < ra_max; ra_ptr++)
++ brelse (bh_use[ra_ptr]);
++ return ret;
++}
++
++#ifdef CONFIG_EXT3COW_INDEX
++static struct buffer_head * ext3cow_dx_find_entry(struct dentry *dentry,
++ struct ext3cow_dir_entry_2 **res_dir, int *err)
++{
++ struct super_block * sb;
++ struct dx_hash_info hinfo;
++ u32 hash;
++ struct dx_frame frames[2], *frame;
++ struct ext3cow_dir_entry_2 *de, *top;
++ struct buffer_head *bh;
++ unsigned long block;
++ int retval;
++ int namelen = dentry->d_name.len;
++ const u8 *name = dentry->d_name.name;
++ struct inode *dir = dentry->d_parent->d_inode;
++
++ sb = dir->i_sb;
++ /* NFS may look up ".." - look at dx_root directory block */
++ if (namelen > 2 || name[0] != '.'||(name[1] != '.' && name[1] != '\0')){
++ if (!(frame = dx_probe(dentry, NULL, &hinfo, frames, err)))
++ return NULL;
++ } else {
++ frame = frames;
++ frame->bh = NULL; /* for dx_release() */
++ frame->at = (struct dx_entry *)frames; /* hack for zero entry*/
++ dx_set_block(frame->at, 0); /* dx_root block is 0 */
++ }
++ hash = hinfo.hash;
++ do {
++ block = dx_get_block(frame->at);
++ if (!(bh = ext3cow_bread (NULL,dir, block, 0, err)))
++ goto errout;
++ de = (struct ext3cow_dir_entry_2 *) bh->b_data;
++ top = (struct ext3cow_dir_entry_2 *) ((char *) de + sb->s_blocksize -
++ EXT3COW_DIR_REC_LEN(0));
++ for (; de < top; de = ext3cow_next_entry(de))
++ if (ext3cow_match (namelen, name, de)) {
++ if (!ext3cow_check_dir_entry("ext3cow_find_entry",
++ dir, de, bh,
++ (block<b_data))) {
++ brelse (bh);
++ goto errout;
++ }
++ *res_dir = de;
++ dx_release (frames);
++ return bh;
++ }
++ brelse (bh);
++ /* Check to see if we should continue to search */
++ retval = ext3cow_htree_next_block(dir, hash, frame,
++ frames, NULL);
++ if (retval < 0) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "error reading index page in directory #%lu",
++ dir->i_ino);
++ *err = retval;
++ goto errout;
++ }
++ } while (retval == 1);
++
++ *err = -ENOENT;
++errout:
++ dxtrace(printk("%s not found\n", name));
++ dx_release (frames);
++ return NULL;
++}
++#endif
++
++/* ext3cow_lookup: One the key functions of this versioning file sytem,
++ * allowing people to return to the past.
++ *
++ * Two policies for inode chains:
++ * 1) If it's the head of the list, it's the most current inode
++ * and always changable. The inode number is static.
++ * 2) If it's any inode in the chain that's not the head,
++ * than it's an inode in the past and unchangeable. The inode
++ * number may change.
++ */
++static struct dentry *ext3cow_lookup(struct inode * dir, struct dentry *dentry,
++ struct nameidata *nd)
++{
++ struct inode * inode = NULL;
++ struct ext3cow_dir_entry_2 * de = NULL;
++ struct buffer_head * bh = NULL;
++ unsigned int epoch_number = 0;
++ char * flux = NULL;
++
++ if (dentry->d_name.len > EXT3COW_NAME_LEN)
++ return ERR_PTR(-ENAMETOOLONG);
++
++ /* Find the epoch number to scope with -znjp
++ * if the parent is unchangeable, so is the inode
++ */
++ if(EXT3COW_IS_UNCHANGEABLE(dir))
++ epoch_number = EXT3COW_I_EPOCHNUMBER(dir);
++ else
++ epoch_number = EXT3COW_S_EPOCHNUMBER(dir->i_sb);
++
++ bh = ext3cow_find_entry(dentry, &de);
++ if (bh) {
++ unsigned long ino = le32_to_cpu(de->inode);
++ brelse (bh);
++ if (!ext3cow_valid_inum(dir->i_sb, ino)) {
++ ext3cow_error(dir->i_sb, "ext3cow_lookup",
++ "bad inode number: %lu", ino);
++ inode = NULL;
++ } else
++ inode = iget(dir->i_sb, ino);
++
++ if (!inode)
++ return ERR_PTR(-EACCES);
++
++ /* Is this a version listing ? */
++ if ((char)dentry->d_name.name[dentry->d_name.len - 1] ==
++ EXT3COW_FLUX_TOKEN) {
++ /* prevent going round in circles */
++ if (dentry->d_parent &&
++ dentry->d_parent->d_name.name[dentry->d_parent->d_name.len - 1] ==
++ EXT3COW_FLUX_TOKEN) {
++ return NULL;
++ }
++ /* we fake a directory using the directory inode instead of
++ * the file one and subsequently force a call to ext3cow_readdir */
++ iput(inode);
++ inode = ext3cow_fake_inode(dir, EXT3COW_S_EPOCHNUMBER(dir->i_sb));
++ EXT3COW_I(inode)->i_next_inode = EXT3COW_I(dir)->i_next_inode;
++ d_splice_alias(inode, dentry);
++
++ return NULL;
++ }
++
++ /* Is the user time-shifting to the past? */
++ flux = strrchr(dentry->d_name.name, EXT3COW_FLUX_TOKEN);
++ if(NULL != flux){
++
++ if(strnicmp(&flux[1], "onehour", 8) == 0){
++ epoch_number = get_seconds() - ONEHOUR;
++ printk(KERN_INFO "ONEHOUR!\n");
++ }else if(strnicmp(&flux[1], "yesterday", 10) == 0 ||
++ strnicmp(&flux[1], "oneday", 7) == 0){
++ epoch_number = get_seconds() - YESTERDAY;
++ }else if(strnicmp(&flux[1], "oneweek", 8) == 0){
++ epoch_number = get_seconds() - ONEWEEK;
++ }else if(strnicmp(&flux[1], "onemonth", 9) == 0){
++ epoch_number = get_seconds() - ONEMONTH;
++ }else if(strnicmp(&flux[1], "oneyear", 8) == 0){
++ epoch_number = get_seconds() - ONEYEAR;
++ }else
++ epoch_number = simple_strtol(&flux[1], (char **)NULL, 10) - 1;
++
++ /* No future epochs */
++ if(epoch_number + 1 > EXT3COW_S_EPOCHNUMBER(dir->i_sb))
++ return ERR_PTR(-ENOENT);
++
++ /* Move to present
++ if(epoch_number + 1 == 0)
++ epoch_number = EXT3COW_S_EPOCHNUMBER(dir->i_sb);
++ */
++ }
++
++ /* Find correct inode in chain */
++ while(EXT3COW_I_EPOCHNUMBER(inode) > epoch_number){
++
++ printk(KERN_INFO "Looking for %u with epoch %u\n", epoch_number,
++ EXT3COW_I_EPOCHNUMBER(inode));
++
++ ino = EXT3COW_I(inode)->i_next_inode;
++ if(ino == 0){
++ ext3cow_warning(dir->i_sb, "ext3cow_lookup",
++ "Next inode is 0 in lookup.");
++ iput(inode);
++ return ERR_PTR(-ENOENT);
++ }
++ iput(inode); /* for correct usage count (i_count) */
++ inode = iget(dir->i_sb, ino);
++
++ if (!inode){
++ ext3cow_warning(dir->i_sb, "ext3cow_lookup",
++ "Could not access inode number %lu",
++ ino);
++ return ERR_PTR(-EACCES);
++ }
++ }
++
++ /* If we're in the past, fake the inode for scoping and "unchangability" */
++ if(flux || (epoch_number != EXT3COW_S_EPOCHNUMBER(dir->i_sb))){
++ printk(KERN_INFO "Faking %s\n", dentry->d_name.name);
++ inode = ext3cow_fake_inode(inode, epoch_number);
++ }
++
++ if (!inode)
++ return ERR_PTR(-EACCES);
++ }
++ return d_splice_alias(inode, dentry);
++}
++
++
++struct dentry *ext3cow_get_parent(struct dentry *child)
++{
++ unsigned long ino;
++ struct dentry *parent;
++ struct inode *inode;
++ struct dentry dotdot;
++ struct ext3cow_dir_entry_2 * de;
++ struct buffer_head *bh;
++
++ dotdot.d_name.name = "..";
++ dotdot.d_name.len = 2;
++ dotdot.d_parent = child; /* confusing, isn't it! */
++
++ bh = ext3cow_find_entry(&dotdot, &de);
++ inode = NULL;
++ if (!bh)
++ return ERR_PTR(-ENOENT);
++ ino = le32_to_cpu(de->inode);
++ brelse(bh);
++
++ if (!ext3cow_valid_inum(child->d_inode->i_sb, ino)) {
++ ext3cow_error(child->d_inode->i_sb, "ext3cow_get_parent",
++ "bad inode number: %lu", ino);
++ inode = NULL;
++ } else
++ inode = iget(child->d_inode->i_sb, ino);
++
++ if (!inode)
++ return ERR_PTR(-EACCES);
++
++ parent = d_alloc_anon(inode);
++ if (!parent) {
++ iput(inode);
++ parent = ERR_PTR(-ENOMEM);
++ }
++ return parent;
++}
++
++#define S_SHIFT 12
++static unsigned char ext3cow_type_by_mode[S_IFMT >> S_SHIFT] = {
++ [S_IFREG >> S_SHIFT] = EXT3COW_FT_REG_FILE,
++ [S_IFDIR >> S_SHIFT] = EXT3COW_FT_DIR,
++ [S_IFCHR >> S_SHIFT] = EXT3COW_FT_CHRDEV,
++ [S_IFBLK >> S_SHIFT] = EXT3COW_FT_BLKDEV,
++ [S_IFIFO >> S_SHIFT] = EXT3COW_FT_FIFO,
++ [S_IFSOCK >> S_SHIFT] = EXT3COW_FT_SOCK,
++ [S_IFLNK >> S_SHIFT] = EXT3COW_FT_SYMLINK,
++};
++
++static inline void ext3cow_set_de_type(struct super_block *sb,
++ struct ext3cow_dir_entry_2 *de,
++ umode_t mode) {
++ if (EXT3COW_HAS_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_FILETYPE))
++ de->file_type = ext3cow_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
++}
++
++#ifdef CONFIG_EXT3COW_INDEX
++static struct ext3cow_dir_entry_2 *
++dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count)
++{
++ unsigned rec_len = 0;
++
++ while (count--) {
++ struct ext3cow_dir_entry_2 *de = (struct ext3cow_dir_entry_2 *) (from + map->offs);
++ rec_len = EXT3COW_DIR_REC_LEN(de->name_len);
++ memcpy (to, de, rec_len);
++ ((struct ext3cow_dir_entry_2 *) to)->rec_len =
++ cpu_to_le16(rec_len);
++ de->inode = 0;
++ map++;
++ to += rec_len;
++ }
++ return (struct ext3cow_dir_entry_2 *) (to - rec_len);
++}
++
++static struct ext3cow_dir_entry_2* dx_pack_dirents(char *base, int size)
++{
++ struct ext3cow_dir_entry_2 *next, *to, *prev, *de = (struct ext3cow_dir_entry_2 *) base;
++ unsigned rec_len = 0;
++
++ prev = to = de;
++ while ((char*)de < base + size) {
++ next = (struct ext3cow_dir_entry_2 *) ((char *) de +
++ le16_to_cpu(de->rec_len));
++ if (de->inode && de->name_len) {
++ rec_len = EXT3COW_DIR_REC_LEN(de->name_len);
++ if (de > to)
++ memmove(to, de, rec_len);
++ to->rec_len = cpu_to_le16(rec_len);
++ prev = to;
++ to = (struct ext3cow_dir_entry_2 *) (((char *) to) + rec_len);
++ }
++ de = next;
++ }
++ return prev;
++}
++
++static struct ext3cow_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
++ struct buffer_head **bh,struct dx_frame *frame,
++ struct dx_hash_info *hinfo, int *error)
++{
++ unsigned blocksize = dir->i_sb->s_blocksize;
++ unsigned count, continued;
++ struct buffer_head *bh2;
++ u32 newblock;
++ u32 hash2;
++ struct dx_map_entry *map;
++ char *data1 = (*bh)->b_data, *data2;
++ unsigned split;
++ struct ext3cow_dir_entry_2 *de = NULL, *de2;
++ int err;
++
++ bh2 = ext3cow_append (handle, dir, &newblock, error);
++ if (!(bh2)) {
++ brelse(*bh);
++ *bh = NULL;
++ goto errout;
++ }
++
++ BUFFER_TRACE(*bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, *bh);
++ if (err) {
++ journal_error:
++ brelse(*bh);
++ brelse(bh2);
++ *bh = NULL;
++ ext3cow_std_error(dir->i_sb, err);
++ goto errout;
++ }
++ BUFFER_TRACE(frame->bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, frame->bh);
++ if (err)
++ goto journal_error;
++
++ data2 = bh2->b_data;
++
++ /* create map in the end of data2 block */
++ map = (struct dx_map_entry *) (data2 + blocksize);
++ count = dx_make_map ((struct ext3cow_dir_entry_2 *) data1,
++ blocksize, hinfo, map);
++ map -= count;
++ split = count/2; // need to adjust to actual middle
++ dx_sort_map (map, count);
++ hash2 = map[split].hash;
++ continued = hash2 == map[split - 1].hash;
++ dxtrace(printk("Split block %i at %x, %i/%i\n",
++ dx_get_block(frame->at), hash2, split, count-split));
++
++ /* Fancy dance to stay within two buffers */
++ de2 = dx_move_dirents(data1, data2, map + split, count - split);
++ de = dx_pack_dirents(data1,blocksize);
++ de->rec_len = cpu_to_le16(data1 + blocksize - (char *) de);
++ de2->rec_len = cpu_to_le16(data2 + blocksize - (char *) de2);
++ dxtrace(dx_show_leaf (hinfo, (struct ext3cow_dir_entry_2 *) data1, blocksize, 1));
++ dxtrace(dx_show_leaf (hinfo, (struct ext3cow_dir_entry_2 *) data2, blocksize, 1));
++
++ /* Which block gets the new entry? */
++ if (hinfo->hash >= hash2)
++ {
++ swap(*bh, bh2);
++ de = de2;
++ }
++ dx_insert_block (frame, hash2 + continued, newblock);
++ err = ext3cow_journal_dirty_metadata (handle, bh2);
++ if (err)
++ goto journal_error;
++ err = ext3cow_journal_dirty_metadata (handle, frame->bh);
++ if (err)
++ goto journal_error;
++ brelse (bh2);
++ dxtrace(dx_show_index ("frame", frame->entries));
++errout:
++ return de;
++}
++#endif
++
++
++/*
++ * Add a new entry into a directory (leaf) block. If de is non-NULL,
++ * it points to a directory entry which is guaranteed to be large
++ * enough for new directory entry. If de is NULL, then
++ * add_dirent_to_buf will attempt search the directory block for
++ * space. It will return -ENOSPC if no space is available, and -EIO
++ * and -EEXIST if directory entry already exists.
++ *
++ * NOTE! bh is NOT released in the case where ENOSPC is returned. In
++ * all other cases bh is released.
++ */
++static int add_dirent_to_buf(handle_t *handle, struct dentry *dentry,
++ struct inode *inode, struct ext3cow_dir_entry_2 *de,
++ struct buffer_head * bh)
++{
++ struct inode *dir = dentry->d_parent->d_inode;
++ const char *name = dentry->d_name.name;
++ int namelen = dentry->d_name.len;
++ unsigned long offset = 0;
++ unsigned short reclen;
++ int nlen, rlen, err;
++ char *top;
++
++ reclen = EXT3COW_DIR_REC_LEN(namelen);
++ if (!de) {
++ de = (struct ext3cow_dir_entry_2 *)bh->b_data;
++ top = bh->b_data + dir->i_sb->s_blocksize - reclen;
++ while ((char *) de <= top) {
++ if (!ext3cow_check_dir_entry("ext3cow_add_entry", dir, de,
++ bh, offset)) {
++ brelse (bh);
++ ext3cow_reclaim_dup_inode(dentry->d_parent->d_parent->d_inode, dir);
++ return -EIO;
++ }
++ /* If name exists and it's still alive, no add. But if it's a new
++ * name in this scope, ok to add. -znjp */
++ if (ext3cow_match (namelen, name, de) && EXT3COW_IS_DIRENT_ALIVE(de)) {
++ brelse (bh);
++ return -EEXIST;
++ }
++ nlen = EXT3COW_DIR_REC_LEN(de->name_len);
++ rlen = le16_to_cpu(de->rec_len);
++ if ((de->inode? rlen - nlen: rlen) >= reclen)
++ break;
++ de = (struct ext3cow_dir_entry_2 *)((char *)de + rlen);
++ offset += rlen;
++ }
++ if ((char *) de > top)
++ return -ENOSPC;
++ }
++ BUFFER_TRACE(bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, bh);
++ if (err) {
++ ext3cow_std_error(dir->i_sb, err);
++ brelse(bh);
++ return err;
++ }
++
++ /* By now the buffer is marked for journaling */
++ nlen = EXT3COW_DIR_REC_LEN(de->name_len);
++ rlen = le16_to_cpu(de->rec_len);
++ if (de->inode) {
++ struct ext3cow_dir_entry_2 *de1 = (struct ext3cow_dir_entry_2 *)((char *)de + nlen);
++ de1->rec_len = cpu_to_le16(rlen - nlen);
++ de->rec_len = cpu_to_le16(nlen);
++ de = de1;
++ }
++ de->file_type = EXT3COW_FT_UNKNOWN;
++ if (inode) {
++ de->inode = cpu_to_le32(inode->i_ino);
++ ext3cow_set_de_type(dir->i_sb, de, inode->i_mode);
++ } else
++ de->inode = 0;
++ /* For versioning -znjp */
++ de->birth_epoch = cpu_to_le32(EXT3COW_S_EPOCHNUMBER(dir->i_sb));
++ de->death_epoch = cpu_to_le32(EXT3COW_DIRENT_ALIVE);
++ de->name_len = namelen;
++ memcpy (de->name, name, namelen);
++ /*
++ * XXX shouldn't update any times until successful
++ * completion of syscall, but too many callers depend
++ * on this.
++ *
++ * XXX similarly, too many callers depend on
++ * ext3cow_new_inode() setting the times, but error
++ * recovery deletes the inode, so the worst that can
++ * happen is that the times are slightly out of date
++ * and/or different from the directory change time.
++ */
++ dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
++ ext3cow_update_dx_flag(dir);
++ dir->i_version++;
++ ext3cow_mark_inode_dirty(handle, dir);
++ BUFFER_TRACE(bh, "call ext3cow_journal_dirty_metadata");
++ err = ext3cow_journal_dirty_metadata(handle, bh);
++ if (err)
++ ext3cow_std_error(dir->i_sb, err);
++ brelse(bh);
++ return 0;
++}
++
++#ifdef CONFIG_EXT3COW_INDEX
++/*
++ * This converts a one block unindexed directory to a 3 block indexed
++ * directory, and adds the dentry to the indexed directory.
++ */
++static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
++ struct inode *inode, struct buffer_head *bh)
++{
++ struct inode *dir = dentry->d_parent->d_inode;
++ const char *name = dentry->d_name.name;
++ int namelen = dentry->d_name.len;
++ struct buffer_head *bh2;
++ struct dx_root *root;
++ struct dx_frame frames[2], *frame;
++ struct dx_entry *entries;
++ struct ext3cow_dir_entry_2 *de, *de2;
++ char *data1, *top;
++ unsigned len;
++ int retval;
++ unsigned blocksize;
++ struct dx_hash_info hinfo;
++ u32 block;
++ struct fake_dirent *fde;
++
++ blocksize = dir->i_sb->s_blocksize;
++ dxtrace(printk("Creating index\n"));
++ retval = ext3cow_journal_get_write_access(handle, bh);
++ if (retval) {
++ ext3cow_std_error(dir->i_sb, retval);
++ brelse(bh);
++ return retval;
++ }
++ root = (struct dx_root *) bh->b_data;
++
++ bh2 = ext3cow_append (handle, dir, &block, &retval);
++ if (!(bh2)) {
++ brelse(bh);
++ return retval;
++ }
++ EXT3COW_I(dir)->i_flags |= EXT3COW_INDEX_FL;
++ data1 = bh2->b_data;
++
++ /* The 0th block becomes the root, move the dirents out */
++ fde = &root->dotdot;
++ de = (struct ext3cow_dir_entry_2 *)((char *)fde + le16_to_cpu(fde->rec_len));
++ len = ((char *) root) + blocksize - (char *) de;
++ memcpy (data1, de, len);
++ de = (struct ext3cow_dir_entry_2 *) data1;
++ top = data1 + len;
++ while ((char *)(de2=(void*)de+le16_to_cpu(de->rec_len)) < top)
++ de = de2;
++ de->rec_len = cpu_to_le16(data1 + blocksize - (char *) de);
++ /* Initialize the root; the dot dirents already exist */
++ de = (struct ext3cow_dir_entry_2 *) (&root->dotdot);
++ de->rec_len = cpu_to_le16(blocksize - EXT3COW_DIR_REC_LEN(2));
++ memset (&root->info, 0, sizeof(root->info));
++ root->info.info_length = sizeof(root->info);
++ root->info.hash_version = EXT3COW_SB(dir->i_sb)->s_def_hash_version;
++ entries = root->entries;
++ dx_set_block (entries, 1);
++ dx_set_count (entries, 1);
++ dx_set_limit (entries, dx_root_limit(dir, sizeof(root->info)));
++
++ /* Initialize as for dx_probe */
++ hinfo.hash_version = root->info.hash_version;
++ hinfo.seed = EXT3COW_SB(dir->i_sb)->s_hash_seed;
++ ext3cowfs_dirhash(name, namelen, &hinfo);
++ frame = frames;
++ frame->entries = entries;
++ frame->at = entries;
++ frame->bh = bh;
++ bh = bh2;
++ de = do_split(handle,dir, &bh, frame, &hinfo, &retval);
++ dx_release (frames);
++ if (!(de))
++ return retval;
++
++ return add_dirent_to_buf(handle, dentry, inode, de, bh);
++}
++#endif
++
++/*
++ * ext3cow_add_entry()
++ *
++ * adds a file entry to the specified directory, using the same
++ * semantics as ext3cow_find_entry(). It returns NULL if it failed.
++ *
++ * NOTE!! The inode part of 'de' is left at 0 - which means you
++ * may not sleep between calling this and putting something into
++ * the entry, as someone else might have used it while you slept.
++ */
++static int ext3cow_add_entry (handle_t *handle, struct dentry *dentry,
++ struct inode *inode)
++{
++ struct inode *dir = dentry->d_parent->d_inode;
++ unsigned long offset;
++ struct buffer_head * bh;
++ struct ext3cow_dir_entry_2 *de;
++ struct super_block * sb;
++ int retval;
++#ifdef CONFIG_EXT3COW_INDEX
++ int dx_fallback=0;
++#endif
++ unsigned blocksize;
++ u32 block, blocks;
++
++ sb = dir->i_sb;
++ blocksize = sb->s_blocksize;
++ if (!dentry->d_name.len)
++ return -EINVAL;
++ /* No additions in the past -znjp */
++ if(is_unchangeable(dir, dentry))
++ return -EROFS;
++
++ if(EXT3COW_S_EPOCHNUMBER(sb) > EXT3COW_I_EPOCHNUMBER(dir)){
++ if(ext3cow_dup_inode(dentry->d_parent->d_parent->d_inode, dir))
++ //if(ext3cow_dup_inode(NULL, dir))
++ return -1;
++ }
++
++#ifdef CONFIG_EXT3COW_INDEX
++ if (is_dx(dir)) {
++ retval = ext3cow_dx_add_entry(handle, dentry, inode);
++ if (!retval || (retval != ERR_BAD_DX_DIR)){
++ ext3cow_reclaim_dup_inode(dentry->d_parent->d_parent->d_inode, dir);
++ return retval;
++ }
++ EXT3COW_I(dir)->i_flags &= ~EXT3COW_INDEX_FL;
++ dx_fallback++;
++ ext3cow_mark_inode_dirty(handle, dir);
++ }
++#endif
++ blocks = dir->i_size >> sb->s_blocksize_bits;
++ for (block = 0, offset = 0; block < blocks; block++) {
++ bh = ext3cow_bread(handle, dir, block, 0, &retval);
++ if(!bh){
++ ext3cow_reclaim_dup_inode(dentry->d_parent->d_parent->d_inode, dir);
++ return retval;
++ }
++ retval = add_dirent_to_buf(handle, dentry, inode, NULL, bh);
++ if (retval != -ENOSPC)
++ return retval;
++
++#ifdef CONFIG_EXT3COW_INDEX
++ if (blocks == 1 && !dx_fallback &&
++ EXT3COW_HAS_COMPAT_FEATURE(sb, EXT3COW_FEATURE_COMPAT_DIR_INDEX))
++ return make_indexed_dir(handle, dentry, inode, bh);
++#endif
++ brelse(bh);
++ }
++
++ bh = ext3cow_append(handle, dir, &block, &retval);
++ if (!bh){
++ ext3cow_reclaim_dup_inode(dentry->d_parent->d_parent->d_inode, dir);
++ return retval;
++ }
++ de = (struct ext3cow_dir_entry_2 *) bh->b_data;
++ de->inode = 0;
++ de->rec_len = cpu_to_le16(blocksize);
++ return add_dirent_to_buf(handle, dentry, inode, de, bh);
++}
++
++#ifdef CONFIG_EXT3COW_INDEX
++/*
++ * Returns 0 for success, or a negative error value
++ */
++static int ext3cow_dx_add_entry(handle_t *handle, struct dentry *dentry,
++ struct inode *inode)
++{
++ struct dx_frame frames[2], *frame;
++ struct dx_entry *entries, *at;
++ struct dx_hash_info hinfo;
++ struct buffer_head * bh;
++ struct inode *dir = dentry->d_parent->d_inode;
++ struct super_block * sb = dir->i_sb;
++ struct ext3cow_dir_entry_2 *de;
++ int err;
++
++ frame = dx_probe(dentry, NULL, &hinfo, frames, &err);
++ if (!frame)
++ return err;
++ entries = frame->entries;
++ at = frame->at;
++
++ if (!(bh = ext3cow_bread(handle,dir, dx_get_block(frame->at), 0, &err)))
++ goto cleanup;
++
++ BUFFER_TRACE(bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, bh);
++ if (err)
++ goto journal_error;
++
++ err = add_dirent_to_buf(handle, dentry, inode, NULL, bh);
++ if (err != -ENOSPC) {
++ bh = NULL;
++ goto cleanup;
++ }
++
++ /* Block full, should compress but for now just split */
++ dxtrace(printk("using %u of %u node entries\n",
++ dx_get_count(entries), dx_get_limit(entries)));
++ /* Need to split index? */
++ if (dx_get_count(entries) == dx_get_limit(entries)) {
++ u32 newblock;
++ unsigned icount = dx_get_count(entries);
++ int levels = frame - frames;
++ struct dx_entry *entries2;
++ struct dx_node *node2;
++ struct buffer_head *bh2;
++
++ if (levels && (dx_get_count(frames->entries) ==
++ dx_get_limit(frames->entries))) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "Directory index full!");
++ err = -ENOSPC;
++ goto cleanup;
++ }
++ bh2 = ext3cow_append (handle, dir, &newblock, &err);
++ if (!(bh2))
++ goto cleanup;
++ node2 = (struct dx_node *)(bh2->b_data);
++ entries2 = node2->entries;
++ node2->fake.rec_len = cpu_to_le16(sb->s_blocksize);
++ node2->fake.inode = 0;
++ BUFFER_TRACE(frame->bh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, frame->bh);
++ if (err)
++ goto journal_error;
++ if (levels) {
++ unsigned icount1 = icount/2, icount2 = icount - icount1;
++ unsigned hash2 = dx_get_hash(entries + icount1);
++ dxtrace(printk("Split index %i/%i\n", icount1, icount2));
++
++ BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
++ err = ext3cow_journal_get_write_access(handle,
++ frames[0].bh);
++ if (err)
++ goto journal_error;
++
++ memcpy ((char *) entries2, (char *) (entries + icount1),
++ icount2 * sizeof(struct dx_entry));
++ dx_set_count (entries, icount1);
++ dx_set_count (entries2, icount2);
++ dx_set_limit (entries2, dx_node_limit(dir));
++
++ /* Which index block gets the new entry? */
++ if (at - entries >= icount1) {
++ frame->at = at = at - entries - icount1 + entries2;
++ frame->entries = entries = entries2;
++ swap(frame->bh, bh2);
++ }
++ dx_insert_block (frames + 0, hash2, newblock);
++ dxtrace(dx_show_index ("node", frames[1].entries));
++ dxtrace(dx_show_index ("node",
++ ((struct dx_node *) bh2->b_data)->entries));
++ err = ext3cow_journal_dirty_metadata(handle, bh2);
++ if (err)
++ goto journal_error;
++ brelse (bh2);
++ } else {
++ dxtrace(printk("Creating second level index...\n"));
++ memcpy((char *) entries2, (char *) entries,
++ icount * sizeof(struct dx_entry));
++ dx_set_limit(entries2, dx_node_limit(dir));
++
++ /* Set up root */
++ dx_set_count(entries, 1);
++ dx_set_block(entries + 0, newblock);
++ ((struct dx_root *) frames[0].bh->b_data)->info.indirect_levels = 1;
++
++ /* Add new access path frame */
++ frame = frames + 1;
++ frame->at = at = at - entries + entries2;
++ frame->entries = entries = entries2;
++ frame->bh = bh2;
++ err = ext3cow_journal_get_write_access(handle,
++ frame->bh);
++ if (err)
++ goto journal_error;
++ }
++ ext3cow_journal_dirty_metadata(handle, frames[0].bh);
++ }
++ de = do_split(handle, dir, &bh, frame, &hinfo, &err);
++ if (!de)
++ goto cleanup;
++ err = add_dirent_to_buf(handle, dentry, inode, de, bh);
++ bh = NULL;
++ goto cleanup;
++
++journal_error:
++ ext3cow_std_error(dir->i_sb, err);
++cleanup:
++ if (bh)
++ brelse(bh);
++ dx_release(frames);
++ return err;
++}
++#endif
++
++/*
++ * ext3cow_delete_entry deletes a directory entry by merging it with the
++ * previous entry
++ */
++static int ext3cow_delete_entry (handle_t *handle,
++ struct inode * dir,
++ struct ext3cow_dir_entry_2 * de_del,
++ struct buffer_head * bh,
++ struct dentry *dentry)
++{
++ struct ext3cow_dir_entry_2 * de, * pde;
++ int i;
++
++ i = 0;
++ pde = NULL;
++ de = (struct ext3cow_dir_entry_2 *) bh->b_data;
++ while (i < bh->b_size) {
++ if (!ext3cow_check_dir_entry("ext3cow_delete_entry", dir, de, bh, i))
++ return -EIO;
++ if (de == de_del) {
++ /* Can't delete an already dead entry - znjp */
++ if(!EXT3COW_IS_DIRENT_ALIVE(de))
++ return 0;
++
++ if(EXT3COW_S_EPOCHNUMBER(dir->i_sb) > EXT3COW_I_EPOCHNUMBER(dir)){
++ if(ext3cow_dup_inode(dentry->d_parent->d_parent->d_inode, dir))
++ //if(ext3cow_dup_inode(NULL, dir))
++ return -1;
++ }
++
++ BUFFER_TRACE(bh, "get_write_access");
++ ext3cow_journal_get_write_access(handle, bh);
++ /* There used to be code here to adjust the rec_len
++ * but since names really never go away, the code was deleted
++ if (pde)
++ pde->rec_len =
++ cpu_to_le16(le16_to_cpu(pde->rec_len) +
++ le16_to_cpu(de->rec_len));
++ else
++ de->inode = 0;
++ */
++ /* Mark it dead - znjp */
++ de->death_epoch = cpu_to_le32(EXT3COW_I_EPOCHNUMBER(dir));
++ dir->i_version++;
++ BUFFER_TRACE(bh, "call ext3cow_journal_dirty_metadata");
++ ext3cow_journal_dirty_metadata(handle, bh);
++ return 0;
++ }
++ i += le16_to_cpu(de->rec_len);
++ pde = de;
++ de = (struct ext3cow_dir_entry_2 *)
++ ((char *) de + le16_to_cpu(de->rec_len));
++ }
++ return -ENOENT;
++}
++
++/*
++ * ext3cow_mark_inode_dirty is somewhat expensive, so unlike ext2 we
++ * do not perform it in these functions. We perform it at the call site,
++ * if it is needed.
++ */
++static inline void ext3cow_inc_count(handle_t *handle, struct inode *inode)
++{
++ inc_nlink(inode);
++}
++
++static inline void ext3cow_dec_count(handle_t *handle, struct inode *inode)
++{
++ drop_nlink(inode);
++}
++
++static int ext3cow_add_nondir(handle_t *handle,
++ struct dentry *dentry, struct inode *inode)
++{
++ int err = ext3cow_add_entry(handle, dentry, inode);
++ if (!err) {
++ ext3cow_mark_inode_dirty(handle, inode);
++ d_instantiate(dentry, inode);
++ return 0;
++ }
++ ext3cow_dec_count(handle, inode);
++ iput(inode);
++ return err;
++}
++
++/*
++ * By the time this is called, we already have created
++ * the directory cache entry for the new file, but it
++ * is so far negative - it has no inode.
++ *
++ * If the create succeeds, we fill in the inode information
++ * with d_instantiate().
++ */
++static int ext3cow_create (struct inode * dir, struct dentry * dentry, int mode,
++ struct nameidata *nd)
++{
++ handle_t *handle;
++ struct inode * inode;
++ int err, retries = 0;
++
++ /* Can't create in the past -znjp */
++ if(is_unchangeable(dir, dentry))
++ return -EROFS;
++
++retry:
++ handle = ext3cow_journal_start(dir, EXT3COW_DATA_TRANS_BLOCKS(dir->i_sb) +
++ EXT3COW_INDEX_EXTRA_TRANS_BLOCKS + 3 +
++ 2*EXT3COW_QUOTA_INIT_BLOCKS(dir->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ if (IS_DIRSYNC(dir))
++ handle->h_sync = 1;
++
++ inode = ext3cow_new_inode (handle, dir, mode);
++ err = PTR_ERR(inode);
++ if (!IS_ERR(inode)) {
++ inode->i_op = &ext3cow_file_inode_operations;
++ inode->i_fop = &ext3cow_file_operations;
++ ext3cow_set_aops(inode);
++ err = ext3cow_add_nondir(handle, dentry, inode);
++ }
++ ext3cow_journal_stop(handle);
++ if (err == -ENOSPC && ext3cow_should_retry_alloc(dir->i_sb, &retries))
++ goto retry;
++ return err;
++}
++
++static int ext3cow_mknod (struct inode * dir, struct dentry *dentry,
++ int mode, dev_t rdev)
++{
++ handle_t *handle;
++ struct inode *inode;
++ int err, retries = 0;
++
++ if (!new_valid_dev(rdev))
++ return -EINVAL;
++
++retry:
++ handle = ext3cow_journal_start(dir, EXT3COW_DATA_TRANS_BLOCKS(dir->i_sb) +
++ EXT3COW_INDEX_EXTRA_TRANS_BLOCKS + 3 +
++ 2*EXT3COW_QUOTA_INIT_BLOCKS(dir->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ if (IS_DIRSYNC(dir))
++ handle->h_sync = 1;
++
++ inode = ext3cow_new_inode (handle, dir, mode);
++ err = PTR_ERR(inode);
++ if (!IS_ERR(inode)) {
++ init_special_inode(inode, inode->i_mode, rdev);
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ inode->i_op = &ext3cow_special_inode_operations;
++#endif
++ err = ext3cow_add_nondir(handle, dentry, inode);
++ }
++ ext3cow_journal_stop(handle);
++ if (err == -ENOSPC && ext3cow_should_retry_alloc(dir->i_sb, &retries))
++ goto retry;
++ return err;
++}
++
++static int ext3cow_mkdir(struct inode * dir, struct dentry * dentry, int mode)
++{
++ handle_t *handle;
++ struct inode * inode;
++ struct buffer_head * dir_block;
++ struct ext3cow_dir_entry_2 * de;
++ int err, retries = 0;
++
++ if (dir->i_nlink >= EXT3COW_LINK_MAX)
++ return -EMLINK;
++ /* No mkdirs in the past -znjp */
++ if(is_unchangeable(dir, dentry))
++ return -EROFS;
++
++
++retry:
++ handle = ext3cow_journal_start(dir, EXT3COW_DATA_TRANS_BLOCKS(dir->i_sb) +
++ EXT3COW_INDEX_EXTRA_TRANS_BLOCKS + 3 +
++ 2*EXT3COW_QUOTA_INIT_BLOCKS(dir->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ if (IS_DIRSYNC(dir))
++ handle->h_sync = 1;
++
++ inode = ext3cow_new_inode (handle, dir, S_IFDIR | mode);
++ err = PTR_ERR(inode);
++ if (IS_ERR(inode))
++ goto out_stop;
++
++ inode->i_op = &ext3cow_dir_inode_operations;
++ inode->i_fop = &ext3cow_dir_operations;
++ inode->i_size = EXT3COW_I(inode)->i_disksize = inode->i_sb->s_blocksize;
++ dir_block = ext3cow_bread (handle, inode, 0, 1, &err);
++ if (!dir_block) {
++ drop_nlink(inode); /* is this nlink == 0? */
++ ext3cow_mark_inode_dirty(handle, inode);
++ iput (inode);
++ goto out_stop;
++ }
++ BUFFER_TRACE(dir_block, "get_write_access");
++ ext3cow_journal_get_write_access(handle, dir_block);
++ de = (struct ext3cow_dir_entry_2 *) dir_block->b_data;
++ de->inode = cpu_to_le32(inode->i_ino);
++ de->name_len = 1;
++ de->rec_len = cpu_to_le16(EXT3COW_DIR_REC_LEN(de->name_len));
++ /* For versioning -znjp */
++ de->birth_epoch = cpu_to_le32(EXT3COW_S_EPOCHNUMBER(dir->i_sb));
++ de->death_epoch = cpu_to_le32(EXT3COW_DIRENT_ALIVE);
++ strcpy (de->name, ".");
++ ext3cow_set_de_type(dir->i_sb, de, S_IFDIR);
++ de = (struct ext3cow_dir_entry_2 *)
++ ((char *) de + le16_to_cpu(de->rec_len));
++ de->inode = cpu_to_le32(dir->i_ino);
++ de->rec_len = cpu_to_le16(inode->i_sb->s_blocksize-EXT3COW_DIR_REC_LEN(1));
++ de->name_len = 2;
++ strcpy (de->name, "..");
++ ext3cow_set_de_type(dir->i_sb, de, S_IFDIR);
++ inode->i_nlink = 2;
++ /* For versioning -znjp */
++ de->birth_epoch = cpu_to_le32(EXT3COW_I_EPOCHNUMBER(dir));
++ de->death_epoch = cpu_to_le32(EXT3COW_DIRENT_ALIVE);
++ BUFFER_TRACE(dir_block, "call ext3cow_journal_dirty_metadata");
++ ext3cow_journal_dirty_metadata(handle, dir_block);
++ brelse (dir_block);
++ ext3cow_mark_inode_dirty(handle, inode);
++ err = ext3cow_add_entry (handle, dentry, inode);
++ if (err) {
++ inode->i_nlink = 0;
++ ext3cow_mark_inode_dirty(handle, inode);
++ iput (inode);
++ goto out_stop;
++ }
++ inc_nlink(dir);
++ ext3cow_update_dx_flag(dir);
++ ext3cow_mark_inode_dirty(handle, dir);
++ d_instantiate(dentry, inode);
++out_stop:
++ ext3cow_journal_stop(handle);
++ if (err == -ENOSPC && ext3cow_should_retry_alloc(dir->i_sb, &retries))
++ goto retry;
++ return err;
++}
++
++/*
++ * routine to check that the specified directory is empty (for rmdir)
++ */
++static int empty_dir (struct inode * inode)
++{
++ unsigned long offset;
++ struct buffer_head * bh;
++ struct ext3cow_dir_entry_2 * de, * de1;
++ struct super_block * sb;
++ int err = 0;
++
++ sb = inode->i_sb;
++ if (inode->i_size < EXT3COW_DIR_REC_LEN(1) + EXT3COW_DIR_REC_LEN(2) ||
++ !(bh = ext3cow_bread (NULL, inode, 0, 0, &err))) {
++ if (err)
++ ext3cow_error(inode->i_sb, __FUNCTION__,
++ "error %d reading directory #%lu offset 0",
++ err, inode->i_ino);
++ else
++ ext3cow_warning(inode->i_sb, __FUNCTION__,
++ "bad directory (dir #%lu) - no data block",
++ inode->i_ino);
++ return 1;
++ }
++ de = (struct ext3cow_dir_entry_2 *) bh->b_data;
++ de1 = (struct ext3cow_dir_entry_2 *)
++ ((char *) de + le16_to_cpu(de->rec_len));
++ if (le32_to_cpu(de->inode) != inode->i_ino ||
++ !le32_to_cpu(de1->inode) ||
++ strcmp (".", de->name) ||
++ strcmp ("..", de1->name)) {
++ ext3cow_warning (inode->i_sb, "empty_dir",
++ "bad directory (dir #%lu) - no `.' or `..'",
++ inode->i_ino);
++ brelse (bh);
++ return 1;
++ }
++ offset = le16_to_cpu(de->rec_len) + le16_to_cpu(de1->rec_len);
++ de = (struct ext3cow_dir_entry_2 *)
++ ((char *) de1 + le16_to_cpu(de1->rec_len));
++ while (offset < inode->i_size ) {
++ if (!bh ||
++ (void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
++ err = 0;
++ brelse (bh);
++ bh = ext3cow_bread (NULL, inode,
++ offset >> EXT3COW_BLOCK_SIZE_BITS(sb), 0, &err);
++ if (!bh) {
++ if (err)
++ ext3cow_error(sb, __FUNCTION__,
++ "error %d reading directory"
++ " #%lu offset %lu",
++ err, inode->i_ino, offset);
++ offset += sb->s_blocksize;
++ continue;
++ }
++ de = (struct ext3cow_dir_entry_2 *) bh->b_data;
++ }
++ if (!ext3cow_check_dir_entry("empty_dir", inode, de, bh, offset)) {
++ de = (struct ext3cow_dir_entry_2 *)(bh->b_data +
++ sb->s_blocksize);
++ offset = (offset | (sb->s_blocksize - 1)) + 1;
++ continue;
++ }
++ /* Can remove a dir only if all dirents are out of scope -znjp */
++ if (le32_to_cpu(de->inode) &&
++ EXT3COW_IS_DIRENT_SCOPED(de, EXT3COW_I_EPOCHNUMBER(inode))) {
++ brelse (bh);
++ return 0;
++ }
++ offset += le16_to_cpu(de->rec_len);
++ de = (struct ext3cow_dir_entry_2 *)
++ ((char *) de + le16_to_cpu(de->rec_len));
++ }
++ brelse (bh);
++ return 1;
++}
++
++/* ext3cow_orphan_add() links an unlinked or truncated inode into a list of
++ * such inodes, starting at the superblock, in case we crash before the
++ * file is closed/deleted, or in case the inode truncate spans multiple
++ * transactions and the last transaction is not recovered after a crash.
++ *
++ * At filesystem recovery time, we walk this list deleting unlinked
++ * inodes and truncating linked inodes in ext3cow_orphan_cleanup().
++ */
++int ext3cow_orphan_add(handle_t *handle, struct inode *inode)
++{
++ struct super_block *sb = inode->i_sb;
++ struct ext3cow_iloc iloc;
++ int err = 0, rc;
++
++ lock_super(sb);
++ if (!list_empty(&EXT3COW_I(inode)->i_orphan))
++ goto out_unlock;
++
++ /* Orphan handling is only valid for files with data blocks
++ * being truncated, or files being unlinked. */
++
++ /* @@@ FIXME: Observation from aviro:
++ * I think I can trigger J_ASSERT in ext3cow_orphan_add(). We block
++ * here (on lock_super()), so race with ext3cow_link() which might bump
++ * ->i_nlink. For, say it, character device. Not a regular file,
++ * not a directory, not a symlink and ->i_nlink > 0.
++ */
++ J_ASSERT ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
++ S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
++
++ BUFFER_TRACE(EXT3COW_SB(sb)->s_sbh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, EXT3COW_SB(sb)->s_sbh);
++ if (err)
++ goto out_unlock;
++
++ err = ext3cow_reserve_inode_write(handle, inode, &iloc);
++ if (err)
++ goto out_unlock;
++
++ /* Insert this inode at the head of the on-disk orphan list... */
++ NEXT_ORPHAN(inode) = le32_to_cpu(EXT3COW_SB(sb)->s_es->s_last_orphan);
++ EXT3COW_SB(sb)->s_es->s_last_orphan = cpu_to_le32(inode->i_ino);
++ err = ext3cow_journal_dirty_metadata(handle, EXT3COW_SB(sb)->s_sbh);
++ rc = ext3cow_mark_iloc_dirty(handle, inode, &iloc);
++ if (!err)
++ err = rc;
++
++ /* Only add to the head of the in-memory list if all the
++ * previous operations succeeded. If the orphan_add is going to
++ * fail (possibly taking the journal offline), we can't risk
++ * leaving the inode on the orphan list: stray orphan-list
++ * entries can cause panics at unmount time.
++ *
++ * This is safe: on error we're going to ignore the orphan list
++ * anyway on the next recovery. */
++ if (!err)
++ list_add(&EXT3COW_I(inode)->i_orphan, &EXT3COW_SB(sb)->s_orphan);
++
++ jbd_debug(4, "superblock will point to %lu\n", inode->i_ino);
++ jbd_debug(4, "orphan inode %lu will point to %d\n",
++ inode->i_ino, NEXT_ORPHAN(inode));
++out_unlock:
++ unlock_super(sb);
++ ext3cow_std_error(inode->i_sb, err);
++ return err;
++}
++
++/*
++ * ext3cow_orphan_del() removes an unlinked or truncated inode from the list
++ * of such inodes stored on disk, because it is finally being cleaned up.
++ */
++int ext3cow_orphan_del(handle_t *handle, struct inode *inode)
++{
++ struct list_head *prev;
++ struct ext3cow_inode_info *ei = EXT3COW_I(inode);
++ struct ext3cow_sb_info *sbi;
++ unsigned long ino_next;
++ struct ext3cow_iloc iloc;
++ int err = 0;
++
++ lock_super(inode->i_sb);
++ if (list_empty(&ei->i_orphan)) {
++ unlock_super(inode->i_sb);
++ return 0;
++ }
++
++ ino_next = NEXT_ORPHAN(inode);
++ prev = ei->i_orphan.prev;
++ sbi = EXT3COW_SB(inode->i_sb);
++
++ jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);
++
++ list_del_init(&ei->i_orphan);
++
++ /* If we're on an error path, we may not have a valid
++ * transaction handle with which to update the orphan list on
++ * disk, but we still need to remove the inode from the linked
++ * list in memory. */
++ if (!handle)
++ goto out;
++
++ err = ext3cow_reserve_inode_write(handle, inode, &iloc);
++ if (err)
++ goto out_err;
++
++ if (prev == &sbi->s_orphan) {
++ jbd_debug(4, "superblock will point to %lu\n", ino_next);
++ BUFFER_TRACE(sbi->s_sbh, "get_write_access");
++ err = ext3cow_journal_get_write_access(handle, sbi->s_sbh);
++ if (err)
++ goto out_brelse;
++ sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
++ err = ext3cow_journal_dirty_metadata(handle, sbi->s_sbh);
++ } else {
++ struct ext3cow_iloc iloc2;
++ struct inode *i_prev =
++ &list_entry(prev, struct ext3cow_inode_info, i_orphan)->vfs_inode;
++
++ jbd_debug(4, "orphan inode %lu will point to %lu\n",
++ i_prev->i_ino, ino_next);
++ err = ext3cow_reserve_inode_write(handle, i_prev, &iloc2);
++ if (err)
++ goto out_brelse;
++ NEXT_ORPHAN(i_prev) = ino_next;
++ err = ext3cow_mark_iloc_dirty(handle, i_prev, &iloc2);
++ }
++ if (err)
++ goto out_brelse;
++ NEXT_ORPHAN(inode) = 0;
++ err = ext3cow_mark_iloc_dirty(handle, inode, &iloc);
++
++out_err:
++ ext3cow_std_error(inode->i_sb, err);
++out:
++ unlock_super(inode->i_sb);
++ return err;
++
++out_brelse:
++ brelse(iloc.bh);
++ goto out_err;
++}
++
++static int ext3cow_rmdir (struct inode * dir, struct dentry *dentry)
++{
++ int retval;
++ struct inode * inode;
++ struct buffer_head * bh;
++ struct ext3cow_dir_entry_2 * de;
++ handle_t *handle;
++
++ /* Initialize quotas before so that eventual writes go in
++ * separate transaction */
++ DQUOT_INIT(dentry->d_inode);
++ handle = ext3cow_journal_start(dir, EXT3COW_DELETE_TRANS_BLOCKS(dir->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ retval = -ENOENT;
++ bh = ext3cow_find_entry (dentry, &de);
++ if (!bh)
++ goto end_rmdir;
++
++ if (IS_DIRSYNC(dir))
++ handle->h_sync = 1;
++
++ inode = dentry->d_inode;
++
++ /* Can't rmdir in the past -znjp */
++ retval = -EROFS;
++ if(is_unchangeable(inode, dentry))
++ goto end_rmdir;
++
++ retval = -EIO;
++ if (le32_to_cpu(de->inode) != inode->i_ino)
++ goto end_rmdir;
++
++ retval = -ENOTEMPTY;
++ if (!empty_dir (inode))
++ goto end_rmdir;
++
++ retval = ext3cow_delete_entry(handle, dir, de, bh, dentry);
++ if (retval)
++ goto end_rmdir;
++ if (inode->i_nlink != 2)
++ ext3cow_warning (inode->i_sb, "ext3cow_rmdir",
++ "empty directory has nlink!=2 (%d)",
++ inode->i_nlink);
++ inode->i_version++;
++
++ /* We only delete things that were created in the same epoch -znjp */
++ if(de->birth_epoch == de->death_epoch){
++ clear_nlink(inode);
++ /* There's no need to set i_disksize: the fact that i_nlink is
++ * zero will ensure that the right thing happens during any
++ * recovery. */
++ inode->i_size = 0;
++ ext3cow_orphan_add(handle, inode);
++ drop_nlink(dir);
++ }
++ EXT3COW_I(inode)->i_flags |= EXT3COW_UNCHANGEABLE_FL;
++ inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
++ ext3cow_mark_inode_dirty(handle, inode);
++ ext3cow_update_dx_flag(dir);
++ ext3cow_mark_inode_dirty(handle, dir);
++
++end_rmdir:
++ ext3cow_journal_stop(handle);
++ brelse (bh);
++ return retval;
++}
++
++static int ext3cow_unlink(struct inode * dir, struct dentry *dentry)
++{
++ int retval;
++ struct inode * inode;
++ struct buffer_head * bh;
++ struct ext3cow_dir_entry_2 * de;
++ handle_t *handle;
++
++ /* Initialize quotas before so that eventual writes go
++ * in separate transaction */
++ DQUOT_INIT(dentry->d_inode);
++ handle = ext3cow_journal_start(dir, EXT3COW_DELETE_TRANS_BLOCKS(dir->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ if (IS_DIRSYNC(dir))
++ handle->h_sync = 1;
++
++ retval = -ENOENT;
++ bh = ext3cow_find_entry (dentry, &de);
++ if (!bh)
++ goto end_unlink;
++
++ inode = dentry->d_inode;
++
++ /* Can't unlink in the past -znjp */
++ retval = -EROFS;
++ if(is_unchangeable(inode, dentry))
++ goto end_unlink;
++
++ retval = -EIO;
++ if (le32_to_cpu(de->inode) != inode->i_ino)
++ goto end_unlink;
++
++ if (!inode->i_nlink) {
++ ext3cow_warning (inode->i_sb, "ext3cow_unlink",
++ "Deleting nonexistent file (%lu), %d",
++ inode->i_ino, inode->i_nlink);
++ inode->i_nlink = 1;
++ }
++ retval = ext3cow_delete_entry(handle, dir, de, bh, dentry);
++ if (retval)
++ goto end_unlink;
++ dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
++ ext3cow_update_dx_flag(dir);
++ ext3cow_mark_inode_dirty(handle, dir);
++
++ /* If the file should be deleted here, don't actually delete it
++ * but mark it unchangeable, i.e. it's now in the past. -znjp */
++
++ /* If file was created in this epoch, then we actually unlink it,
++ * if not, then it belongs to the past, so mark it unchangeable -znjp */
++ if(de->birth_epoch == de->death_epoch){
++ drop_nlink(inode);
++ if (!inode->i_nlink){
++ ext3cow_orphan_add(handle, inode);
++ }
++ }else{
++ if(!(inode->i_nlink - 1))
++ EXT3COW_I(inode)->i_flags |= EXT3COW_UNCHANGEABLE_FL;
++ }
++ inode->i_ctime = dir->i_ctime;
++ ext3cow_mark_inode_dirty(handle, inode);
++ retval = 0;
++
++end_unlink:
++ ext3cow_journal_stop(handle);
++ brelse (bh);
++ return retval;
++}
++
++static int ext3cow_symlink (struct inode * dir,
++ struct dentry *dentry, const char * symname)
++{
++ handle_t *handle;
++ struct inode * inode;
++ int l, err, retries = 0;
++
++ l = strlen(symname)+1;
++ if (l > dir->i_sb->s_blocksize)
++ return -ENAMETOOLONG;
++
++retry:
++ handle = ext3cow_journal_start(dir, EXT3COW_DATA_TRANS_BLOCKS(dir->i_sb) +
++ EXT3COW_INDEX_EXTRA_TRANS_BLOCKS + 5 +
++ 2*EXT3COW_QUOTA_INIT_BLOCKS(dir->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ if (IS_DIRSYNC(dir))
++ handle->h_sync = 1;
++
++ inode = ext3cow_new_inode (handle, dir, S_IFLNK|S_IRWXUGO);
++ err = PTR_ERR(inode);
++ if (IS_ERR(inode))
++ goto out_stop;
++
++ if (l > sizeof (EXT3COW_I(inode)->i_data)) {
++ inode->i_op = &ext3cow_symlink_inode_operations;
++ ext3cow_set_aops(inode);
++ /*
++ * page_symlink() calls into ext3cow_prepare/commit_write.
++ * We have a transaction open. All is sweetness. It also sets
++ * i_size in generic_commit_write().
++ */
++ err = __page_symlink(inode, symname, l,
++ mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
++ if (err) {
++ ext3cow_dec_count(handle, inode);
++ ext3cow_mark_inode_dirty(handle, inode);
++ iput (inode);
++ goto out_stop;
++ }
++ } else {
++ inode->i_op = &ext3cow_fast_symlink_inode_operations;
++ memcpy((char*)&EXT3COW_I(inode)->i_data,symname,l);
++ inode->i_size = l-1;
++ }
++ EXT3COW_I(inode)->i_disksize = inode->i_size;
++ err = ext3cow_add_nondir(handle, dentry, inode);
++out_stop:
++ ext3cow_journal_stop(handle);
++ if (err == -ENOSPC && ext3cow_should_retry_alloc(dir->i_sb, &retries))
++ goto retry;
++ return err;
++}
++
++static int ext3cow_link (struct dentry * old_dentry,
++ struct inode * dir, struct dentry *dentry)
++{
++ handle_t *handle;
++ struct inode *inode = old_dentry->d_inode;
++ int err, retries = 0;
++
++ if (inode->i_nlink >= EXT3COW_LINK_MAX)
++ return -EMLINK;
++
++retry:
++ handle = ext3cow_journal_start(dir, EXT3COW_DATA_TRANS_BLOCKS(dir->i_sb) +
++ EXT3COW_INDEX_EXTRA_TRANS_BLOCKS);
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ if (IS_DIRSYNC(dir))
++ handle->h_sync = 1;
++
++ inode->i_ctime = CURRENT_TIME_SEC;
++ ext3cow_inc_count(handle, inode);
++ atomic_inc(&inode->i_count);
++
++ err = ext3cow_add_nondir(handle, dentry, inode);
++ ext3cow_journal_stop(handle);
++ if (err == -ENOSPC && ext3cow_should_retry_alloc(dir->i_sb, &retries))
++ goto retry;
++ return err;
++}
++
++#define PARENT_INO(buffer) \
++ ((struct ext3cow_dir_entry_2 *) ((char *) buffer + \
++ le16_to_cpu(((struct ext3cow_dir_entry_2 *) buffer)->rec_len)))->inode
++
++/*
++ * Anybody can rename anything with this: the permission checks are left to the
++ * higher-level routines.
++ */
++static int ext3cow_rename (struct inode * old_dir, struct dentry *old_dentry,
++ struct inode * new_dir,struct dentry *new_dentry)
++{
++ handle_t *handle;
++ struct inode * old_inode, * new_inode;
++ struct buffer_head * old_bh, * new_bh, * dir_bh;
++ struct ext3cow_dir_entry_2 * old_de, * new_de;
++ int retval;
++
++ old_bh = new_bh = dir_bh = NULL;
++
++ /* Initialize quotas before so that eventual writes go
++ * in separate transaction */
++ if (new_dentry->d_inode)
++ DQUOT_INIT(new_dentry->d_inode);
++ handle = ext3cow_journal_start(old_dir, 2 *
++ EXT3COW_DATA_TRANS_BLOCKS(old_dir->i_sb) +
++ EXT3COW_INDEX_EXTRA_TRANS_BLOCKS + 2);
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ if (IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir))
++ handle->h_sync = 1;
++
++ old_bh = ext3cow_find_entry (old_dentry, &old_de);
++ /*
++ * Check for inode number is _not_ due to possible IO errors.
++ * We might rmdir the source, keep it as pwd of some process
++ * and merrily kill the link to whatever was created under the
++ * same name. Goodbye sticky bit ;-<
++ */
++ old_inode = old_dentry->d_inode;
++ retval = -ENOENT;
++ if (!old_bh || le32_to_cpu(old_de->inode) != old_inode->i_ino)
++ goto end_rename;
++
++ new_inode = new_dentry->d_inode;
++ new_bh = ext3cow_find_entry (new_dentry, &new_de);
++ if (new_bh) {
++ if (!new_inode) {
++ brelse (new_bh);
++ new_bh = NULL;
++ }
++ }
++
++ /* can't move something into the past -znjp */
++ retval = -EROFS;
++ if(is_unchangeable(new_inode, new_dentry))
++ goto end_rename;
++ /* can't some move from the past -znjp */
++ if(is_unchangeable(old_inode, old_dentry))
++ goto end_rename;
++
++ if (S_ISDIR(old_inode->i_mode)) {
++ if (new_inode) {
++ retval = -ENOTEMPTY;
++ if (!empty_dir (new_inode))
++ goto end_rename;
++ }
++ retval = -EIO;
++ dir_bh = ext3cow_bread (handle, old_inode, 0, 0, &retval);
++ if (!dir_bh)
++ goto end_rename;
++ if (le32_to_cpu(PARENT_INO(dir_bh->b_data)) != old_dir->i_ino)
++ goto end_rename;
++ retval = -EMLINK;
++ if (!new_inode && new_dir!=old_dir &&
++ new_dir->i_nlink >= EXT3COW_LINK_MAX)
++ goto end_rename;
++ }
++ if (!new_bh) {
++ retval = ext3cow_add_entry (handle, new_dentry, old_inode);
++ if (retval)
++ goto end_rename;
++ } else {
++ BUFFER_TRACE(new_bh, "get write access");
++ ext3cow_journal_get_write_access(handle, new_bh);
++ new_de->inode = cpu_to_le32(old_inode->i_ino);
++ if (EXT3COW_HAS_INCOMPAT_FEATURE(new_dir->i_sb,
++ EXT3COW_FEATURE_INCOMPAT_FILETYPE))
++ new_de->file_type = old_de->file_type;
++ new_dir->i_version++;
++ BUFFER_TRACE(new_bh, "call ext3cow_journal_dirty_metadata");
++ ext3cow_journal_dirty_metadata(handle, new_bh);
++ brelse(new_bh);
++ new_bh = NULL;
++ }
++
++ /*
++ * Like most other Unix systems, set the ctime for inodes on a
++ * rename.
++ */
++ old_inode->i_ctime = CURRENT_TIME_SEC;
++ ext3cow_mark_inode_dirty(handle, old_inode);
++
++ /*
++ * ok, that's it
++ */
++ if (le32_to_cpu(old_de->inode) != old_inode->i_ino ||
++ old_de->name_len != old_dentry->d_name.len ||
++ strncmp(old_de->name, old_dentry->d_name.name, old_de->name_len) ||
++ (retval = ext3cow_delete_entry(handle, old_dir,
++ old_de, old_bh, new_dentry)) == -ENOENT) {
++ /* old_de could have moved from under us during htree split, so
++ * make sure that we are deleting the right entry. We might
++ * also be pointing to a stale entry in the unused part of
++ * old_bh so just checking inum and the name isn't enough. */
++ struct buffer_head *old_bh2;
++ struct ext3cow_dir_entry_2 *old_de2;
++
++ old_bh2 = ext3cow_find_entry(old_dentry, &old_de2);
++ if (old_bh2) {
++ retval = ext3cow_delete_entry(handle, old_dir,
++ old_de2, old_bh2, new_dentry);
++ brelse(old_bh2);
++ }
++ }
++ if (retval) {
++ ext3cow_warning(old_dir->i_sb, "ext3cow_rename",
++ "Deleting old file (%lu), %d, error=%d",
++ old_dir->i_ino, old_dir->i_nlink, retval);
++ }
++
++ if (new_inode) {
++ new_inode->i_ctime = CURRENT_TIME_SEC;
++ }
++ if(!is_unchangeable(old_inode, old_dentry))
++ old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME_SEC;
++ ext3cow_update_dx_flag(old_dir);
++ if (dir_bh) {
++ BUFFER_TRACE(dir_bh, "get_write_access");
++ ext3cow_journal_get_write_access(handle, dir_bh);
++ PARENT_INO(dir_bh->b_data) = cpu_to_le32(new_dir->i_ino);
++ BUFFER_TRACE(dir_bh, "call ext3cow_journal_dirty_metadata");
++ ext3cow_journal_dirty_metadata(handle, dir_bh);
++ if (!new_inode) {
++ inc_nlink(new_dir);
++ ext3cow_update_dx_flag(new_dir);
++ ext3cow_mark_inode_dirty(handle, new_dir);
++ }
++ }
++ ext3cow_mark_inode_dirty(handle, old_dir);
++ if (new_inode) {
++ ext3cow_mark_inode_dirty(handle, new_inode);
++ if (!new_inode->i_nlink)
++ ext3cow_orphan_add(handle, new_inode);
++ }
++ retval = 0;
++
++end_rename:
++ brelse (dir_bh);
++ brelse (old_bh);
++ brelse (new_bh);
++ ext3cow_journal_stop(handle);
++ return retval;
++}
++
++/* ext3cow_fake_inode: This function creates a VFS-only inode
++ * used for properly scoping views into the past file system - znjp
++ */
++struct inode *ext3cow_fake_inode(struct inode *inode,
++ unsigned int epoch_number)
++{
++ struct inode * fake_inode = NULL;
++ struct ext3cow_inode_info * ini = NULL;
++ struct ext3cow_inode_info * fake_ini = NULL;
++ static unsigned int last_ino = UINT_MAX;
++ int err = 0;
++ int block = -1;
++
++ if(NULL == inode){
++ printk(KERN_ERR "Trying to duplicate a NULL inode.\n");
++ return NULL;
++ }
++
++ if(EXT3COW_IS_FAKEINODE(inode)){
++ printk(KERN_ERR "Trying to fake a fake inode.\n");
++ return inode;
++ }
++
++ printk(KERN_INFO "** faking inode %lu\n", inode->i_ino);
++
++ ini = EXT3COW_I(inode);
++
++ /* Create a new VFS-only inode */
++ fake_inode = new_inode(inode->i_sb);
++ err = PTR_ERR(fake_inode);
++ if(!IS_ERR(fake_inode)){
++
++ fake_ini = EXT3COW_I(fake_inode);
++
++ printk(KERN_INFO "** got inode %lu setting with %u\n", fake_inode->i_ino,
++ last_ino);
++
++ /* When inode is a directory, we can fake the inode number */
++ //if(S_ISDIR(inode->i_mode))
++ fake_inode->i_ino = --last_ino;
++
++ fake_inode->i_mode = inode->i_mode;
++ fake_inode->i_uid = inode->i_uid;
++ fake_inode->i_gid = inode->i_gid;
++
++ /* uid_high and gid_high code would go here -znjp
++ fake_inode->i_uid_high = inode->i_uid_high;
++ fake_inode->i_gid_high = inode->i_gid_high;
++ */
++
++ atomic_set(&fake_inode->i_count, 1);
++
++ fake_inode->i_nlink = inode->i_nlink;
++ fake_inode->i_size = inode->i_size;
++ fake_inode->i_atime.tv_sec = inode->i_atime.tv_sec;
++ fake_inode->i_ctime.tv_sec = inode->i_ctime.tv_sec;
++ fake_inode->i_mtime.tv_sec = inode->i_mtime.tv_sec;
++ fake_inode->i_atime.tv_nsec = inode->i_atime.tv_nsec;
++ fake_inode->i_ctime.tv_nsec = inode->i_ctime.tv_nsec;
++ fake_inode->i_mtime.tv_nsec = inode->i_mtime.tv_nsec;
++
++ fake_ini->i_state = ini->i_state;
++ fake_ini->i_dir_start_lookup = ini->i_dir_start_lookup;
++ fake_ini->i_dtime = ini->i_dtime;
++
++ fake_inode->i_blocks = inode->i_blocks;
++ fake_ini->i_flags = ini->i_flags;
++#ifdef EXT3COW_FRAGMENTS
++ fake_ini->i_faddr = ini->i_faddr;
++ fake_ini->i_frag_no = ini->i_frag_no;
++ fake_ini->i_frag_size = ini->i_frag_size;
++#endif
++ fake_ini->i_file_acl = ini->i_file_acl;
++ if (!S_ISREG(fake_inode->i_mode)) {
++ fake_ini->i_dir_acl = ini->i_dir_acl;
++ }
++ fake_ini->i_disksize = inode->i_size;
++ fake_inode->i_generation = inode->i_generation;
++ //TODO: This could be wrong.
++ //fake_ini->i_block_group = ini->i_block_group; //iloc.block_group;
++
++ for (block = 0; block < EXT3COW_N_BLOCKS; block++)
++ fake_ini->i_data[block] = ini->i_data[block];
++
++ fake_ini->i_extra_isize = ini->i_extra_isize;
++
++ /* set copy-on-write bitmap to 0 */
++ fake_ini->i_cow_bitmap = 0x0000;
++
++ /* Mark fake inode unchangeable, etc. */
++ fake_ini->i_flags |= EXT3COW_UNCHANGEABLE_FL;
++ fake_ini->i_flags |= EXT3COW_UNVERSIONABLE_FL;
++ fake_ini->i_flags |= EXT3COW_FAKEINODE_FL;
++ fake_ini->i_flags |= EXT3COW_IMMUTABLE_FL;
++
++ /* Make sure we get the right operations */
++ if (S_ISREG(fake_inode->i_mode)) {
++ fake_inode->i_op = &ext3cow_file_inode_operations;
++ fake_inode->i_fop = &ext3cow_file_operations;
++ ext3cow_set_aops(fake_inode);
++ } else if (S_ISDIR(fake_inode->i_mode)) {
++ fake_inode->i_op = &ext3cow_dir_inode_operations;
++ fake_inode->i_fop = &ext3cow_dir_operations;
++ } else if (S_ISLNK(fake_inode->i_mode)) {
++ //if (ext3cow_inode_is_fast_symlink(cow_inode))
++ if((S_ISLNK(fake_inode->i_mode) && fake_inode->i_blocks -
++ (EXT3COW_I(fake_inode)->i_file_acl ?
++ (fake_inode->i_sb->s_blocksize >> 9) : 0)))
++ fake_inode->i_op = &ext3cow_fast_symlink_inode_operations;
++ else {
++ fake_inode->i_op = &ext3cow_symlink_inode_operations;
++ ext3cow_set_aops(fake_inode);
++ }
++ } else {
++ fake_inode->i_op = &ext3cow_special_inode_operations;
++ }
++
++ fake_ini->i_epoch_number = epoch_number;
++ fake_ini->i_next_inode = 0;
++
++ iput(inode); /* dec i_count */
++
++ return fake_inode;
++ }else
++ ext3cow_warning(inode->i_sb, "ext3cow_fake_inode",
++ "Could not create fake inode.");
++
++ return NULL;
++}
++
++/*
++ * ext3cow_dup_inode: This function creates a new inode,
++ * copies all the metadata from the passed in inode,
++ * and adds it to the version chain, creating a new version.
++ * The head of the chain never changes; it is always the most current version.
++ * Similar in nature to ext3cow_creat and ext3cow_read_inode. -znjp
++ */
++int ext3cow_dup_inode(struct inode *dir, struct inode *inode){
++
++ struct inode *cow_inode = NULL;
++ struct inode *parent = NULL;
++ struct ext3cow_inode_info *ini = NULL;
++ struct ext3cow_inode_info *cow_ini = NULL;
++ handle_t *handle = NULL;
++ int err = 0;
++ int block = -1;
++ unsigned int epoch_number_temp = 0;
++ int retries = 0;
++
++ printk(KERN_INFO "** duping inode %lu\n", inode->i_ino);
++
++ if(EXT3COW_IS_UNVERSIONABLE(inode))
++ return 0;
++
++ if(NULL == inode){
++ printk(KERN_ERR "Trying to duplicate a NULL inode.\n");
++ return -1;
++ }
++
++ if (inode->i_nlink == 0) {
++ if (inode->i_mode == 0 ||
++ !(EXT3COW_SB(inode->i_sb)->s_mount_state & EXT3COW_ORPHAN_FS)) {
++ /* this inode is deleted */
++ return -1;
++ }
++ /* The only unlinked inodes we let through here have
++ * valid i_mode and are being read by the orphan
++ * recovery code: that's fine, we're about to complete
++ * the process of deleting those. */
++ }
++
++ ini = EXT3COW_I(inode);
++
++ /* This is for truncate, which can't pass in a parent */
++ if(NULL == dir)
++ parent = inode;
++ else
++ parent = dir;
++
++ retry:
++ handle = ext3cow_journal_start(parent, EXT3COW_DATA_TRANS_BLOCKS(dir->i_sb) +
++ EXT3COW_INDEX_EXTRA_TRANS_BLOCKS + 3 +
++ 2*EXT3COW_QUOTA_INIT_BLOCKS(dir->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ if (IS_DIRSYNC(parent))
++ handle->h_sync = 1;
++
++ cow_inode = ext3cow_new_inode (handle, parent, inode->i_mode);
++ err = PTR_ERR(cow_inode);
++ if (!IS_ERR(cow_inode)) {
++
++ printk(KERN_INFO " ** Allocated new inode %lu\n", cow_inode->i_ino);
++
++ cow_ini = EXT3COW_I(cow_inode);
++
++ cow_inode->i_mode = inode->i_mode;
++ cow_inode->i_uid = inode->i_uid;
++ cow_inode->i_gid = inode->i_gid;
++
++ /* uid_high and gid_high code would go here -znjp
++ cow_inode->i_uid_high = inode->i_uid_high;
++ cow_inode->i_gid_high = inode->i_gid_high;
++ */
++
++ cow_inode->i_nlink = inode->i_nlink;
++ cow_inode->i_size = inode->i_size;
++ cow_inode->i_atime.tv_sec = inode->i_atime.tv_sec;
++ cow_inode->i_ctime.tv_sec = inode->i_ctime.tv_sec;
++ cow_inode->i_mtime.tv_sec = inode->i_mtime.tv_sec;
++ cow_inode->i_atime.tv_nsec = inode->i_atime.tv_nsec;
++ cow_inode->i_ctime.tv_nsec = inode->i_ctime.tv_nsec;
++ cow_inode->i_mtime.tv_nsec = inode->i_mtime.tv_nsec;
++
++ cow_ini->i_state = ini->i_state;
++ cow_ini->i_dir_start_lookup = ini->i_dir_start_lookup;
++ cow_ini->i_dtime = ini->i_dtime;
++
++ cow_inode->i_blocks = inode->i_blocks;
++ cow_ini->i_flags = ini->i_flags;
++#ifdef EXT3COW_FRAGMENTS
++ cow_ini->i_faddr = ini->i_faddr;
++ cow_ini->i_frag_no = ini->i_frag_no;
++ cow_ini->i_frag_size = ini->i_frag_size;
++#endif
++ cow_ini->i_file_acl = ini->i_file_acl;
++ if (!S_ISREG(cow_inode->i_mode)) {
++ cow_ini->i_dir_acl = ini->i_dir_acl;
++ }
++ cow_ini->i_disksize = inode->i_size;
++ cow_inode->i_generation = inode->i_generation;
++ //TODO: This could be wrong.
++ cow_ini->i_block_group = ini->i_block_group; //iloc.block_group;
++
++ for (block = 0; block < EXT3COW_N_BLOCKS; block++)
++ cow_ini->i_data[block] = ini->i_data[block];
++
++ //TODO: This could be wrong
++ //cow_ini->i_orphan = NULL; //INIT_LIST_HEAD(&ei->i_orphan);
++
++ cow_ini->i_extra_isize = ini->i_extra_isize;
++
++ /* Make sure we get the right operations */
++ if (S_ISREG(cow_inode->i_mode)) {
++ cow_inode->i_op = &ext3cow_file_inode_operations;
++ cow_inode->i_fop = &ext3cow_file_operations;
++ ext3cow_set_aops(cow_inode);
++ } else if (S_ISDIR(cow_inode->i_mode)) {
++ cow_inode->i_op = &ext3cow_dir_inode_operations;
++ cow_inode->i_fop = &ext3cow_dir_operations;
++ } else if (S_ISLNK(cow_inode->i_mode)) {
++ //if (ext3cow_inode_is_fast_symlink(cow_inode))
++ if((S_ISLNK(cow_inode->i_mode) && cow_inode->i_blocks -
++ (EXT3COW_I(cow_inode)->i_file_acl ?
++ (cow_inode->i_sb->s_blocksize >> 9) : 0)))
++ cow_inode->i_op = &ext3cow_fast_symlink_inode_operations;
++ else {
++ cow_inode->i_op = &ext3cow_symlink_inode_operations;
++ ext3cow_set_aops(cow_inode);
++ }
++ } else {
++ cow_inode->i_op = &ext3cow_special_inode_operations;
++ /*
++ if (raw_inode->i_block[0])
++ init_special_inode(inode, inode->i_mode,
++ old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
++ else
++ init_special_inode(inode, inode->i_mode,
++ new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
++ */
++ }
++
++ /* Dup in the direct cow bitmap */
++ cow_ini->i_cow_bitmap = ini->i_cow_bitmap;
++ ini->i_cow_bitmap = 0x0000;
++ /* Mark new inode unchangeable */
++ cow_ini->i_flags |= EXT3COW_UNCHANGEABLE_FL;
++ /* Switch epoch numbers */
++ epoch_number_temp = ini->i_epoch_number;
++ ini->i_epoch_number = cow_ini->i_epoch_number;
++ cow_ini->i_epoch_number = epoch_number_temp;
++ /* Chain Inodes together */
++ cow_ini->i_next_inode = ini->i_next_inode;
++ ini->i_next_inode = cow_inode->i_ino;
++
++ ext3cow_mark_inode_dirty(handle, cow_inode);
++ ext3cow_mark_inode_dirty(handle, inode);
++
++ iput(cow_inode); /* dec i_count */
++
++ err = 0;
++ }
++ ext3cow_journal_stop(handle);
++ if (err == -ENOSPC && ext3cow_should_retry_alloc(dir->i_sb, &retries))
++ goto retry;
++ return err;
++
++}
++
++/* ext3cow_reclaim_dup_inode: rolls back a recently dup'd inode
++ * on error, including epoch number and bitmaps. Should not
++ * be used for removing versions. */
++int ext3cow_reclaim_dup_inode(struct inode *dir, struct inode *inode)
++{
++ // handle_t *handle = NULL;
++
++ if(is_bad_inode(inode))
++ goto no_delete;
++
++ return 0;
++ no_delete:
++ return -1;
++}
++
++/*
++ * directories can handle most operations...
++ */
++struct inode_operations ext3cow_dir_inode_operations = {
++ .create = ext3cow_create,
++ .lookup = ext3cow_lookup,
++ .link = ext3cow_link,
++ .unlink = ext3cow_unlink,
++ .symlink = ext3cow_symlink,
++ .mkdir = ext3cow_mkdir,
++ .rmdir = ext3cow_rmdir,
++ .mknod = ext3cow_mknod,
++ .rename = ext3cow_rename,
++ .setattr = ext3cow_setattr,
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ .setxattr = generic_setxattr,
++ .getxattr = generic_getxattr,
++ .listxattr = ext3cow_listxattr,
++ .removexattr = generic_removexattr,
++#endif
++ .permission = ext3cow_permission,
++};
++
++struct inode_operations ext3cow_special_inode_operations = {
++ .setattr = ext3cow_setattr,
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ .setxattr = generic_setxattr,
++ .getxattr = generic_getxattr,
++ .listxattr = ext3cow_listxattr,
++ .removexattr = generic_removexattr,
++#endif
++ .permission = ext3cow_permission,
++};
+diff -ruN linux-2.6.20.3/fs/ext3cow/namei.h linux-2.6.20.3-ext3cow/fs/ext3cow/namei.h
+--- linux-2.6.20.3/fs/ext3cow/namei.h 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/namei.h 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,8 @@
++/* linux/fs/ext3cow/namei.h
++ *
++ * Copyright (C) 2005 Simtec Electronics
++ * Ben Dooks
++ *
++*/
++
++extern struct dentry *ext3cow_get_parent(struct dentry *child);
+diff -ruN linux-2.6.20.3/fs/ext3cow/resize.c linux-2.6.20.3-ext3cow/fs/ext3cow/resize.c
+--- linux-2.6.20.3/fs/ext3cow/resize.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/resize.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,1042 @@
++/*
++ * linux/fs/ext3cow/resize.c
++ *
++ * Support for resizing an ext3cow filesystem while it is mounted.
++ *
++ * Copyright (C) 2001, 2002 Andreas Dilger
++ *
++ * This could probably be made into a module, because it is not often in use.
++ */
++
++
++#define EXT3COWFS_DEBUG
++
++#include
++#include
++#include
++
++#include
++#include
++
++
++#define outside(b, first, last) ((b) < (first) || (b) >= (last))
++#define inside(b, first, last) ((b) >= (first) && (b) < (last))
++
++static int verify_group_input(struct super_block *sb,
++ struct ext3cow_new_group_data *input)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ struct ext3cow_super_block *es = sbi->s_es;
++ ext3cow_fsblk_t start = le32_to_cpu(es->s_blocks_count);
++ ext3cow_fsblk_t end = start + input->blocks_count;
++ unsigned group = input->group;
++ ext3cow_fsblk_t itend = input->inode_table + sbi->s_itb_per_group;
++ unsigned overhead = ext3cow_bg_has_super(sb, group) ?
++ (1 + ext3cow_bg_num_gdb(sb, group) +
++ le16_to_cpu(es->s_reserved_gdt_blocks)) : 0;
++ ext3cow_fsblk_t metaend = start + overhead;
++ struct buffer_head *bh = NULL;
++ ext3cow_grpblk_t free_blocks_count;
++ int err = -EINVAL;
++
++ input->free_blocks_count = free_blocks_count =
++ input->blocks_count - 2 - overhead - sbi->s_itb_per_group;
++
++ if (test_opt(sb, DEBUG))
++ printk(KERN_DEBUG "EXT3COW-fs: adding %s group %u: %u blocks "
++ "(%d free, %u reserved)\n",
++ ext3cow_bg_has_super(sb, input->group) ? "normal" :
++ "no-super", input->group, input->blocks_count,
++ free_blocks_count, input->reserved_blocks);
++
++ if (group != sbi->s_groups_count)
++ ext3cow_warning(sb, __FUNCTION__,
++ "Cannot add at group %u (only %lu groups)",
++ input->group, sbi->s_groups_count);
++ else if ((start - le32_to_cpu(es->s_first_data_block)) %
++ EXT3COW_BLOCKS_PER_GROUP(sb))
++ ext3cow_warning(sb, __FUNCTION__, "Last group not full");
++ else if (input->reserved_blocks > input->blocks_count / 5)
++ ext3cow_warning(sb, __FUNCTION__, "Reserved blocks too high (%u)",
++ input->reserved_blocks);
++ else if (free_blocks_count < 0)
++ ext3cow_warning(sb, __FUNCTION__, "Bad blocks count %u",
++ input->blocks_count);
++ else if (!(bh = sb_bread(sb, end - 1)))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Cannot read last block ("E3FSBLK")",
++ end - 1);
++ else if (outside(input->block_bitmap, start, end))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Block bitmap not in group (block %u)",
++ input->block_bitmap);
++ else if (outside(input->inode_bitmap, start, end))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Inode bitmap not in group (block %u)",
++ input->inode_bitmap);
++ else if (outside(input->inode_table, start, end) ||
++ outside(itend - 1, start, end))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Inode table not in group (blocks %u-"E3FSBLK")",
++ input->inode_table, itend - 1);
++ else if (input->inode_bitmap == input->block_bitmap)
++ ext3cow_warning(sb, __FUNCTION__,
++ "Block bitmap same as inode bitmap (%u)",
++ input->block_bitmap);
++ else if (inside(input->block_bitmap, input->inode_table, itend))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Block bitmap (%u) in inode table (%u-"E3FSBLK")",
++ input->block_bitmap, input->inode_table, itend-1);
++ else if (inside(input->inode_bitmap, input->inode_table, itend))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Inode bitmap (%u) in inode table (%u-"E3FSBLK")",
++ input->inode_bitmap, input->inode_table, itend-1);
++ else if (inside(input->block_bitmap, start, metaend))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Block bitmap (%u) in GDT table"
++ " ("E3FSBLK"-"E3FSBLK")",
++ input->block_bitmap, start, metaend - 1);
++ else if (inside(input->inode_bitmap, start, metaend))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Inode bitmap (%u) in GDT table"
++ " ("E3FSBLK"-"E3FSBLK")",
++ input->inode_bitmap, start, metaend - 1);
++ else if (inside(input->inode_table, start, metaend) ||
++ inside(itend - 1, start, metaend))
++ ext3cow_warning(sb, __FUNCTION__,
++ "Inode table (%u-"E3FSBLK") overlaps"
++ "GDT table ("E3FSBLK"-"E3FSBLK")",
++ input->inode_table, itend - 1, start, metaend - 1);
++ else
++ err = 0;
++ brelse(bh);
++
++ return err;
++}
++
++static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,
++ ext3cow_fsblk_t blk)
++{
++ struct buffer_head *bh;
++ int err;
++
++ bh = sb_getblk(sb, blk);
++ if (!bh)
++ return ERR_PTR(-EIO);
++ if ((err = ext3cow_journal_get_write_access(handle, bh))) {
++ brelse(bh);
++ bh = ERR_PTR(err);
++ } else {
++ lock_buffer(bh);
++ memset(bh->b_data, 0, sb->s_blocksize);
++ set_buffer_uptodate(bh);
++ unlock_buffer(bh);
++ }
++
++ return bh;
++}
++
++/*
++ * To avoid calling the atomic setbit hundreds or thousands of times, we only
++ * need to use it within a single byte (to ensure we get endianness right).
++ * We can use memset for the rest of the bitmap as there are no other users.
++ */
++static void mark_bitmap_end(int start_bit, int end_bit, char *bitmap)
++{
++ int i;
++
++ if (start_bit >= end_bit)
++ return;
++
++ ext3cow_debug("mark end bits +%d through +%d used\n", start_bit, end_bit);
++ for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++)
++ ext3cow_set_bit(i, bitmap);
++ if (i < end_bit)
++ memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
++}
++
++/*
++ * Set up the block and inode bitmaps, and the inode table for the new group.
++ * This doesn't need to be part of the main transaction, since we are only
++ * changing blocks outside the actual filesystem. We still do journaling to
++ * ensure the recovery is correct in case of a failure just after resize.
++ * If any part of this fails, we simply abort the resize.
++ */
++static int setup_new_group_blocks(struct super_block *sb,
++ struct ext3cow_new_group_data *input)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ ext3cow_fsblk_t start = ext3cow_group_first_block_no(sb, input->group);
++ int reserved_gdb = ext3cow_bg_has_super(sb, input->group) ?
++ le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0;
++ unsigned long gdblocks = ext3cow_bg_num_gdb(sb, input->group);
++ struct buffer_head *bh;
++ handle_t *handle;
++ ext3cow_fsblk_t block;
++ ext3cow_grpblk_t bit;
++ int i;
++ int err = 0, err2;
++
++ handle = ext3cow_journal_start_sb(sb, reserved_gdb + gdblocks +
++ 2 + sbi->s_itb_per_group);
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++
++ lock_super(sb);
++ if (input->group != sbi->s_groups_count) {
++ err = -EBUSY;
++ goto exit_journal;
++ }
++
++ if (IS_ERR(bh = bclean(handle, sb, input->block_bitmap))) {
++ err = PTR_ERR(bh);
++ goto exit_journal;
++ }
++
++ if (ext3cow_bg_has_super(sb, input->group)) {
++ ext3cow_debug("mark backup superblock %#04lx (+0)\n", start);
++ ext3cow_set_bit(0, bh->b_data);
++ }
++
++ /* Copy all of the GDT blocks into the backup in this group */
++ for (i = 0, bit = 1, block = start + 1;
++ i < gdblocks; i++, block++, bit++) {
++ struct buffer_head *gdb;
++
++ ext3cow_debug("update backup group %#04lx (+%d)\n", block, bit);
++
++ gdb = sb_getblk(sb, block);
++ if (!gdb) {
++ err = -EIO;
++ goto exit_bh;
++ }
++ if ((err = ext3cow_journal_get_write_access(handle, gdb))) {
++ brelse(gdb);
++ goto exit_bh;
++ }
++ lock_buffer(bh);
++ memcpy(gdb->b_data, sbi->s_group_desc[i]->b_data, bh->b_size);
++ set_buffer_uptodate(gdb);
++ unlock_buffer(bh);
++ ext3cow_journal_dirty_metadata(handle, gdb);
++ ext3cow_set_bit(bit, bh->b_data);
++ brelse(gdb);
++ }
++
++ /* Zero out all of the reserved backup group descriptor table blocks */
++ for (i = 0, bit = gdblocks + 1, block = start + bit;
++ i < reserved_gdb; i++, block++, bit++) {
++ struct buffer_head *gdb;
++
++ ext3cow_debug("clear reserved block %#04lx (+%d)\n", block, bit);
++
++ if (IS_ERR(gdb = bclean(handle, sb, block))) {
++ err = PTR_ERR(bh);
++ goto exit_bh;
++ }
++ ext3cow_journal_dirty_metadata(handle, gdb);
++ ext3cow_set_bit(bit, bh->b_data);
++ brelse(gdb);
++ }
++ ext3cow_debug("mark block bitmap %#04x (+%ld)\n", input->block_bitmap,
++ input->block_bitmap - start);
++ ext3cow_set_bit(input->block_bitmap - start, bh->b_data);
++ ext3cow_debug("mark inode bitmap %#04x (+%ld)\n", input->inode_bitmap,
++ input->inode_bitmap - start);
++ ext3cow_set_bit(input->inode_bitmap - start, bh->b_data);
++
++ /* Zero out all of the inode table blocks */
++ for (i = 0, block = input->inode_table, bit = block - start;
++ i < sbi->s_itb_per_group; i++, bit++, block++) {
++ struct buffer_head *it;
++
++ ext3cow_debug("clear inode block %#04lx (+%d)\n", block, bit);
++ if (IS_ERR(it = bclean(handle, sb, block))) {
++ err = PTR_ERR(it);
++ goto exit_bh;
++ }
++ ext3cow_journal_dirty_metadata(handle, it);
++ brelse(it);
++ ext3cow_set_bit(bit, bh->b_data);
++ }
++ mark_bitmap_end(input->blocks_count, EXT3COW_BLOCKS_PER_GROUP(sb),
++ bh->b_data);
++ ext3cow_journal_dirty_metadata(handle, bh);
++ brelse(bh);
++
++ /* Mark unused entries in inode bitmap used */
++ ext3cow_debug("clear inode bitmap %#04x (+%ld)\n",
++ input->inode_bitmap, input->inode_bitmap - start);
++ if (IS_ERR(bh = bclean(handle, sb, input->inode_bitmap))) {
++ err = PTR_ERR(bh);
++ goto exit_journal;
++ }
++
++ mark_bitmap_end(EXT3COW_INODES_PER_GROUP(sb), EXT3COW_BLOCKS_PER_GROUP(sb),
++ bh->b_data);
++ ext3cow_journal_dirty_metadata(handle, bh);
++exit_bh:
++ brelse(bh);
++
++exit_journal:
++ unlock_super(sb);
++ if ((err2 = ext3cow_journal_stop(handle)) && !err)
++ err = err2;
++
++ return err;
++}
++
++/*
++ * Iterate through the groups which hold BACKUP superblock/GDT copies in an
++ * ext3cow filesystem. The counters should be initialized to 1, 5, and 7 before
++ * calling this for the first time. In a sparse filesystem it will be the
++ * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ...
++ * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ...
++ */
++static unsigned ext3cow_list_backups(struct super_block *sb, unsigned *three,
++ unsigned *five, unsigned *seven)
++{
++ unsigned *min = three;
++ int mult = 3;
++ unsigned ret;
++
++ if (!EXT3COW_HAS_RO_COMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
++ ret = *min;
++ *min += 1;
++ return ret;
++ }
++
++ if (*five < *min) {
++ min = five;
++ mult = 5;
++ }
++ if (*seven < *min) {
++ min = seven;
++ mult = 7;
++ }
++
++ ret = *min;
++ *min *= mult;
++
++ return ret;
++}
++
++/*
++ * Check that all of the backup GDT blocks are held in the primary GDT block.
++ * It is assumed that they are stored in group order. Returns the number of
++ * groups in current filesystem that have BACKUPS, or -ve error code.
++ */
++static int verify_reserved_gdb(struct super_block *sb,
++ struct buffer_head *primary)
++{
++ const ext3cow_fsblk_t blk = primary->b_blocknr;
++ const unsigned long end = EXT3COW_SB(sb)->s_groups_count;
++ unsigned three = 1;
++ unsigned five = 5;
++ unsigned seven = 7;
++ unsigned grp;
++ __le32 *p = (__le32 *)primary->b_data;
++ int gdbackups = 0;
++
++ while ((grp = ext3cow_list_backups(sb, &three, &five, &seven)) < end) {
++ if (le32_to_cpu(*p++) != grp * EXT3COW_BLOCKS_PER_GROUP(sb) + blk){
++ ext3cow_warning(sb, __FUNCTION__,
++ "reserved GDT "E3FSBLK
++ " missing grp %d ("E3FSBLK")",
++ blk, grp,
++ grp * EXT3COW_BLOCKS_PER_GROUP(sb) + blk);
++ return -EINVAL;
++ }
++ if (++gdbackups > EXT3COW_ADDR_PER_BLOCK(sb))
++ return -EFBIG;
++ }
++
++ return gdbackups;
++}
++
++/*
++ * Called when we need to bring a reserved group descriptor table block into
++ * use from the resize inode. The primary copy of the new GDT block currently
++ * is an indirect block (under the double indirect block in the resize inode).
++ * The new backup GDT blocks will be stored as leaf blocks in this indirect
++ * block, in group order. Even though we know all the block numbers we need,
++ * we check to ensure that the resize inode has actually reserved these blocks.
++ *
++ * Don't need to update the block bitmaps because the blocks are still in use.
++ *
++ * We get all of the error cases out of the way, so that we are sure to not
++ * fail once we start modifying the data on disk, because JBD has no rollback.
++ */
++static int add_new_gdb(handle_t *handle, struct inode *inode,
++ struct ext3cow_new_group_data *input,
++ struct buffer_head **primary)
++{
++ struct super_block *sb = inode->i_sb;
++ struct ext3cow_super_block *es = EXT3COW_SB(sb)->s_es;
++ unsigned long gdb_num = input->group / EXT3COW_DESC_PER_BLOCK(sb);
++ ext3cow_fsblk_t gdblock = EXT3COW_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num;
++ struct buffer_head **o_group_desc, **n_group_desc;
++ struct buffer_head *dind;
++ int gdbackups;
++ struct ext3cow_iloc iloc;
++ __le32 *data;
++ int err;
++
++ if (test_opt(sb, DEBUG))
++ printk(KERN_DEBUG
++ "EXT3COW-fs: ext3cow_add_new_gdb: adding group block %lu\n",
++ gdb_num);
++
++ /*
++ * If we are not using the primary superblock/GDT copy don't resize,
++ * because the user tools have no way of handling this. Probably a
++ * bad time to do it anyways.
++ */
++ if (EXT3COW_SB(sb)->s_sbh->b_blocknr !=
++ le32_to_cpu(EXT3COW_SB(sb)->s_es->s_first_data_block)) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "won't resize using backup superblock at %llu",
++ (unsigned long long)EXT3COW_SB(sb)->s_sbh->b_blocknr);
++ return -EPERM;
++ }
++
++ *primary = sb_bread(sb, gdblock);
++ if (!*primary)
++ return -EIO;
++
++ if ((gdbackups = verify_reserved_gdb(sb, *primary)) < 0) {
++ err = gdbackups;
++ goto exit_bh;
++ }
++
++ data = EXT3COW_I(inode)->i_data + EXT3COW_DIND_BLOCK;
++ dind = sb_bread(sb, le32_to_cpu(*data));
++ if (!dind) {
++ err = -EIO;
++ goto exit_bh;
++ }
++
++ data = (__le32 *)dind->b_data;
++ if (le32_to_cpu(data[gdb_num % EXT3COW_ADDR_PER_BLOCK(sb)]) != gdblock) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "new group %u GDT block "E3FSBLK" not reserved",
++ input->group, gdblock);
++ err = -EINVAL;
++ goto exit_dind;
++ }
++
++ if ((err = ext3cow_journal_get_write_access(handle, EXT3COW_SB(sb)->s_sbh)))
++ goto exit_dind;
++
++ if ((err = ext3cow_journal_get_write_access(handle, *primary)))
++ goto exit_sbh;
++
++ if ((err = ext3cow_journal_get_write_access(handle, dind)))
++ goto exit_primary;
++
++ /* ext3cow_reserve_inode_write() gets a reference on the iloc */
++ if ((err = ext3cow_reserve_inode_write(handle, inode, &iloc)))
++ goto exit_dindj;
++
++ n_group_desc = kmalloc((gdb_num + 1) * sizeof(struct buffer_head *),
++ GFP_KERNEL);
++ if (!n_group_desc) {
++ err = -ENOMEM;
++ ext3cow_warning (sb, __FUNCTION__,
++ "not enough memory for %lu groups", gdb_num + 1);
++ goto exit_inode;
++ }
++
++ /*
++ * Finally, we have all of the possible failures behind us...
++ *
++ * Remove new GDT block from inode double-indirect block and clear out
++ * the new GDT block for use (which also "frees" the backup GDT blocks
++ * from the reserved inode). We don't need to change the bitmaps for
++ * these blocks, because they are marked as in-use from being in the
++ * reserved inode, and will become GDT blocks (primary and backup).
++ */
++ data[gdb_num % EXT3COW_ADDR_PER_BLOCK(sb)] = 0;
++ ext3cow_journal_dirty_metadata(handle, dind);
++ brelse(dind);
++ inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9;
++ ext3cow_mark_iloc_dirty(handle, inode, &iloc);
++ memset((*primary)->b_data, 0, sb->s_blocksize);
++ ext3cow_journal_dirty_metadata(handle, *primary);
++
++ o_group_desc = EXT3COW_SB(sb)->s_group_desc;
++ memcpy(n_group_desc, o_group_desc,
++ EXT3COW_SB(sb)->s_gdb_count * sizeof(struct buffer_head *));
++ n_group_desc[gdb_num] = *primary;
++ EXT3COW_SB(sb)->s_group_desc = n_group_desc;
++ EXT3COW_SB(sb)->s_gdb_count++;
++ kfree(o_group_desc);
++
++ es->s_reserved_gdt_blocks =
++ cpu_to_le16(le16_to_cpu(es->s_reserved_gdt_blocks) - 1);
++ ext3cow_journal_dirty_metadata(handle, EXT3COW_SB(sb)->s_sbh);
++
++ return 0;
++
++exit_inode:
++ //ext3cow_journal_release_buffer(handle, iloc.bh);
++ brelse(iloc.bh);
++exit_dindj:
++ //ext3cow_journal_release_buffer(handle, dind);
++exit_primary:
++ //ext3cow_journal_release_buffer(handle, *primary);
++exit_sbh:
++ //ext3cow_journal_release_buffer(handle, *primary);
++exit_dind:
++ brelse(dind);
++exit_bh:
++ brelse(*primary);
++
++ ext3cow_debug("leaving with error %d\n", err);
++ return err;
++}
++
++/*
++ * Called when we are adding a new group which has a backup copy of each of
++ * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks.
++ * We need to add these reserved backup GDT blocks to the resize inode, so
++ * that they are kept for future resizing and not allocated to files.
++ *
++ * Each reserved backup GDT block will go into a different indirect block.
++ * The indirect blocks are actually the primary reserved GDT blocks,
++ * so we know in advance what their block numbers are. We only get the
++ * double-indirect block to verify it is pointing to the primary reserved
++ * GDT blocks so we don't overwrite a data block by accident. The reserved
++ * backup GDT blocks are stored in their reserved primary GDT block.
++ */
++static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
++ struct ext3cow_new_group_data *input)
++{
++ struct super_block *sb = inode->i_sb;
++ int reserved_gdb =le16_to_cpu(EXT3COW_SB(sb)->s_es->s_reserved_gdt_blocks);
++ struct buffer_head **primary;
++ struct buffer_head *dind;
++ struct ext3cow_iloc iloc;
++ ext3cow_fsblk_t blk;
++ __le32 *data, *end;
++ int gdbackups = 0;
++ int res, i;
++ int err;
++
++ primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_KERNEL);
++ if (!primary)
++ return -ENOMEM;
++
++ data = EXT3COW_I(inode)->i_data + EXT3COW_DIND_BLOCK;
++ dind = sb_bread(sb, le32_to_cpu(*data));
++ if (!dind) {
++ err = -EIO;
++ goto exit_free;
++ }
++
++ blk = EXT3COW_SB(sb)->s_sbh->b_blocknr + 1 + EXT3COW_SB(sb)->s_gdb_count;
++ data = (__le32 *)dind->b_data + EXT3COW_SB(sb)->s_gdb_count;
++ end = (__le32 *)dind->b_data + EXT3COW_ADDR_PER_BLOCK(sb);
++
++ /* Get each reserved primary GDT block and verify it holds backups */
++ for (res = 0; res < reserved_gdb; res++, blk++) {
++ if (le32_to_cpu(*data) != blk) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "reserved block "E3FSBLK
++ " not at offset %ld",
++ blk,
++ (long)(data - (__le32 *)dind->b_data));
++ err = -EINVAL;
++ goto exit_bh;
++ }
++ primary[res] = sb_bread(sb, blk);
++ if (!primary[res]) {
++ err = -EIO;
++ goto exit_bh;
++ }
++ if ((gdbackups = verify_reserved_gdb(sb, primary[res])) < 0) {
++ brelse(primary[res]);
++ err = gdbackups;
++ goto exit_bh;
++ }
++ if (++data >= end)
++ data = (__le32 *)dind->b_data;
++ }
++
++ for (i = 0; i < reserved_gdb; i++) {
++ if ((err = ext3cow_journal_get_write_access(handle, primary[i]))) {
++ /*
++ int j;
++ for (j = 0; j < i; j++)
++ ext3cow_journal_release_buffer(handle, primary[j]);
++ */
++ goto exit_bh;
++ }
++ }
++
++ if ((err = ext3cow_reserve_inode_write(handle, inode, &iloc)))
++ goto exit_bh;
++
++ /*
++ * Finally we can add each of the reserved backup GDT blocks from
++ * the new group to its reserved primary GDT block.
++ */
++ blk = input->group * EXT3COW_BLOCKS_PER_GROUP(sb);
++ for (i = 0; i < reserved_gdb; i++) {
++ int err2;
++ data = (__le32 *)primary[i]->b_data;
++ /* printk("reserving backup %lu[%u] = %lu\n",
++ primary[i]->b_blocknr, gdbackups,
++ blk + primary[i]->b_blocknr); */
++ data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr);
++ err2 = ext3cow_journal_dirty_metadata(handle, primary[i]);
++ if (!err)
++ err = err2;
++ }
++ inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9;
++ ext3cow_mark_iloc_dirty(handle, inode, &iloc);
++
++exit_bh:
++ while (--res >= 0)
++ brelse(primary[res]);
++ brelse(dind);
++
++exit_free:
++ kfree(primary);
++
++ return err;
++}
++
++/*
++ * Update the backup copies of the ext3cow metadata. These don't need to be part
++ * of the main resize transaction, because e2fsck will re-write them if there
++ * is a problem (basically only OOM will cause a problem). However, we
++ * _should_ update the backups if possible, in case the primary gets trashed
++ * for some reason and we need to run e2fsck from a backup superblock. The
++ * important part is that the new block and inode counts are in the backup
++ * superblocks, and the location of the new group metadata in the GDT backups.
++ *
++ * We do not need lock_super() for this, because these blocks are not
++ * otherwise touched by the filesystem code when it is mounted. We don't
++ * need to worry about last changing from sbi->s_groups_count, because the
++ * worst that can happen is that we do not copy the full number of backups
++ * at this time. The resize which changed s_groups_count will backup again.
++ */
++static void update_backups(struct super_block *sb,
++ int blk_off, char *data, int size)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ const unsigned long last = sbi->s_groups_count;
++ const int bpg = EXT3COW_BLOCKS_PER_GROUP(sb);
++ unsigned three = 1;
++ unsigned five = 5;
++ unsigned seven = 7;
++ unsigned group;
++ int rest = sb->s_blocksize - size;
++ handle_t *handle;
++ int err = 0, err2;
++
++ handle = ext3cow_journal_start_sb(sb, EXT3COW_MAX_TRANS_DATA);
++ if (IS_ERR(handle)) {
++ group = 1;
++ err = PTR_ERR(handle);
++ goto exit_err;
++ }
++
++ while ((group = ext3cow_list_backups(sb, &three, &five, &seven)) < last) {
++ struct buffer_head *bh;
++
++ /* Out of journal space, and can't get more - abort - so sad */
++ if (handle->h_buffer_credits == 0 &&
++ ext3cow_journal_extend(handle, EXT3COW_MAX_TRANS_DATA) &&
++ (err = ext3cow_journal_restart(handle, EXT3COW_MAX_TRANS_DATA)))
++ break;
++
++ bh = sb_getblk(sb, group * bpg + blk_off);
++ if (!bh) {
++ err = -EIO;
++ break;
++ }
++ ext3cow_debug("update metadata backup %#04lx\n",
++ (unsigned long)bh->b_blocknr);
++ if ((err = ext3cow_journal_get_write_access(handle, bh)))
++ break;
++ lock_buffer(bh);
++ memcpy(bh->b_data, data, size);
++ if (rest)
++ memset(bh->b_data + size, 0, rest);
++ set_buffer_uptodate(bh);
++ unlock_buffer(bh);
++ ext3cow_journal_dirty_metadata(handle, bh);
++ brelse(bh);
++ }
++ if ((err2 = ext3cow_journal_stop(handle)) && !err)
++ err = err2;
++
++ /*
++ * Ugh! Need to have e2fsck write the backup copies. It is too
++ * late to revert the resize, we shouldn't fail just because of
++ * the backup copies (they are only needed in case of corruption).
++ *
++ * However, if we got here we have a journal problem too, so we
++ * can't really start a transaction to mark the superblock.
++ * Chicken out and just set the flag on the hope it will be written
++ * to disk, and if not - we will simply wait until next fsck.
++ */
++exit_err:
++ if (err) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "can't update backup for group %d (err %d), "
++ "forcing fsck on next reboot", group, err);
++ sbi->s_mount_state &= ~EXT3COW_VALID_FS;
++ sbi->s_es->s_state &= cpu_to_le16(~EXT3COW_VALID_FS);
++ mark_buffer_dirty(sbi->s_sbh);
++ }
++}
++
++/* Add group descriptor data to an existing or new group descriptor block.
++ * Ensure we handle all possible error conditions _before_ we start modifying
++ * the filesystem, because we cannot abort the transaction and not have it
++ * write the data to disk.
++ *
++ * If we are on a GDT block boundary, we need to get the reserved GDT block.
++ * Otherwise, we may need to add backup GDT blocks for a sparse group.
++ *
++ * We only need to hold the superblock lock while we are actually adding
++ * in the new group's counts to the superblock. Prior to that we have
++ * not really "added" the group at all. We re-check that we are still
++ * adding in the last group in case things have changed since verifying.
++ */
++int ext3cow_group_add(struct super_block *sb, struct ext3cow_new_group_data *input)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ struct ext3cow_super_block *es = sbi->s_es;
++ int reserved_gdb = ext3cow_bg_has_super(sb, input->group) ?
++ le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
++ struct buffer_head *primary = NULL;
++ struct ext3cow_group_desc *gdp;
++ struct inode *inode = NULL;
++ handle_t *handle;
++ int gdb_off, gdb_num;
++ int err, err2;
++
++ gdb_num = input->group / EXT3COW_DESC_PER_BLOCK(sb);
++ gdb_off = input->group % EXT3COW_DESC_PER_BLOCK(sb);
++
++ if (gdb_off == 0 && !EXT3COW_HAS_RO_COMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "Can't resize non-sparse filesystem further");
++ return -EPERM;
++ }
++
++ if (le32_to_cpu(es->s_blocks_count) + input->blocks_count <
++ le32_to_cpu(es->s_blocks_count)) {
++ ext3cow_warning(sb, __FUNCTION__, "blocks_count overflow\n");
++ return -EINVAL;
++ }
++
++ if (le32_to_cpu(es->s_inodes_count) + EXT3COW_INODES_PER_GROUP(sb) <
++ le32_to_cpu(es->s_inodes_count)) {
++ ext3cow_warning(sb, __FUNCTION__, "inodes_count overflow\n");
++ return -EINVAL;
++ }
++
++ if (reserved_gdb || gdb_off == 0) {
++ if (!EXT3COW_HAS_COMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_COMPAT_RESIZE_INODE)){
++ ext3cow_warning(sb, __FUNCTION__,
++ "No reserved GDT blocks, can't resize");
++ return -EPERM;
++ }
++ inode = iget(sb, EXT3COW_RESIZE_INO);
++ if (!inode || is_bad_inode(inode)) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "Error opening resize inode");
++ iput(inode);
++ return -ENOENT;
++ }
++ }
++
++ if ((err = verify_group_input(sb, input)))
++ goto exit_put;
++
++ if ((err = setup_new_group_blocks(sb, input)))
++ goto exit_put;
++
++ /*
++ * We will always be modifying at least the superblock and a GDT
++ * block. If we are adding a group past the last current GDT block,
++ * we will also modify the inode and the dindirect block. If we
++ * are adding a group with superblock/GDT backups we will also
++ * modify each of the reserved GDT dindirect blocks.
++ */
++ handle = ext3cow_journal_start_sb(sb,
++ ext3cow_bg_has_super(sb, input->group) ?
++ 3 + reserved_gdb : 4);
++ if (IS_ERR(handle)) {
++ err = PTR_ERR(handle);
++ goto exit_put;
++ }
++
++ lock_super(sb);
++ if (input->group != sbi->s_groups_count) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "multiple resizers run on filesystem!");
++ err = -EBUSY;
++ goto exit_journal;
++ }
++
++ if ((err = ext3cow_journal_get_write_access(handle, sbi->s_sbh)))
++ goto exit_journal;
++
++ /*
++ * We will only either add reserved group blocks to a backup group
++ * or remove reserved blocks for the first group in a new group block.
++ * Doing both would be mean more complex code, and sane people don't
++ * use non-sparse filesystems anymore. This is already checked above.
++ */
++ if (gdb_off) {
++ primary = sbi->s_group_desc[gdb_num];
++ if ((err = ext3cow_journal_get_write_access(handle, primary)))
++ goto exit_journal;
++
++ if (reserved_gdb && ext3cow_bg_num_gdb(sb, input->group) &&
++ (err = reserve_backup_gdb(handle, inode, input)))
++ goto exit_journal;
++ } else if ((err = add_new_gdb(handle, inode, input, &primary)))
++ goto exit_journal;
++
++ /*
++ * OK, now we've set up the new group. Time to make it active.
++ *
++ * Current kernels don't lock all allocations via lock_super(),
++ * so we have to be safe wrt. concurrent accesses the group
++ * data. So we need to be careful to set all of the relevant
++ * group descriptor data etc. *before* we enable the group.
++ *
++ * The key field here is sbi->s_groups_count: as long as
++ * that retains its old value, nobody is going to access the new
++ * group.
++ *
++ * So first we update all the descriptor metadata for the new
++ * group; then we update the total disk blocks count; then we
++ * update the groups count to enable the group; then finally we
++ * update the free space counts so that the system can start
++ * using the new disk blocks.
++ */
++
++ /* Update group descriptor block for new group */
++ gdp = (struct ext3cow_group_desc *)primary->b_data + gdb_off;
++
++ gdp->bg_block_bitmap = cpu_to_le32(input->block_bitmap);
++ gdp->bg_inode_bitmap = cpu_to_le32(input->inode_bitmap);
++ gdp->bg_inode_table = cpu_to_le32(input->inode_table);
++ gdp->bg_free_blocks_count = cpu_to_le16(input->free_blocks_count);
++ gdp->bg_free_inodes_count = cpu_to_le16(EXT3COW_INODES_PER_GROUP(sb));
++
++ /*
++ * Make the new blocks and inodes valid next. We do this before
++ * increasing the group count so that once the group is enabled,
++ * all of its blocks and inodes are already valid.
++ *
++ * We always allocate group-by-group, then block-by-block or
++ * inode-by-inode within a group, so enabling these
++ * blocks/inodes before the group is live won't actually let us
++ * allocate the new space yet.
++ */
++ es->s_blocks_count = cpu_to_le32(le32_to_cpu(es->s_blocks_count) +
++ input->blocks_count);
++ es->s_inodes_count = cpu_to_le32(le32_to_cpu(es->s_inodes_count) +
++ EXT3COW_INODES_PER_GROUP(sb));
++
++ /*
++ * We need to protect s_groups_count against other CPUs seeing
++ * inconsistent state in the superblock.
++ *
++ * The precise rules we use are:
++ *
++ * * Writers of s_groups_count *must* hold lock_super
++ * AND
++ * * Writers must perform a smp_wmb() after updating all dependent
++ * data and before modifying the groups count
++ *
++ * * Readers must hold lock_super() over the access
++ * OR
++ * * Readers must perform an smp_rmb() after reading the groups count
++ * and before reading any dependent data.
++ *
++ * NB. These rules can be relaxed when checking the group count
++ * while freeing data, as we can only allocate from a block
++ * group after serialising against the group count, and we can
++ * only then free after serialising in turn against that
++ * allocation.
++ */
++ smp_wmb();
++
++ /* Update the global fs size fields */
++ sbi->s_groups_count++;
++
++ ext3cow_journal_dirty_metadata(handle, primary);
++
++ /* Update the reserved block counts only once the new group is
++ * active. */
++ es->s_r_blocks_count = cpu_to_le32(le32_to_cpu(es->s_r_blocks_count) +
++ input->reserved_blocks);
++
++ /* Update the free space counts */
++ percpu_counter_mod(&sbi->s_freeblocks_counter,
++ input->free_blocks_count);
++ percpu_counter_mod(&sbi->s_freeinodes_counter,
++ EXT3COW_INODES_PER_GROUP(sb));
++
++ ext3cow_journal_dirty_metadata(handle, sbi->s_sbh);
++ sb->s_dirt = 1;
++
++exit_journal:
++ unlock_super(sb);
++ if ((err2 = ext3cow_journal_stop(handle)) && !err)
++ err = err2;
++ if (!err) {
++ update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es,
++ sizeof(struct ext3cow_super_block));
++ update_backups(sb, primary->b_blocknr, primary->b_data,
++ primary->b_size);
++ }
++exit_put:
++ iput(inode);
++ return err;
++} /* ext3cow_group_add */
++
++/* Extend the filesystem to the new number of blocks specified. This entry
++ * point is only used to extend the current filesystem to the end of the last
++ * existing group. It can be accessed via ioctl, or by "remount,resize="
++ * for emergencies (because it has no dependencies on reserved blocks).
++ *
++ * If we _really_ wanted, we could use default values to call ext3cow_group_add()
++ * allow the "remount" trick to work for arbitrary resizing, assuming enough
++ * GDT blocks are reserved to grow to the desired size.
++ */
++int ext3cow_group_extend(struct super_block *sb, struct ext3cow_super_block *es,
++ ext3cow_fsblk_t n_blocks_count)
++{
++ ext3cow_fsblk_t o_blocks_count;
++ unsigned long o_groups_count;
++ ext3cow_grpblk_t last;
++ ext3cow_grpblk_t add;
++ struct buffer_head * bh;
++ handle_t *handle;
++ int err;
++ unsigned long freed_blocks;
++
++ /* We don't need to worry about locking wrt other resizers just
++ * yet: we're going to revalidate es->s_blocks_count after
++ * taking lock_super() below. */
++ o_blocks_count = le32_to_cpu(es->s_blocks_count);
++ o_groups_count = EXT3COW_SB(sb)->s_groups_count;
++
++ if (test_opt(sb, DEBUG))
++ printk(KERN_DEBUG "EXT3COW-fs: extending last group from "E3FSBLK" uto "E3FSBLK" blocks\n",
++ o_blocks_count, n_blocks_count);
++
++ if (n_blocks_count == 0 || n_blocks_count == o_blocks_count)
++ return 0;
++
++ if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
++ printk(KERN_ERR "EXT3COW-fs: filesystem on %s:"
++ " too large to resize to %lu blocks safely\n",
++ sb->s_id, n_blocks_count);
++ if (sizeof(sector_t) < 8)
++ ext3cow_warning(sb, __FUNCTION__,
++ "CONFIG_LBD not enabled\n");
++ return -EINVAL;
++ }
++
++ if (n_blocks_count < o_blocks_count) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "can't shrink FS - resize aborted");
++ return -EBUSY;
++ }
++
++ /* Handle the remaining blocks in the last group only. */
++ last = (o_blocks_count - le32_to_cpu(es->s_first_data_block)) %
++ EXT3COW_BLOCKS_PER_GROUP(sb);
++
++ if (last == 0) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "need to use ext2online to resize further");
++ return -EPERM;
++ }
++
++ add = EXT3COW_BLOCKS_PER_GROUP(sb) - last;
++
++ if (o_blocks_count + add < o_blocks_count) {
++ ext3cow_warning(sb, __FUNCTION__, "blocks_count overflow");
++ return -EINVAL;
++ }
++
++ if (o_blocks_count + add > n_blocks_count)
++ add = n_blocks_count - o_blocks_count;
++
++ if (o_blocks_count + add < n_blocks_count)
++ ext3cow_warning(sb, __FUNCTION__,
++ "will only finish group ("E3FSBLK
++ " blocks, %u new)",
++ o_blocks_count + add, add);
++
++ /* See if the device is actually as big as what was requested */
++ bh = sb_bread(sb, o_blocks_count + add -1);
++ if (!bh) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "can't read last block, resize aborted");
++ return -ENOSPC;
++ }
++ brelse(bh);
++
++ /* We will update the superblock, one block bitmap, and
++ * one group descriptor via ext3cow_free_blocks().
++ */
++ handle = ext3cow_journal_start_sb(sb, 3);
++ if (IS_ERR(handle)) {
++ err = PTR_ERR(handle);
++ ext3cow_warning(sb, __FUNCTION__, "error %d on journal start",err);
++ goto exit_put;
++ }
++
++ lock_super(sb);
++ if (o_blocks_count != le32_to_cpu(es->s_blocks_count)) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "multiple resizers run on filesystem!");
++ unlock_super(sb);
++ err = -EBUSY;
++ goto exit_put;
++ }
++
++ if ((err = ext3cow_journal_get_write_access(handle,
++ EXT3COW_SB(sb)->s_sbh))) {
++ ext3cow_warning(sb, __FUNCTION__,
++ "error %d on journal write access", err);
++ unlock_super(sb);
++ ext3cow_journal_stop(handle);
++ goto exit_put;
++ }
++ es->s_blocks_count = cpu_to_le32(o_blocks_count + add);
++ ext3cow_journal_dirty_metadata(handle, EXT3COW_SB(sb)->s_sbh);
++ sb->s_dirt = 1;
++ unlock_super(sb);
++ ext3cow_debug("freeing blocks %lu through "E3FSBLK"\n", o_blocks_count,
++ o_blocks_count + add);
++ ext3cow_free_blocks_sb(handle, sb, o_blocks_count, add, &freed_blocks);
++ ext3cow_debug("freed blocks "E3FSBLK" through "E3FSBLK"\n", o_blocks_count,
++ o_blocks_count + add);
++ if ((err = ext3cow_journal_stop(handle)))
++ goto exit_put;
++ if (test_opt(sb, DEBUG))
++ printk(KERN_DEBUG "EXT3COW-fs: extended group to %u blocks\n",
++ le32_to_cpu(es->s_blocks_count));
++ update_backups(sb, EXT3COW_SB(sb)->s_sbh->b_blocknr, (char *)es,
++ sizeof(struct ext3cow_super_block));
++exit_put:
++ return err;
++} /* ext3cow_group_extend */
+diff -ruN linux-2.6.20.3/fs/ext3cow/super.c linux-2.6.20.3-ext3cow/fs/ext3cow/super.c
+--- linux-2.6.20.3/fs/ext3cow/super.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/super.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,2808 @@
++/*
++ * linux/fs/ext3cow/super.c
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/fs/minix/inode.c
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ *
++ * Big-endian to little-endian byte-swapping/bitmaps by
++ * David S. Miller (davem@caip.rutgers.edu), 1995
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++
++#include
++
++#include "xattr.h"
++#include "acl.h"
++#include "namei.h"
++
++static int ext3cow_load_journal(struct super_block *, struct ext3cow_super_block *,
++ unsigned long journal_devnum);
++static int ext3cow_create_journal(struct super_block *, struct ext3cow_super_block *,
++ unsigned int);
++static void ext3cow_commit_super (struct super_block * sb,
++ struct ext3cow_super_block * es,
++ int sync);
++static void ext3cow_mark_recovery_complete(struct super_block * sb,
++ struct ext3cow_super_block * es);
++static void ext3cow_clear_journal_err(struct super_block * sb,
++ struct ext3cow_super_block * es);
++static int ext3cow_sync_fs(struct super_block *sb, int wait);
++static const char *ext3cow_decode_error(struct super_block * sb, int errno,
++ char nbuf[16]);
++static int ext3cow_remount (struct super_block * sb, int * flags, char * data);
++static int ext3cow_statfs (struct dentry * dentry, struct kstatfs * buf);
++static void ext3cow_unlockfs(struct super_block *sb);
++static void ext3cow_write_super (struct super_block * sb);
++static void ext3cow_write_super_lockfs(struct super_block *sb);
++
++/*
++ * Wrappers for journal_start/end.
++ *
++ * The only special thing we need to do here is to make sure that all
++ * journal_end calls result in the superblock being marked dirty, so
++ * that sync() will call the filesystem's write_super callback if
++ * appropriate.
++ */
++handle_t *ext3cow_journal_start_sb(struct super_block *sb, int nblocks)
++{
++ journal_t *journal;
++
++ if (sb->s_flags & MS_RDONLY)
++ return ERR_PTR(-EROFS);
++
++ /* Special case here: if the journal has aborted behind our
++ * backs (eg. EIO in the commit thread), then we still need to
++ * take the FS itself readonly cleanly. */
++ journal = EXT3COW_SB(sb)->s_journal;
++ if (is_journal_aborted(journal)) {
++ ext3cow_abort(sb, __FUNCTION__,
++ "Detected aborted journal");
++ return ERR_PTR(-EROFS);
++ }
++
++ return journal_start(journal, nblocks);
++}
++
++/*
++ * The only special thing we need to do here is to make sure that all
++ * journal_stop calls result in the superblock being marked dirty, so
++ * that sync() will call the filesystem's write_super callback if
++ * appropriate.
++ */
++int __ext3cow_journal_stop(const char *where, handle_t *handle)
++{
++ struct super_block *sb;
++ int err;
++ int rc;
++
++ sb = handle->h_transaction->t_journal->j_private;
++ err = handle->h_err;
++ rc = journal_stop(handle);
++
++ if (!err)
++ err = rc;
++ if (err)
++ __ext3cow_std_error(sb, where, err);
++ return err;
++}
++
++void ext3cow_journal_abort_handle(const char *caller, const char *err_fn,
++ struct buffer_head *bh, handle_t *handle, int err)
++{
++ char nbuf[16];
++ const char *errstr = ext3cow_decode_error(NULL, err, nbuf);
++
++ if (bh)
++ BUFFER_TRACE(bh, "abort");
++
++ if (!handle->h_err)
++ handle->h_err = err;
++
++ if (is_handle_aborted(handle))
++ return;
++
++ printk(KERN_ERR "%s: aborting transaction: %s in %s\n",
++ caller, errstr, err_fn);
++
++ journal_abort_handle(handle);
++}
++
++/* Deal with the reporting of failure conditions on a filesystem such as
++ * inconsistencies detected or read IO failures.
++ *
++ * On ext2, we can store the error state of the filesystem in the
++ * superblock. That is not possible on ext3cow, because we may have other
++ * write ordering constraints on the superblock which prevent us from
++ * writing it out straight away; and given that the journal is about to
++ * be aborted, we can't rely on the current, or future, transactions to
++ * write out the superblock safely.
++ *
++ * We'll just use the journal_abort() error code to record an error in
++ * the journal instead. On recovery, the journal will compain about
++ * that error until we've noted it down and cleared it.
++ */
++
++static void ext3cow_handle_error(struct super_block *sb)
++{
++ struct ext3cow_super_block *es = EXT3COW_SB(sb)->s_es;
++
++ EXT3COW_SB(sb)->s_mount_state |= EXT3COW_ERROR_FS;
++ es->s_state |= cpu_to_le16(EXT3COW_ERROR_FS);
++
++ if (sb->s_flags & MS_RDONLY)
++ return;
++
++ if (!test_opt (sb, ERRORS_CONT)) {
++ journal_t *journal = EXT3COW_SB(sb)->s_journal;
++
++ EXT3COW_SB(sb)->s_mount_opt |= EXT3COW_MOUNT_ABORT;
++ if (journal)
++ journal_abort(journal, -EIO);
++ }
++ if (test_opt (sb, ERRORS_RO)) {
++ printk (KERN_CRIT "Remounting filesystem read-only\n");
++ sb->s_flags |= MS_RDONLY;
++ }
++ ext3cow_commit_super(sb, es, 1);
++ if (test_opt(sb, ERRORS_PANIC))
++ panic("EXT3COW-fs (device %s): panic forced after error\n",
++ sb->s_id);
++}
++
++void ext3cow_error (struct super_block * sb, const char * function,
++ const char * fmt, ...)
++{
++ va_list args;
++
++ va_start(args, fmt);
++ printk(KERN_CRIT "EXT3COW-fs error (device %s): %s: ",sb->s_id, function);
++ vprintk(fmt, args);
++ printk("\n");
++ va_end(args);
++
++ ext3cow_handle_error(sb);
++}
++
++static const char *ext3cow_decode_error(struct super_block * sb, int errno,
++ char nbuf[16])
++{
++ char *errstr = NULL;
++
++ switch (errno) {
++ case -EIO:
++ errstr = "IO failure";
++ break;
++ case -ENOMEM:
++ errstr = "Out of memory";
++ break;
++ case -EROFS:
++ if (!sb || EXT3COW_SB(sb)->s_journal->j_flags & JFS_ABORT)
++ errstr = "Journal has aborted";
++ else
++ errstr = "Readonly filesystem";
++ break;
++ default:
++ /* If the caller passed in an extra buffer for unknown
++ * errors, textualise them now. Else we just return
++ * NULL. */
++ if (nbuf) {
++ /* Check for truncated error codes... */
++ if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
++ errstr = nbuf;
++ }
++ break;
++ }
++
++ return errstr;
++}
++
++/* __ext3cow_std_error decodes expected errors from journaling functions
++ * automatically and invokes the appropriate error response. */
++
++void __ext3cow_std_error (struct super_block * sb, const char * function,
++ int errno)
++{
++ char nbuf[16];
++ const char *errstr;
++
++ /* Special case: if the error is EROFS, and we're not already
++ * inside a transaction, then there's really no point in logging
++ * an error. */
++ if (errno == -EROFS && journal_current_handle() == NULL &&
++ (sb->s_flags & MS_RDONLY))
++ return;
++
++ errstr = ext3cow_decode_error(sb, errno, nbuf);
++ printk (KERN_CRIT "EXT3COW-fs error (device %s) in %s: %s\n",
++ sb->s_id, function, errstr);
++
++ ext3cow_handle_error(sb);
++}
++
++/*
++ * ext3cow_abort is a much stronger failure handler than ext3cow_error. The
++ * abort function may be used to deal with unrecoverable failures such
++ * as journal IO errors or ENOMEM at a critical moment in log management.
++ *
++ * We unconditionally force the filesystem into an ABORT|READONLY state,
++ * unless the error response on the fs has been set to panic in which
++ * case we take the easy way out and panic immediately.
++ */
++
++void ext3cow_abort (struct super_block * sb, const char * function,
++ const char * fmt, ...)
++{
++ va_list args;
++
++ printk (KERN_CRIT "ext3cow_abort called.\n");
++
++ va_start(args, fmt);
++ printk(KERN_CRIT "EXT3COW-fs error (device %s): %s: ",sb->s_id, function);
++ vprintk(fmt, args);
++ printk("\n");
++ va_end(args);
++
++ if (test_opt(sb, ERRORS_PANIC))
++ panic("EXT3COW-fs panic from previous error\n");
++
++ if (sb->s_flags & MS_RDONLY)
++ return;
++
++ printk(KERN_CRIT "Remounting filesystem read-only\n");
++ EXT3COW_SB(sb)->s_mount_state |= EXT3COW_ERROR_FS;
++ sb->s_flags |= MS_RDONLY;
++ EXT3COW_SB(sb)->s_mount_opt |= EXT3COW_MOUNT_ABORT;
++ journal_abort(EXT3COW_SB(sb)->s_journal, -EIO);
++}
++
++void ext3cow_warning (struct super_block * sb, const char * function,
++ const char * fmt, ...)
++{
++ va_list args;
++
++ va_start(args, fmt);
++ printk(KERN_WARNING "EXT3COW-fs warning (device %s): %s: ",
++ sb->s_id, function);
++ vprintk(fmt, args);
++ printk("\n");
++ va_end(args);
++}
++
++void ext3cow_update_dynamic_rev(struct super_block *sb)
++{
++ struct ext3cow_super_block *es = EXT3COW_SB(sb)->s_es;
++
++ if (le32_to_cpu(es->s_rev_level) > EXT3COW_GOOD_OLD_REV)
++ return;
++
++ ext3cow_warning(sb, __FUNCTION__,
++ "updating to rev %d because of new feature flag, "
++ "running e2fsck is recommended",
++ EXT3COW_DYNAMIC_REV);
++
++ es->s_first_ino = cpu_to_le32(EXT3COW_GOOD_OLD_FIRST_INO);
++ es->s_inode_size = cpu_to_le16(EXT3COW_GOOD_OLD_INODE_SIZE);
++ es->s_rev_level = cpu_to_le32(EXT3COW_DYNAMIC_REV);
++ /* leave es->s_feature_*compat flags alone */
++ /* es->s_uuid will be set by e2fsck if empty */
++
++ /*
++ * The rest of the superblock fields should be zero, and if not it
++ * means they are likely already in use, so leave them alone. We
++ * can leave it up to e2fsck to clean up any inconsistencies there.
++ */
++}
++
++/*
++ * Open the external journal device
++ */
++static struct block_device *ext3cow_blkdev_get(dev_t dev)
++{
++ struct block_device *bdev;
++ char b[BDEVNAME_SIZE];
++
++ bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
++ if (IS_ERR(bdev))
++ goto fail;
++ return bdev;
++
++fail:
++ printk(KERN_ERR "EXT3COW: failed to open journal device %s: %ld\n",
++ __bdevname(dev, b), PTR_ERR(bdev));
++ return NULL;
++}
++
++/*
++ * Release the journal device
++ */
++static int ext3cow_blkdev_put(struct block_device *bdev)
++{
++ bd_release(bdev);
++ return blkdev_put(bdev);
++}
++
++static int ext3cow_blkdev_remove(struct ext3cow_sb_info *sbi)
++{
++ struct block_device *bdev;
++ int ret = -ENODEV;
++
++ bdev = sbi->journal_bdev;
++ if (bdev) {
++ ret = ext3cow_blkdev_put(bdev);
++ sbi->journal_bdev = NULL;
++ }
++ return ret;
++}
++
++static inline struct inode *orphan_list_entry(struct list_head *l)
++{
++ return &list_entry(l, struct ext3cow_inode_info, i_orphan)->vfs_inode;
++}
++
++static void dump_orphan_list(struct super_block *sb, struct ext3cow_sb_info *sbi)
++{
++ struct list_head *l;
++
++ printk(KERN_ERR "sb orphan head is %d\n",
++ le32_to_cpu(sbi->s_es->s_last_orphan));
++
++ printk(KERN_ERR "sb_info orphan list:\n");
++ list_for_each(l, &sbi->s_orphan) {
++ struct inode *inode = orphan_list_entry(l);
++ printk(KERN_ERR " "
++ "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
++ inode->i_sb->s_id, inode->i_ino, inode,
++ inode->i_mode, inode->i_nlink,
++ NEXT_ORPHAN(inode));
++ }
++}
++
++static void ext3cow_put_super (struct super_block * sb)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ struct ext3cow_super_block *es = sbi->s_es;
++ int i;
++
++ ext3cow_xattr_put_super(sb);
++ journal_destroy(sbi->s_journal);
++ if (!(sb->s_flags & MS_RDONLY)) {
++ EXT3COW_CLEAR_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER);
++ es->s_state = cpu_to_le16(sbi->s_mount_state);
++ BUFFER_TRACE(sbi->s_sbh, "marking dirty");
++ mark_buffer_dirty(sbi->s_sbh);
++ ext3cow_commit_super(sb, es, 1);
++ }
++
++ for (i = 0; i < sbi->s_gdb_count; i++)
++ brelse(sbi->s_group_desc[i]);
++ kfree(sbi->s_group_desc);
++ percpu_counter_destroy(&sbi->s_freeblocks_counter);
++ percpu_counter_destroy(&sbi->s_freeinodes_counter);
++ percpu_counter_destroy(&sbi->s_dirs_counter);
++ brelse(sbi->s_sbh);
++#ifdef CONFIG_QUOTA
++ for (i = 0; i < MAXQUOTAS; i++)
++ kfree(sbi->s_qf_names[i]);
++#endif
++
++ /* Debugging code just in case the in-memory inode orphan list
++ * isn't empty. The on-disk one can be non-empty if we've
++ * detected an error and taken the fs readonly, but the
++ * in-memory list had better be clean by this point. */
++ if (!list_empty(&sbi->s_orphan))
++ dump_orphan_list(sb, sbi);
++ J_ASSERT(list_empty(&sbi->s_orphan));
++
++ invalidate_bdev(sb->s_bdev, 0);
++ if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
++ /*
++ * Invalidate the journal device's buffers. We don't want them
++ * floating about in memory - the physical journal device may
++ * hotswapped, and it breaks the `ro-after' testing code.
++ */
++ sync_blockdev(sbi->journal_bdev);
++ invalidate_bdev(sbi->journal_bdev, 0);
++ ext3cow_blkdev_remove(sbi);
++ }
++ sb->s_fs_info = NULL;
++ kfree(sbi);
++ return;
++}
++
++static struct kmem_cache *ext3cow_inode_cachep;
++
++/*
++ * Called inside transaction, so use GFP_NOFS
++ */
++static struct inode *ext3cow_alloc_inode(struct super_block *sb)
++{
++ struct ext3cow_inode_info *ei;
++
++ ei = kmem_cache_alloc(ext3cow_inode_cachep, GFP_NOFS);
++ if (!ei)
++ return NULL;
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++ ei->i_acl = EXT3COW_ACL_NOT_CACHED;
++ ei->i_default_acl = EXT3COW_ACL_NOT_CACHED;
++#endif
++ ei->i_block_alloc_info = NULL;
++ ei->vfs_inode.i_version = 1;
++ return &ei->vfs_inode;
++}
++
++static void ext3cow_destroy_inode(struct inode *inode)
++{
++ kmem_cache_free(ext3cow_inode_cachep, EXT3COW_I(inode));
++}
++
++static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
++{
++ struct ext3cow_inode_info *ei = (struct ext3cow_inode_info *) foo;
++
++ if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
++ SLAB_CTOR_CONSTRUCTOR) {
++ INIT_LIST_HEAD(&ei->i_orphan);
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ init_rwsem(&ei->xattr_sem);
++#endif
++ mutex_init(&ei->truncate_mutex);
++ inode_init_once(&ei->vfs_inode);
++ }
++}
++
++static int init_inodecache(void)
++{
++ ext3cow_inode_cachep = kmem_cache_create("ext3cow_inode_cache",
++ sizeof(struct ext3cow_inode_info),
++ 0, (SLAB_RECLAIM_ACCOUNT|
++ SLAB_MEM_SPREAD),
++ init_once, NULL);
++ if (ext3cow_inode_cachep == NULL)
++ return -ENOMEM;
++ return 0;
++}
++
++static void destroy_inodecache(void)
++{
++ kmem_cache_destroy(ext3cow_inode_cachep);
++}
++
++static void ext3cow_clear_inode(struct inode *inode)
++{
++ struct ext3cow_block_alloc_info *rsv = EXT3COW_I(inode)->i_block_alloc_info;
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++ if (EXT3COW_I(inode)->i_acl &&
++ EXT3COW_I(inode)->i_acl != EXT3COW_ACL_NOT_CACHED) {
++ posix_acl_release(EXT3COW_I(inode)->i_acl);
++ EXT3COW_I(inode)->i_acl = EXT3COW_ACL_NOT_CACHED;
++ }
++ if (EXT3COW_I(inode)->i_default_acl &&
++ EXT3COW_I(inode)->i_default_acl != EXT3COW_ACL_NOT_CACHED) {
++ posix_acl_release(EXT3COW_I(inode)->i_default_acl);
++ EXT3COW_I(inode)->i_default_acl = EXT3COW_ACL_NOT_CACHED;
++ }
++#endif
++ ext3cow_discard_reservation(inode);
++ EXT3COW_I(inode)->i_block_alloc_info = NULL;
++ if (unlikely(rsv))
++ kfree(rsv);
++}
++
++static inline void ext3cow_show_quota_options(struct seq_file *seq, struct super_block *sb)
++{
++#if defined(CONFIG_QUOTA)
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++
++ if (sbi->s_jquota_fmt)
++ seq_printf(seq, ",jqfmt=%s",
++ (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold": "vfsv0");
++
++ if (sbi->s_qf_names[USRQUOTA])
++ seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
++
++ if (sbi->s_qf_names[GRPQUOTA])
++ seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
++
++ if (sbi->s_mount_opt & EXT3COW_MOUNT_USRQUOTA)
++ seq_puts(seq, ",usrquota");
++
++ if (sbi->s_mount_opt & EXT3COW_MOUNT_GRPQUOTA)
++ seq_puts(seq, ",grpquota");
++#endif
++}
++
++static int ext3cow_show_options(struct seq_file *seq, struct vfsmount *vfs)
++{
++ struct super_block *sb = vfs->mnt_sb;
++
++ if (test_opt(sb, DATA_FLAGS) == EXT3COW_MOUNT_JOURNAL_DATA)
++ seq_puts(seq, ",data=journal");
++ else if (test_opt(sb, DATA_FLAGS) == EXT3COW_MOUNT_ORDERED_DATA)
++ seq_puts(seq, ",data=ordered");
++ else if (test_opt(sb, DATA_FLAGS) == EXT3COW_MOUNT_WRITEBACK_DATA)
++ seq_puts(seq, ",data=writeback");
++
++ ext3cow_show_quota_options(seq, sb);
++
++ return 0;
++}
++
++
++static struct dentry *ext3cow_get_dentry(struct super_block *sb, void *vobjp)
++{
++ __u32 *objp = vobjp;
++ unsigned long ino = objp[0];
++ __u32 generation = objp[1];
++ struct inode *inode;
++ struct dentry *result;
++
++ if (ino < EXT3COW_FIRST_INO(sb) && ino != EXT3COW_ROOT_INO)
++ return ERR_PTR(-ESTALE);
++ if (ino > le32_to_cpu(EXT3COW_SB(sb)->s_es->s_inodes_count))
++ return ERR_PTR(-ESTALE);
++
++ /* iget isn't really right if the inode is currently unallocated!!
++ *
++ * ext3cow_read_inode will return a bad_inode if the inode had been
++ * deleted, so we should be safe.
++ *
++ * Currently we don't know the generation for parent directory, so
++ * a generation of 0 means "accept any"
++ */
++ inode = iget(sb, ino);
++ if (inode == NULL)
++ return ERR_PTR(-ENOMEM);
++ if (is_bad_inode(inode) ||
++ (generation && inode->i_generation != generation)) {
++ iput(inode);
++ return ERR_PTR(-ESTALE);
++ }
++ /* now to find a dentry.
++ * If possible, get a well-connected one
++ */
++ result = d_alloc_anon(inode);
++ if (!result) {
++ iput(inode);
++ return ERR_PTR(-ENOMEM);
++ }
++ return result;
++}
++
++#ifdef CONFIG_QUOTA
++#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
++#define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
++
++static int ext3cow_dquot_initialize(struct inode *inode, int type);
++static int ext3cow_dquot_drop(struct inode *inode);
++static int ext3cow_write_dquot(struct dquot *dquot);
++static int ext3cow_acquire_dquot(struct dquot *dquot);
++static int ext3cow_release_dquot(struct dquot *dquot);
++static int ext3cow_mark_dquot_dirty(struct dquot *dquot);
++static int ext3cow_write_info(struct super_block *sb, int type);
++static int ext3cow_quota_on(struct super_block *sb, int type, int format_id, char *path);
++static int ext3cow_quota_on_mount(struct super_block *sb, int type);
++static ssize_t ext3cow_quota_read(struct super_block *sb, int type, char *data,
++ size_t len, loff_t off);
++static ssize_t ext3cow_quota_write(struct super_block *sb, int type,
++ const char *data, size_t len, loff_t off);
++
++static struct dquot_operations ext3cow_quota_operations = {
++ .initialize = ext3cow_dquot_initialize,
++ .drop = ext3cow_dquot_drop,
++ .alloc_space = dquot_alloc_space,
++ .alloc_inode = dquot_alloc_inode,
++ .free_space = dquot_free_space,
++ .free_inode = dquot_free_inode,
++ .transfer = dquot_transfer,
++ .write_dquot = ext3cow_write_dquot,
++ .acquire_dquot = ext3cow_acquire_dquot,
++ .release_dquot = ext3cow_release_dquot,
++ .mark_dirty = ext3cow_mark_dquot_dirty,
++ .write_info = ext3cow_write_info
++};
++
++static struct quotactl_ops ext3cow_qctl_operations = {
++ .quota_on = ext3cow_quota_on,
++ .quota_off = vfs_quota_off,
++ .quota_sync = vfs_quota_sync,
++ .get_info = vfs_get_dqinfo,
++ .set_info = vfs_set_dqinfo,
++ .get_dqblk = vfs_get_dqblk,
++ .set_dqblk = vfs_set_dqblk
++};
++#endif
++
++static struct super_operations ext3cow_sops = {
++ .alloc_inode = ext3cow_alloc_inode,
++ .destroy_inode = ext3cow_destroy_inode,
++ .read_inode = ext3cow_read_inode,
++ .write_inode = ext3cow_write_inode,
++ .dirty_inode = ext3cow_dirty_inode,
++ .delete_inode = ext3cow_delete_inode,
++ .put_super = ext3cow_put_super,
++ .write_super = ext3cow_write_super,
++ .sync_fs = ext3cow_sync_fs,
++ .write_super_lockfs = ext3cow_write_super_lockfs,
++ .unlockfs = ext3cow_unlockfs,
++ .statfs = ext3cow_statfs,
++ .remount_fs = ext3cow_remount,
++ .clear_inode = ext3cow_clear_inode,
++ .show_options = ext3cow_show_options,
++#ifdef CONFIG_QUOTA
++ .quota_read = ext3cow_quota_read,
++ .quota_write = ext3cow_quota_write,
++#endif
++};
++
++static struct export_operations ext3cow_export_ops = {
++ .get_parent = ext3cow_get_parent,
++ .get_dentry = ext3cow_get_dentry,
++};
++
++enum {
++ Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
++ Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
++ Opt_nouid32, Opt_nocheck, Opt_debug, Opt_oldalloc, Opt_orlov,
++ Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
++ Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh, Opt_bh,
++ Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
++ Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
++ Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
++ Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
++ Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
++ Opt_grpquota
++};
++
++static match_table_t tokens = {
++ {Opt_bsd_df, "bsddf"},
++ {Opt_minix_df, "minixdf"},
++ {Opt_grpid, "grpid"},
++ {Opt_grpid, "bsdgroups"},
++ {Opt_nogrpid, "nogrpid"},
++ {Opt_nogrpid, "sysvgroups"},
++ {Opt_resgid, "resgid=%u"},
++ {Opt_resuid, "resuid=%u"},
++ {Opt_sb, "sb=%u"},
++ {Opt_err_cont, "errors=continue"},
++ {Opt_err_panic, "errors=panic"},
++ {Opt_err_ro, "errors=remount-ro"},
++ {Opt_nouid32, "nouid32"},
++ {Opt_nocheck, "nocheck"},
++ {Opt_nocheck, "check=none"},
++ {Opt_debug, "debug"},
++ {Opt_oldalloc, "oldalloc"},
++ {Opt_orlov, "orlov"},
++ {Opt_user_xattr, "user_xattr"},
++ {Opt_nouser_xattr, "nouser_xattr"},
++ {Opt_acl, "acl"},
++ {Opt_noacl, "noacl"},
++ {Opt_reservation, "reservation"},
++ {Opt_noreservation, "noreservation"},
++ {Opt_noload, "noload"},
++ {Opt_nobh, "nobh"},
++ {Opt_bh, "bh"},
++ {Opt_commit, "commit=%u"},
++ {Opt_journal_update, "journal=update"},
++ {Opt_journal_inum, "journal=%u"},
++ {Opt_journal_dev, "journal_dev=%u"},
++ {Opt_abort, "abort"},
++ {Opt_data_journal, "data=journal"},
++ {Opt_data_ordered, "data=ordered"},
++ {Opt_data_writeback, "data=writeback"},
++ {Opt_offusrjquota, "usrjquota="},
++ {Opt_usrjquota, "usrjquota=%s"},
++ {Opt_offgrpjquota, "grpjquota="},
++ {Opt_grpjquota, "grpjquota=%s"},
++ {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
++ {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
++ {Opt_grpquota, "grpquota"},
++ {Opt_noquota, "noquota"},
++ {Opt_quota, "quota"},
++ {Opt_usrquota, "usrquota"},
++ {Opt_barrier, "barrier=%u"},
++ {Opt_err, NULL},
++ {Opt_resize, "resize"},
++};
++
++static ext3cow_fsblk_t get_sb_block(void **data)
++{
++ ext3cow_fsblk_t sb_block;
++ char *options = (char *) *data;
++
++ if (!options || strncmp(options, "sb=", 3) != 0)
++ return 1; /* Default location */
++ options += 3;
++ /*todo: use simple_strtoll with >32bit ext3cow */
++ sb_block = simple_strtoul(options, &options, 0);
++ if (*options && *options != ',') {
++ printk("EXT3COW-fs: Invalid sb specification: %s\n",
++ (char *) *data);
++ return 1;
++ }
++ if (*options == ',')
++ options++;
++ *data = (void *) options;
++ return sb_block;
++}
++
++static int parse_options (char *options, struct super_block *sb,
++ unsigned int *inum, unsigned long *journal_devnum,
++ ext3cow_fsblk_t *n_blocks_count, int is_remount)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ char * p;
++ substring_t args[MAX_OPT_ARGS];
++ int data_opt = 0;
++ int option;
++#ifdef CONFIG_QUOTA
++ int qtype;
++ char *qname;
++#endif
++
++ if (!options)
++ return 1;
++
++ while ((p = strsep (&options, ",")) != NULL) {
++ int token;
++ if (!*p)
++ continue;
++
++ token = match_token(p, tokens, args);
++ switch (token) {
++ case Opt_bsd_df:
++ clear_opt (sbi->s_mount_opt, MINIX_DF);
++ break;
++ case Opt_minix_df:
++ set_opt (sbi->s_mount_opt, MINIX_DF);
++ break;
++ case Opt_grpid:
++ set_opt (sbi->s_mount_opt, GRPID);
++ break;
++ case Opt_nogrpid:
++ clear_opt (sbi->s_mount_opt, GRPID);
++ break;
++ case Opt_resuid:
++ if (match_int(&args[0], &option))
++ return 0;
++ sbi->s_resuid = option;
++ break;
++ case Opt_resgid:
++ if (match_int(&args[0], &option))
++ return 0;
++ sbi->s_resgid = option;
++ break;
++ case Opt_sb:
++ /* handled by get_sb_block() instead of here */
++ /* *sb_block = match_int(&args[0]); */
++ break;
++ case Opt_err_panic:
++ clear_opt (sbi->s_mount_opt, ERRORS_CONT);
++ clear_opt (sbi->s_mount_opt, ERRORS_RO);
++ set_opt (sbi->s_mount_opt, ERRORS_PANIC);
++ break;
++ case Opt_err_ro:
++ clear_opt (sbi->s_mount_opt, ERRORS_CONT);
++ clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
++ set_opt (sbi->s_mount_opt, ERRORS_RO);
++ break;
++ case Opt_err_cont:
++ clear_opt (sbi->s_mount_opt, ERRORS_RO);
++ clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
++ set_opt (sbi->s_mount_opt, ERRORS_CONT);
++ break;
++ case Opt_nouid32:
++ set_opt (sbi->s_mount_opt, NO_UID32);
++ break;
++ case Opt_nocheck:
++ clear_opt (sbi->s_mount_opt, CHECK);
++ break;
++ case Opt_debug:
++ set_opt (sbi->s_mount_opt, DEBUG);
++ break;
++ case Opt_oldalloc:
++ set_opt (sbi->s_mount_opt, OLDALLOC);
++ break;
++ case Opt_orlov:
++ clear_opt (sbi->s_mount_opt, OLDALLOC);
++ break;
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ case Opt_user_xattr:
++ set_opt (sbi->s_mount_opt, XATTR_USER);
++ break;
++ case Opt_nouser_xattr:
++ clear_opt (sbi->s_mount_opt, XATTR_USER);
++ break;
++#else
++ case Opt_user_xattr:
++ case Opt_nouser_xattr:
++ printk("EXT3COW (no)user_xattr options not supported\n");
++ break;
++#endif
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++ case Opt_acl:
++ set_opt(sbi->s_mount_opt, POSIX_ACL);
++ break;
++ case Opt_noacl:
++ clear_opt(sbi->s_mount_opt, POSIX_ACL);
++ break;
++#else
++ case Opt_acl:
++ case Opt_noacl:
++ printk("EXT3COW (no)acl options not supported\n");
++ break;
++#endif
++ case Opt_reservation:
++ set_opt(sbi->s_mount_opt, RESERVATION);
++ break;
++ case Opt_noreservation:
++ clear_opt(sbi->s_mount_opt, RESERVATION);
++ break;
++ case Opt_journal_update:
++ /* @@@ FIXME */
++ /* Eventually we will want to be able to create
++ a journal file here. For now, only allow the
++ user to specify an existing inode to be the
++ journal file. */
++ if (is_remount) {
++ printk(KERN_ERR "EXT3COW-fs: cannot specify "
++ "journal on remount\n");
++ return 0;
++ }
++ set_opt (sbi->s_mount_opt, UPDATE_JOURNAL);
++ break;
++ case Opt_journal_inum:
++ if (is_remount) {
++ printk(KERN_ERR "EXT3COW-fs: cannot specify "
++ "journal on remount\n");
++ return 0;
++ }
++ if (match_int(&args[0], &option))
++ return 0;
++ *inum = option;
++ break;
++ case Opt_journal_dev:
++ if (is_remount) {
++ printk(KERN_ERR "EXT3COW-fs: cannot specify "
++ "journal on remount\n");
++ return 0;
++ }
++ if (match_int(&args[0], &option))
++ return 0;
++ *journal_devnum = option;
++ break;
++ case Opt_noload:
++ set_opt (sbi->s_mount_opt, NOLOAD);
++ break;
++ case Opt_commit:
++ if (match_int(&args[0], &option))
++ return 0;
++ if (option < 0)
++ return 0;
++ if (option == 0)
++ option = JBD_DEFAULT_MAX_COMMIT_AGE;
++ sbi->s_commit_interval = HZ * option;
++ break;
++ case Opt_data_journal:
++ data_opt = EXT3COW_MOUNT_JOURNAL_DATA;
++ goto datacheck;
++ case Opt_data_ordered:
++ data_opt = EXT3COW_MOUNT_ORDERED_DATA;
++ goto datacheck;
++ case Opt_data_writeback:
++ data_opt = EXT3COW_MOUNT_WRITEBACK_DATA;
++ datacheck:
++ if (is_remount) {
++ if ((sbi->s_mount_opt & EXT3COW_MOUNT_DATA_FLAGS)
++ != data_opt) {
++ printk(KERN_ERR
++ "EXT3COW-fs: cannot change data "
++ "mode on remount\n");
++ return 0;
++ }
++ } else {
++ sbi->s_mount_opt &= ~EXT3COW_MOUNT_DATA_FLAGS;
++ sbi->s_mount_opt |= data_opt;
++ }
++ break;
++#ifdef CONFIG_QUOTA
++ case Opt_usrjquota:
++ qtype = USRQUOTA;
++ goto set_qf_name;
++ case Opt_grpjquota:
++ qtype = GRPQUOTA;
++set_qf_name:
++ if (sb_any_quota_enabled(sb)) {
++ printk(KERN_ERR
++ "EXT3COW-fs: Cannot change journalled "
++ "quota options when quota turned on.\n");
++ return 0;
++ }
++ qname = match_strdup(&args[0]);
++ if (!qname) {
++ printk(KERN_ERR
++ "EXT3COW-fs: not enough memory for "
++ "storing quotafile name.\n");
++ return 0;
++ }
++ if (sbi->s_qf_names[qtype] &&
++ strcmp(sbi->s_qf_names[qtype], qname)) {
++ printk(KERN_ERR
++ "EXT3COW-fs: %s quota file already "
++ "specified.\n", QTYPE2NAME(qtype));
++ kfree(qname);
++ return 0;
++ }
++ sbi->s_qf_names[qtype] = qname;
++ if (strchr(sbi->s_qf_names[qtype], '/')) {
++ printk(KERN_ERR
++ "EXT3COW-fs: quotafile must be on "
++ "filesystem root.\n");
++ kfree(sbi->s_qf_names[qtype]);
++ sbi->s_qf_names[qtype] = NULL;
++ return 0;
++ }
++ set_opt(sbi->s_mount_opt, QUOTA);
++ break;
++ case Opt_offusrjquota:
++ qtype = USRQUOTA;
++ goto clear_qf_name;
++ case Opt_offgrpjquota:
++ qtype = GRPQUOTA;
++clear_qf_name:
++ if (sb_any_quota_enabled(sb)) {
++ printk(KERN_ERR "EXT3COW-fs: Cannot change "
++ "journalled quota options when "
++ "quota turned on.\n");
++ return 0;
++ }
++ /*
++ * The space will be released later when all options
++ * are confirmed to be correct
++ */
++ sbi->s_qf_names[qtype] = NULL;
++ break;
++ case Opt_jqfmt_vfsold:
++ sbi->s_jquota_fmt = QFMT_VFS_OLD;
++ break;
++ case Opt_jqfmt_vfsv0:
++ sbi->s_jquota_fmt = QFMT_VFS_V0;
++ break;
++ case Opt_quota:
++ case Opt_usrquota:
++ set_opt(sbi->s_mount_opt, QUOTA);
++ set_opt(sbi->s_mount_opt, USRQUOTA);
++ break;
++ case Opt_grpquota:
++ set_opt(sbi->s_mount_opt, QUOTA);
++ set_opt(sbi->s_mount_opt, GRPQUOTA);
++ break;
++ case Opt_noquota:
++ if (sb_any_quota_enabled(sb)) {
++ printk(KERN_ERR "EXT3COW-fs: Cannot change quota "
++ "options when quota turned on.\n");
++ return 0;
++ }
++ clear_opt(sbi->s_mount_opt, QUOTA);
++ clear_opt(sbi->s_mount_opt, USRQUOTA);
++ clear_opt(sbi->s_mount_opt, GRPQUOTA);
++ break;
++#else
++ case Opt_quota:
++ case Opt_usrquota:
++ case Opt_grpquota:
++ case Opt_usrjquota:
++ case Opt_grpjquota:
++ case Opt_offusrjquota:
++ case Opt_offgrpjquota:
++ case Opt_jqfmt_vfsold:
++ case Opt_jqfmt_vfsv0:
++ printk(KERN_ERR
++ "EXT3COW-fs: journalled quota options not "
++ "supported.\n");
++ break;
++ case Opt_noquota:
++ break;
++#endif
++ case Opt_abort:
++ set_opt(sbi->s_mount_opt, ABORT);
++ break;
++ case Opt_barrier:
++ if (match_int(&args[0], &option))
++ return 0;
++ if (option)
++ set_opt(sbi->s_mount_opt, BARRIER);
++ else
++ clear_opt(sbi->s_mount_opt, BARRIER);
++ break;
++ case Opt_ignore:
++ break;
++ case Opt_resize:
++ if (!is_remount) {
++ printk("EXT3COW-fs: resize option only available "
++ "for remount\n");
++ return 0;
++ }
++ if (match_int(&args[0], &option) != 0)
++ return 0;
++ *n_blocks_count = option;
++ break;
++ case Opt_nobh:
++ set_opt(sbi->s_mount_opt, NOBH);
++ break;
++ case Opt_bh:
++ clear_opt(sbi->s_mount_opt, NOBH);
++ break;
++ default:
++ printk (KERN_ERR
++ "EXT3COW-fs: Unrecognized mount option \"%s\" "
++ "or missing value\n", p);
++ return 0;
++ }
++ }
++#ifdef CONFIG_QUOTA
++ if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
++ if ((sbi->s_mount_opt & EXT3COW_MOUNT_USRQUOTA) &&
++ sbi->s_qf_names[USRQUOTA])
++ clear_opt(sbi->s_mount_opt, USRQUOTA);
++
++ if ((sbi->s_mount_opt & EXT3COW_MOUNT_GRPQUOTA) &&
++ sbi->s_qf_names[GRPQUOTA])
++ clear_opt(sbi->s_mount_opt, GRPQUOTA);
++
++ if ((sbi->s_qf_names[USRQUOTA] &&
++ (sbi->s_mount_opt & EXT3COW_MOUNT_GRPQUOTA)) ||
++ (sbi->s_qf_names[GRPQUOTA] &&
++ (sbi->s_mount_opt & EXT3COW_MOUNT_USRQUOTA))) {
++ printk(KERN_ERR "EXT3COW-fs: old and new quota "
++ "format mixing.\n");
++ return 0;
++ }
++
++ if (!sbi->s_jquota_fmt) {
++ printk(KERN_ERR "EXT3COW-fs: journalled quota format "
++ "not specified.\n");
++ return 0;
++ }
++ } else {
++ if (sbi->s_jquota_fmt) {
++ printk(KERN_ERR "EXT3COW-fs: journalled quota format "
++ "specified with no journalling "
++ "enabled.\n");
++ return 0;
++ }
++ }
++#endif
++ return 1;
++}
++
++static int ext3cow_setup_super(struct super_block *sb, struct ext3cow_super_block *es,
++ int read_only)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ int res = 0;
++
++ if (le32_to_cpu(es->s_rev_level) > EXT3COW_MAX_SUPP_REV) {
++ printk (KERN_ERR "EXT3COW-fs warning: revision level too high, "
++ "forcing read-only mode\n");
++ res = MS_RDONLY;
++ }
++ if (read_only)
++ return res;
++ if (!(sbi->s_mount_state & EXT3COW_VALID_FS))
++ printk (KERN_WARNING "EXT3COW-fs warning: mounting unchecked fs, "
++ "running e2fsck is recommended\n");
++ else if ((sbi->s_mount_state & EXT3COW_ERROR_FS))
++ printk (KERN_WARNING
++ "EXT3COW-fs warning: mounting fs with errors, "
++ "running e2fsck is recommended\n");
++ else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
++ le16_to_cpu(es->s_mnt_count) >=
++ (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
++ printk (KERN_WARNING
++ "EXT3COW-fs warning: maximal mount count reached, "
++ "running e2fsck is recommended\n");
++ else if (le32_to_cpu(es->s_checkinterval) &&
++ (le32_to_cpu(es->s_lastcheck) +
++ le32_to_cpu(es->s_checkinterval) <= get_seconds()))
++ printk (KERN_WARNING
++ "EXT3COW-fs warning: checktime reached, "
++ "running e2fsck is recommended\n");
++#if 0
++ /* @@@ We _will_ want to clear the valid bit if we find
++ inconsistencies, to force a fsck at reboot. But for
++ a plain journaled filesystem we can keep it set as
++ valid forever! :) */
++ es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) & ~EXT3COW_VALID_FS);
++#endif
++ if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
++ es->s_max_mnt_count = cpu_to_le16(EXT3COW_DFL_MAX_MNT_COUNT);
++ es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
++ es->s_mtime = cpu_to_le32(get_seconds());
++ ext3cow_update_dynamic_rev(sb);
++ EXT3COW_SET_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER);
++
++ ext3cow_commit_super(sb, es, 1);
++ if (test_opt(sb, DEBUG))
++ printk(KERN_INFO "[EXT3COW FS bs=%lu, gc=%lu, "
++ "bpg=%lu, ipg=%lu, mo=%04lx]\n",
++ sb->s_blocksize,
++ sbi->s_groups_count,
++ EXT3COW_BLOCKS_PER_GROUP(sb),
++ EXT3COW_INODES_PER_GROUP(sb),
++ sbi->s_mount_opt);
++
++ printk(KERN_INFO "EXT3COW FS on %s, ", sb->s_id);
++ if (EXT3COW_SB(sb)->s_journal->j_inode == NULL) {
++ char b[BDEVNAME_SIZE];
++
++ printk("external journal on %s\n",
++ bdevname(EXT3COW_SB(sb)->s_journal->j_dev, b));
++ } else {
++ printk("internal journal\n");
++ }
++ return res;
++}
++
++/* Called at mount-time, super-block is locked */
++static int ext3cow_check_descriptors (struct super_block * sb)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ ext3cow_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
++ ext3cow_fsblk_t last_block;
++ struct ext3cow_group_desc * gdp = NULL;
++ int desc_block = 0;
++ int i;
++
++ ext3cow_debug ("Checking group descriptors");
++
++ for (i = 0; i < sbi->s_groups_count; i++)
++ {
++ if (i == sbi->s_groups_count - 1)
++ last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
++ else
++ last_block = first_block +
++ (EXT3COW_BLOCKS_PER_GROUP(sb) - 1);
++
++ if ((i % EXT3COW_DESC_PER_BLOCK(sb)) == 0)
++ gdp = (struct ext3cow_group_desc *)
++ sbi->s_group_desc[desc_block++]->b_data;
++ if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||
++ le32_to_cpu(gdp->bg_block_bitmap) > last_block)
++ {
++ ext3cow_error (sb, "ext3cow_check_descriptors",
++ "Block bitmap for group %d"
++ " not in group (block %lu)!",
++ i, (unsigned long)
++ le32_to_cpu(gdp->bg_block_bitmap));
++ return 0;
++ }
++ if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||
++ le32_to_cpu(gdp->bg_inode_bitmap) > last_block)
++ {
++ ext3cow_error (sb, "ext3cow_check_descriptors",
++ "Inode bitmap for group %d"
++ " not in group (block %lu)!",
++ i, (unsigned long)
++ le32_to_cpu(gdp->bg_inode_bitmap));
++ return 0;
++ }
++ if (le32_to_cpu(gdp->bg_inode_table) < first_block ||
++ le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group >
++ last_block)
++ {
++ ext3cow_error (sb, "ext3cow_check_descriptors",
++ "Inode table for group %d"
++ " not in group (block %lu)!",
++ i, (unsigned long)
++ le32_to_cpu(gdp->bg_inode_table));
++ return 0;
++ }
++ first_block += EXT3COW_BLOCKS_PER_GROUP(sb);
++ gdp++;
++ }
++
++ sbi->s_es->s_free_blocks_count=cpu_to_le32(ext3cow_count_free_blocks(sb));
++ sbi->s_es->s_free_inodes_count=cpu_to_le32(ext3cow_count_free_inodes(sb));
++ return 1;
++}
++
++
++/* ext3cow_orphan_cleanup() walks a singly-linked list of inodes (starting at
++ * the superblock) which were deleted from all directories, but held open by
++ * a process at the time of a crash. We walk the list and try to delete these
++ * inodes at recovery time (only with a read-write filesystem).
++ *
++ * In order to keep the orphan inode chain consistent during traversal (in
++ * case of crash during recovery), we link each inode into the superblock
++ * orphan list_head and handle it the same way as an inode deletion during
++ * normal operation (which journals the operations for us).
++ *
++ * We only do an iget() and an iput() on each inode, which is very safe if we
++ * accidentally point at an in-use or already deleted inode. The worst that
++ * can happen in this case is that we get a "bit already cleared" message from
++ * ext3cow_free_inode(). The only reason we would point at a wrong inode is if
++ * e2fsck was run on this filesystem, and it must have already done the orphan
++ * inode cleanup for us, so we can safely abort without any further action.
++ */
++static void ext3cow_orphan_cleanup (struct super_block * sb,
++ struct ext3cow_super_block * es)
++{
++ unsigned int s_flags = sb->s_flags;
++ int nr_orphans = 0, nr_truncates = 0;
++#ifdef CONFIG_QUOTA
++ int i;
++#endif
++ if (!es->s_last_orphan) {
++ jbd_debug(4, "no orphan inodes to clean up\n");
++ return;
++ }
++
++ if (bdev_read_only(sb->s_bdev)) {
++ printk(KERN_ERR "EXT3COW-fs: write access "
++ "unavailable, skipping orphan cleanup.\n");
++ return;
++ }
++
++ if (EXT3COW_SB(sb)->s_mount_state & EXT3COW_ERROR_FS) {
++ if (es->s_last_orphan)
++ jbd_debug(1, "Errors on filesystem, "
++ "clearing orphan list.\n");
++ es->s_last_orphan = 0;
++ jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
++ return;
++ }
++
++ if (s_flags & MS_RDONLY) {
++ printk(KERN_INFO "EXT3COW-fs: %s: orphan cleanup on readonly fs\n",
++ sb->s_id);
++ sb->s_flags &= ~MS_RDONLY;
++ }
++#ifdef CONFIG_QUOTA
++ /* Needed for iput() to work correctly and not trash data */
++ sb->s_flags |= MS_ACTIVE;
++ /* Turn on quotas so that they are updated correctly */
++ for (i = 0; i < MAXQUOTAS; i++) {
++ if (EXT3COW_SB(sb)->s_qf_names[i]) {
++ int ret = ext3cow_quota_on_mount(sb, i);
++ if (ret < 0)
++ printk(KERN_ERR
++ "EXT3COW-fs: Cannot turn on journalled "
++ "quota: error %d\n", ret);
++ }
++ }
++#endif
++
++ while (es->s_last_orphan) {
++ struct inode *inode;
++
++ if (!(inode =
++ ext3cow_orphan_get(sb, le32_to_cpu(es->s_last_orphan)))) {
++ es->s_last_orphan = 0;
++ break;
++ }
++
++ list_add(&EXT3COW_I(inode)->i_orphan, &EXT3COW_SB(sb)->s_orphan);
++ DQUOT_INIT(inode);
++ if (inode->i_nlink) {
++ printk(KERN_DEBUG
++ "%s: truncating inode %lu to %Ld bytes\n",
++ __FUNCTION__, inode->i_ino, inode->i_size);
++ jbd_debug(2, "truncating inode %lu to %Ld bytes\n",
++ inode->i_ino, inode->i_size);
++ ext3cow_truncate(inode);
++ nr_truncates++;
++ } else {
++ printk(KERN_DEBUG
++ "%s: deleting unreferenced inode %lu\n",
++ __FUNCTION__, inode->i_ino);
++ jbd_debug(2, "deleting unreferenced inode %lu\n",
++ inode->i_ino);
++ nr_orphans++;
++ }
++ iput(inode); /* The delete magic happens here! */
++ }
++
++#define PLURAL(x) (x), ((x)==1) ? "" : "s"
++
++ if (nr_orphans)
++ printk(KERN_INFO "EXT3COW-fs: %s: %d orphan inode%s deleted\n",
++ sb->s_id, PLURAL(nr_orphans));
++ if (nr_truncates)
++ printk(KERN_INFO "EXT3COW-fs: %s: %d truncate%s cleaned up\n",
++ sb->s_id, PLURAL(nr_truncates));
++#ifdef CONFIG_QUOTA
++ /* Turn quotas off */
++ for (i = 0; i < MAXQUOTAS; i++) {
++ if (sb_dqopt(sb)->files[i])
++ vfs_quota_off(sb, i);
++ }
++#endif
++ sb->s_flags = s_flags; /* Restore MS_RDONLY status */
++}
++
++/*
++ * Maximal file size. There is a direct, and {,double-,triple-}indirect
++ * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
++ * We need to be 1 filesystem block less than the 2^32 sector limit.
++ */
++static loff_t ext3cow_max_size(int bits)
++{
++ loff_t res = EXT3COW_NDIR_BLOCKS;
++ /* This constant is calculated to be the largest file size for a
++ * dense, 4k-blocksize file such that the total number of
++ * sectors in the file, including data and all indirect blocks,
++ * does not exceed 2^32. */
++ const loff_t upper_limit = 0x1ff7fffd000LL;
++
++ res += 1LL << (bits-2);
++ res += 1LL << (2*(bits-2));
++ res += 1LL << (3*(bits-2));
++ res <<= bits;
++ if (res > upper_limit)
++ res = upper_limit;
++ return res;
++}
++
++static ext3cow_fsblk_t descriptor_loc(struct super_block *sb,
++ ext3cow_fsblk_t logic_sb_block,
++ int nr)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ unsigned long bg, first_meta_bg;
++ int has_super = 0;
++
++ first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
++
++ if (!EXT3COW_HAS_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_META_BG) ||
++ nr < first_meta_bg)
++ return (logic_sb_block + nr + 1);
++ bg = sbi->s_desc_per_block * nr;
++ if (ext3cow_bg_has_super(sb, bg))
++ has_super = 1;
++ return (has_super + ext3cow_group_first_block_no(sb, bg));
++}
++
++
++static int ext3cow_fill_super (struct super_block *sb, void *data, int silent)
++{
++ struct buffer_head * bh;
++ struct ext3cow_super_block *es = NULL;
++ struct ext3cow_sb_info *sbi;
++ ext3cow_fsblk_t block;
++ ext3cow_fsblk_t sb_block = get_sb_block(&data);
++ ext3cow_fsblk_t logic_sb_block;
++ unsigned long offset = 0;
++ unsigned int journal_inum = 0;
++ unsigned long journal_devnum = 0;
++ unsigned long def_mount_opts;
++ struct inode *root;
++ int blocksize;
++ int hblock;
++ int db_count;
++ int i;
++ int needs_recovery;
++ __le32 features;
++
++ sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
++ if (!sbi)
++ return -ENOMEM;
++ sb->s_fs_info = sbi;
++ sbi->s_mount_opt = 0;
++ sbi->s_resuid = EXT3COW_DEF_RESUID;
++ sbi->s_resgid = EXT3COW_DEF_RESGID;
++
++ unlock_kernel();
++
++ blocksize = sb_min_blocksize(sb, EXT3COW_MIN_BLOCK_SIZE);
++ if (!blocksize) {
++ printk(KERN_ERR "EXT3COW-fs: unable to set blocksize\n");
++ goto out_fail;
++ }
++
++ /*
++ * The ext3cow superblock will not be buffer aligned for other than 1kB
++ * block sizes. We need to calculate the offset from buffer start.
++ */
++ if (blocksize != EXT3COW_MIN_BLOCK_SIZE) {
++ logic_sb_block = (sb_block * EXT3COW_MIN_BLOCK_SIZE) / blocksize;
++ offset = (sb_block * EXT3COW_MIN_BLOCK_SIZE) % blocksize;
++ } else {
++ logic_sb_block = sb_block;
++ }
++
++ if (!(bh = sb_bread(sb, logic_sb_block))) {
++ printk (KERN_ERR "EXT3COW-fs: unable to read superblock\n");
++ goto out_fail;
++ }
++ /*
++ * Note: s_es must be initialized as soon as possible because
++ * some ext3cow macro-instructions depend on its value
++ */
++ es = (struct ext3cow_super_block *) (((char *)bh->b_data) + offset);
++ sbi->s_es = es;
++ sb->s_magic = le16_to_cpu(es->s_magic);
++ if (sb->s_magic != EXT3COW_SUPER_MAGIC)
++ goto cantfind_ext3cow;
++
++ /* Set defaults before we parse the mount options */
++ def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
++ if (def_mount_opts & EXT3COW_DEFM_DEBUG)
++ set_opt(sbi->s_mount_opt, DEBUG);
++ if (def_mount_opts & EXT3COW_DEFM_BSDGROUPS)
++ set_opt(sbi->s_mount_opt, GRPID);
++ if (def_mount_opts & EXT3COW_DEFM_UID16)
++ set_opt(sbi->s_mount_opt, NO_UID32);
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ if (def_mount_opts & EXT3COW_DEFM_XATTR_USER)
++ set_opt(sbi->s_mount_opt, XATTR_USER);
++#endif
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++ if (def_mount_opts & EXT3COW_DEFM_ACL)
++ set_opt(sbi->s_mount_opt, POSIX_ACL);
++#endif
++ if ((def_mount_opts & EXT3COW_DEFM_JMODE) == EXT3COW_DEFM_JMODE_DATA)
++ sbi->s_mount_opt |= EXT3COW_MOUNT_JOURNAL_DATA;
++ else if ((def_mount_opts & EXT3COW_DEFM_JMODE) == EXT3COW_DEFM_JMODE_ORDERED)
++ sbi->s_mount_opt |= EXT3COW_MOUNT_ORDERED_DATA;
++ else if ((def_mount_opts & EXT3COW_DEFM_JMODE) == EXT3COW_DEFM_JMODE_WBACK)
++ sbi->s_mount_opt |= EXT3COW_MOUNT_WRITEBACK_DATA;
++
++ if (le16_to_cpu(sbi->s_es->s_errors) == EXT3COW_ERRORS_PANIC)
++ set_opt(sbi->s_mount_opt, ERRORS_PANIC);
++ else if (le16_to_cpu(sbi->s_es->s_errors) == EXT3COW_ERRORS_RO)
++ set_opt(sbi->s_mount_opt, ERRORS_RO);
++ else
++ set_opt(sbi->s_mount_opt, ERRORS_CONT);
++
++ sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
++ sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
++
++ set_opt(sbi->s_mount_opt, RESERVATION);
++
++ if (!parse_options ((char *) data, sb, &journal_inum, &journal_devnum,
++ NULL, 0))
++ goto failed_mount;
++
++ sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
++ ((sbi->s_mount_opt & EXT3COW_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
++
++ if (le32_to_cpu(es->s_rev_level) == EXT3COW_GOOD_OLD_REV &&
++ (EXT3COW_HAS_COMPAT_FEATURE(sb, ~0U) ||
++ EXT3COW_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
++ EXT3COW_HAS_INCOMPAT_FEATURE(sb, ~0U)))
++ printk(KERN_WARNING
++ "EXT3COW-fs warning: feature flags set on rev 0 fs, "
++ "running e2fsck is recommended\n");
++ /*
++ * Check feature flags regardless of the revision level, since we
++ * previously didn't change the revision level when setting the flags,
++ * so there is a chance incompat flags are set on a rev 0 filesystem.
++ */
++ features = EXT3COW_HAS_INCOMPAT_FEATURE(sb, ~EXT3COW_FEATURE_INCOMPAT_SUPP);
++ if (features) {
++ printk(KERN_ERR "EXT3COW-fs: %s: couldn't mount because of "
++ "unsupported optional features (%x).\n",
++ sb->s_id, le32_to_cpu(features));
++ goto failed_mount;
++ }
++ features = EXT3COW_HAS_RO_COMPAT_FEATURE(sb, ~EXT3COW_FEATURE_RO_COMPAT_SUPP);
++ if (!(sb->s_flags & MS_RDONLY) && features) {
++ printk(KERN_ERR "EXT3COW-fs: %s: couldn't mount RDWR because of "
++ "unsupported optional features (%x).\n",
++ sb->s_id, le32_to_cpu(features));
++ goto failed_mount;
++ }
++ blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
++
++ if (blocksize < EXT3COW_MIN_BLOCK_SIZE ||
++ blocksize > EXT3COW_MAX_BLOCK_SIZE) {
++ printk(KERN_ERR
++ "EXT3COW-fs: Unsupported filesystem blocksize %d on %s.\n",
++ blocksize, sb->s_id);
++ goto failed_mount;
++ }
++
++ hblock = bdev_hardsect_size(sb->s_bdev);
++ if (sb->s_blocksize != blocksize) {
++ /*
++ * Make sure the blocksize for the filesystem is larger
++ * than the hardware sectorsize for the machine.
++ */
++ if (blocksize < hblock) {
++ printk(KERN_ERR "EXT3COW-fs: blocksize %d too small for "
++ "device blocksize %d.\n", blocksize, hblock);
++ goto failed_mount;
++ }
++
++ brelse (bh);
++ sb_set_blocksize(sb, blocksize);
++ logic_sb_block = (sb_block * EXT3COW_MIN_BLOCK_SIZE) / blocksize;
++ offset = (sb_block * EXT3COW_MIN_BLOCK_SIZE) % blocksize;
++ bh = sb_bread(sb, logic_sb_block);
++ if (!bh) {
++ printk(KERN_ERR
++ "EXT3COW-fs: Can't read superblock on 2nd try.\n");
++ goto failed_mount;
++ }
++ es = (struct ext3cow_super_block *)(((char *)bh->b_data) + offset);
++ sbi->s_es = es;
++ if (es->s_magic != cpu_to_le16(EXT3COW_SUPER_MAGIC)) {
++ printk (KERN_ERR
++ "EXT3COW-fs: Magic mismatch, very weird !\n");
++ goto failed_mount;
++ }
++ }
++
++ sb->s_maxbytes = ext3cow_max_size(sb->s_blocksize_bits);
++
++ if (le32_to_cpu(es->s_rev_level) == EXT3COW_GOOD_OLD_REV) {
++ sbi->s_inode_size = EXT3COW_GOOD_OLD_INODE_SIZE;
++ sbi->s_first_ino = EXT3COW_GOOD_OLD_FIRST_INO;
++ } else {
++ sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
++ sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
++ if ((sbi->s_inode_size < EXT3COW_GOOD_OLD_INODE_SIZE) ||
++ (sbi->s_inode_size & (sbi->s_inode_size - 1)) ||
++ (sbi->s_inode_size > blocksize)) {
++ printk (KERN_ERR
++ "EXT3COW-fs: unsupported inode size: %d\n",
++ sbi->s_inode_size);
++ goto failed_mount;
++ }
++ }
++ sbi->s_frag_size = EXT3COW_MIN_FRAG_SIZE <<
++ le32_to_cpu(es->s_log_frag_size);
++ if (blocksize != sbi->s_frag_size) {
++ printk(KERN_ERR
++ "EXT3COW-fs: fragsize %lu != blocksize %u (unsupported)\n",
++ sbi->s_frag_size, blocksize);
++ goto failed_mount;
++ }
++ sbi->s_frags_per_block = 1;
++ sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
++ sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
++ sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
++ if (EXT3COW_INODE_SIZE(sb) == 0)
++ goto cantfind_ext3cow;
++ sbi->s_inodes_per_block = blocksize / EXT3COW_INODE_SIZE(sb);
++ if (sbi->s_inodes_per_block == 0)
++ goto cantfind_ext3cow;
++ sbi->s_itb_per_group = sbi->s_inodes_per_group /
++ sbi->s_inodes_per_block;
++ sbi->s_desc_per_block = blocksize / sizeof(struct ext3cow_group_desc);
++ sbi->s_sbh = bh;
++ sbi->s_mount_state = le16_to_cpu(es->s_state);
++ sbi->s_addr_per_block_bits = ilog2(EXT3COW_ADDR_PER_BLOCK(sb));
++ sbi->s_desc_per_block_bits = ilog2(EXT3COW_DESC_PER_BLOCK(sb));
++ for (i=0; i < 4; i++)
++ sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
++ sbi->s_def_hash_version = es->s_def_hash_version;
++
++ /* Epoch number for versioning -znjp */
++ sbi->s_epoch_number = le32_to_cpu(es->s_epoch_number);
++ printk(KERN_INFO "EXT3COW-fs: System epoch number: %u\n",
++ sbi->s_epoch_number);
++
++ if (sbi->s_blocks_per_group > blocksize * 8) {
++ printk (KERN_ERR
++ "EXT3COW-fs: #blocks per group too big: %lu\n",
++ sbi->s_blocks_per_group);
++ goto failed_mount;
++ }
++ if (sbi->s_frags_per_group > blocksize * 8) {
++ printk (KERN_ERR
++ "EXT3COW-fs: #fragments per group too big: %lu\n",
++ sbi->s_frags_per_group);
++ goto failed_mount;
++ }
++ if (sbi->s_inodes_per_group > blocksize * 8) {
++ printk (KERN_ERR
++ "EXT3COW-fs: #inodes per group too big: %lu\n",
++ sbi->s_inodes_per_group);
++ goto failed_mount;
++ }
++
++ if (le32_to_cpu(es->s_blocks_count) >
++ (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
++ printk(KERN_ERR "EXT3COW-fs: filesystem on %s:"
++ " too large to mount safely\n", sb->s_id);
++ if (sizeof(sector_t) < 8)
++ printk(KERN_WARNING "EXT3COW-fs: CONFIG_LBD not "
++ "enabled\n");
++ goto failed_mount;
++ }
++
++ if (EXT3COW_BLOCKS_PER_GROUP(sb) == 0)
++ goto cantfind_ext3cow;
++ sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
++ le32_to_cpu(es->s_first_data_block) - 1)
++ / EXT3COW_BLOCKS_PER_GROUP(sb)) + 1;
++ db_count = (sbi->s_groups_count + EXT3COW_DESC_PER_BLOCK(sb) - 1) /
++ EXT3COW_DESC_PER_BLOCK(sb);
++ sbi->s_group_desc = kmalloc(db_count * sizeof (struct buffer_head *),
++ GFP_KERNEL);
++ if (sbi->s_group_desc == NULL) {
++ printk (KERN_ERR "EXT3COW-fs: not enough memory\n");
++ goto failed_mount;
++ }
++
++ bgl_lock_init(&sbi->s_blockgroup_lock);
++
++ for (i = 0; i < db_count; i++) {
++ block = descriptor_loc(sb, logic_sb_block, i);
++ sbi->s_group_desc[i] = sb_bread(sb, block);
++ if (!sbi->s_group_desc[i]) {
++ printk (KERN_ERR "EXT3COW-fs: "
++ "can't read group descriptor %d\n", i);
++ db_count = i;
++ goto failed_mount2;
++ }
++ }
++ if (!ext3cow_check_descriptors (sb)) {
++ printk(KERN_ERR "EXT3COW-fs: group descriptors corrupted!\n");
++ goto failed_mount2;
++ }
++ sbi->s_gdb_count = db_count;
++ get_random_bytes(&sbi->s_next_generation, sizeof(u32));
++ spin_lock_init(&sbi->s_next_gen_lock);
++
++ percpu_counter_init(&sbi->s_freeblocks_counter,
++ ext3cow_count_free_blocks(sb));
++ percpu_counter_init(&sbi->s_freeinodes_counter,
++ ext3cow_count_free_inodes(sb));
++ percpu_counter_init(&sbi->s_dirs_counter,
++ ext3cow_count_dirs(sb));
++
++ /* per fileystem reservation list head & lock */
++ spin_lock_init(&sbi->s_rsv_window_lock);
++ sbi->s_rsv_window_root = RB_ROOT;
++ /* Add a single, static dummy reservation to the start of the
++ * reservation window list --- it gives us a placeholder for
++ * append-at-start-of-list which makes the allocation logic
++ * _much_ simpler. */
++ sbi->s_rsv_window_head.rsv_start = EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED;
++ sbi->s_rsv_window_head.rsv_end = EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED;
++ sbi->s_rsv_window_head.rsv_alloc_hit = 0;
++ sbi->s_rsv_window_head.rsv_goal_size = 0;
++ ext3cow_rsv_window_add(sb, &sbi->s_rsv_window_head);
++
++ /*
++ * set up enough so that it can read an inode
++ */
++ sb->s_op = &ext3cow_sops;
++ sb->s_export_op = &ext3cow_export_ops;
++ sb->s_xattr = ext3cow_xattr_handlers;
++#ifdef CONFIG_QUOTA
++ sb->s_qcop = &ext3cow_qctl_operations;
++ sb->dq_op = &ext3cow_quota_operations;
++#endif
++ INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
++
++ sb->s_root = NULL;
++
++ needs_recovery = (es->s_last_orphan != 0 ||
++ EXT3COW_HAS_INCOMPAT_FEATURE(sb,
++ EXT3COW_FEATURE_INCOMPAT_RECOVER));
++
++ /*
++ * The first inode we look at is the journal inode. Don't try
++ * root first: it may be modified in the journal!
++ */
++ if (!test_opt(sb, NOLOAD) &&
++ EXT3COW_HAS_COMPAT_FEATURE(sb, EXT3COW_FEATURE_COMPAT_HAS_JOURNAL)) {
++ if (ext3cow_load_journal(sb, es, journal_devnum))
++ goto failed_mount3;
++ } else if (journal_inum) {
++ if (ext3cow_create_journal(sb, es, journal_inum))
++ goto failed_mount3;
++ } else {
++ if (!silent)
++ printk (KERN_ERR
++ "ext3cow: No journal on filesystem on %s\n",
++ sb->s_id);
++ goto failed_mount3;
++ }
++
++ /* We have now updated the journal if required, so we can
++ * validate the data journaling mode. */
++ switch (test_opt(sb, DATA_FLAGS)) {
++ case 0:
++ /* No mode set, assume a default based on the journal
++ capabilities: ORDERED_DATA if the journal can
++ cope, else JOURNAL_DATA */
++ if (journal_check_available_features
++ (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE))
++ set_opt(sbi->s_mount_opt, ORDERED_DATA);
++ else
++ set_opt(sbi->s_mount_opt, JOURNAL_DATA);
++ break;
++
++ case EXT3COW_MOUNT_ORDERED_DATA:
++ case EXT3COW_MOUNT_WRITEBACK_DATA:
++ if (!journal_check_available_features
++ (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) {
++ printk(KERN_ERR "EXT3COW-fs: Journal does not support "
++ "requested data journaling mode\n");
++ goto failed_mount4;
++ }
++ default:
++ break;
++ }
++
++ if (test_opt(sb, NOBH)) {
++ if (!(test_opt(sb, DATA_FLAGS) == EXT3COW_MOUNT_WRITEBACK_DATA)) {
++ printk(KERN_WARNING "EXT3COW-fs: Ignoring nobh option - "
++ "its supported only with writeback mode\n");
++ clear_opt(sbi->s_mount_opt, NOBH);
++ }
++ }
++ /*
++ * The journal_load will have done any necessary log recovery,
++ * so we can safely mount the rest of the filesystem now.
++ */
++
++ root = iget(sb, EXT3COW_ROOT_INO);
++ sb->s_root = d_alloc_root(root);
++ if (!sb->s_root) {
++ printk(KERN_ERR "EXT3COW-fs: get root inode failed\n");
++ iput(root);
++ goto failed_mount4;
++ }
++ if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
++ dput(sb->s_root);
++ sb->s_root = NULL;
++ printk(KERN_ERR "EXT3COW-fs: corrupt root inode, run e2fsck\n");
++ goto failed_mount4;
++ }
++
++ ext3cow_setup_super (sb, es, sb->s_flags & MS_RDONLY);
++ /*
++ * akpm: core read_super() calls in here with the superblock locked.
++ * That deadlocks, because orphan cleanup needs to lock the superblock
++ * in numerous places. Here we just pop the lock - it's relatively
++ * harmless, because we are now ready to accept write_super() requests,
++ * and aviro says that's the only reason for hanging onto the
++ * superblock lock.
++ */
++ EXT3COW_SB(sb)->s_mount_state |= EXT3COW_ORPHAN_FS;
++ ext3cow_orphan_cleanup(sb, es);
++ EXT3COW_SB(sb)->s_mount_state &= ~EXT3COW_ORPHAN_FS;
++ if (needs_recovery)
++ printk (KERN_INFO "EXT3COW-fs: recovery complete.\n");
++ ext3cow_mark_recovery_complete(sb, es);
++ printk (KERN_INFO "EXT3COW-fs: mounted filesystem with %s data mode.\n",
++ test_opt(sb,DATA_FLAGS) == EXT3COW_MOUNT_JOURNAL_DATA ? "journal":
++ test_opt(sb,DATA_FLAGS) == EXT3COW_MOUNT_ORDERED_DATA ? "ordered":
++ "writeback");
++
++ lock_kernel();
++ return 0;
++
++cantfind_ext3cow:
++ if (!silent)
++ printk(KERN_ERR "VFS: Can't find ext3cow filesystem on dev %s.\n",
++ sb->s_id);
++ goto failed_mount;
++
++failed_mount4:
++ journal_destroy(sbi->s_journal);
++failed_mount3:
++ percpu_counter_destroy(&sbi->s_freeblocks_counter);
++ percpu_counter_destroy(&sbi->s_freeinodes_counter);
++ percpu_counter_destroy(&sbi->s_dirs_counter);
++failed_mount2:
++ for (i = 0; i < db_count; i++)
++ brelse(sbi->s_group_desc[i]);
++ kfree(sbi->s_group_desc);
++failed_mount:
++#ifdef CONFIG_QUOTA
++ for (i = 0; i < MAXQUOTAS; i++)
++ kfree(sbi->s_qf_names[i]);
++#endif
++ ext3cow_blkdev_remove(sbi);
++ brelse(bh);
++out_fail:
++ sb->s_fs_info = NULL;
++ kfree(sbi);
++ lock_kernel();
++ return -EINVAL;
++}
++
++/*
++ * Setup any per-fs journal parameters now. We'll do this both on
++ * initial mount, once the journal has been initialised but before we've
++ * done any recovery; and again on any subsequent remount.
++ */
++static void ext3cow_init_journal_params(struct super_block *sb, journal_t *journal)
++{
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++
++ if (sbi->s_commit_interval)
++ journal->j_commit_interval = sbi->s_commit_interval;
++ /* We could also set up an ext3cow-specific default for the commit
++ * interval here, but for now we'll just fall back to the jbd
++ * default. */
++
++ spin_lock(&journal->j_state_lock);
++ if (test_opt(sb, BARRIER))
++ journal->j_flags |= JFS_BARRIER;
++ else
++ journal->j_flags &= ~JFS_BARRIER;
++ spin_unlock(&journal->j_state_lock);
++}
++
++static journal_t *ext3cow_get_journal(struct super_block *sb,
++ unsigned int journal_inum)
++{
++ struct inode *journal_inode;
++ journal_t *journal;
++
++ /* First, test for the existence of a valid inode on disk. Bad
++ * things happen if we iget() an unused inode, as the subsequent
++ * iput() will try to delete it. */
++
++ journal_inode = iget(sb, journal_inum);
++ if (!journal_inode) {
++ printk(KERN_ERR "EXT3COW-fs: no journal found.\n");
++ return NULL;
++ }
++ if (!journal_inode->i_nlink) {
++ make_bad_inode(journal_inode);
++ iput(journal_inode);
++ printk(KERN_ERR "EXT3COW-fs: journal inode is deleted.\n");
++ return NULL;
++ }
++
++ jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
++ journal_inode, journal_inode->i_size);
++ if (is_bad_inode(journal_inode) || !S_ISREG(journal_inode->i_mode)) {
++ printk(KERN_ERR "EXT3COW-fs: invalid journal inode.\n");
++ iput(journal_inode);
++ return NULL;
++ }
++
++ journal = journal_init_inode(journal_inode);
++ if (!journal) {
++ printk(KERN_ERR "EXT3COW-fs: Could not load journal inode\n");
++ iput(journal_inode);
++ return NULL;
++ }
++ /* Make sure the journal never gets versioned -znjp */
++ EXT3COW_I(journal_inode)->i_flags |= EXT3COW_UNVERSIONABLE_FL;
++ journal->j_private = sb;
++ ext3cow_init_journal_params(sb, journal);
++ return journal;
++}
++
++static journal_t *ext3cow_get_dev_journal(struct super_block *sb,
++ dev_t j_dev)
++{
++ struct buffer_head * bh;
++ journal_t *journal;
++ ext3cow_fsblk_t start;
++ ext3cow_fsblk_t len;
++ int hblock, blocksize;
++ ext3cow_fsblk_t sb_block;
++ unsigned long offset;
++ struct ext3cow_super_block * es;
++ struct block_device *bdev;
++
++ bdev = ext3cow_blkdev_get(j_dev);
++ if (bdev == NULL)
++ return NULL;
++
++ if (bd_claim(bdev, sb)) {
++ printk(KERN_ERR
++ "EXT3COW: failed to claim external journal device.\n");
++ blkdev_put(bdev);
++ return NULL;
++ }
++
++ blocksize = sb->s_blocksize;
++ hblock = bdev_hardsect_size(bdev);
++ if (blocksize < hblock) {
++ printk(KERN_ERR
++ "EXT3COW-fs: blocksize too small for journal device.\n");
++ goto out_bdev;
++ }
++
++ sb_block = EXT3COW_MIN_BLOCK_SIZE / blocksize;
++ offset = EXT3COW_MIN_BLOCK_SIZE % blocksize;
++ set_blocksize(bdev, blocksize);
++ if (!(bh = __bread(bdev, sb_block, blocksize))) {
++ printk(KERN_ERR "EXT3COW-fs: couldn't read superblock of "
++ "external journal\n");
++ goto out_bdev;
++ }
++
++ es = (struct ext3cow_super_block *) (((char *)bh->b_data) + offset);
++ if ((le16_to_cpu(es->s_magic) != EXT3COW_SUPER_MAGIC) ||
++ !(le32_to_cpu(es->s_feature_incompat) &
++ EXT3COW_FEATURE_INCOMPAT_JOURNAL_DEV)) {
++ printk(KERN_ERR "EXT3COW-fs: external journal has "
++ "bad superblock\n");
++ brelse(bh);
++ goto out_bdev;
++ }
++
++ if (memcmp(EXT3COW_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
++ printk(KERN_ERR "EXT3COW-fs: journal UUID does not match\n");
++ brelse(bh);
++ goto out_bdev;
++ }
++
++ len = le32_to_cpu(es->s_blocks_count);
++ start = sb_block + 1;
++ brelse(bh); /* we're done with the superblock */
++
++ journal = journal_init_dev(bdev, sb->s_bdev,
++ start, len, blocksize);
++ if (!journal) {
++ printk(KERN_ERR "EXT3COW-fs: failed to create device journal\n");
++ goto out_bdev;
++ }
++ journal->j_private = sb;
++ ll_rw_block(READ, 1, &journal->j_sb_buffer);
++ wait_on_buffer(journal->j_sb_buffer);
++ if (!buffer_uptodate(journal->j_sb_buffer)) {
++ printk(KERN_ERR "EXT3COW-fs: I/O error on journal device\n");
++ goto out_journal;
++ }
++ if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
++ printk(KERN_ERR "EXT3COW-fs: External journal has more than one "
++ "user (unsupported) - %d\n",
++ be32_to_cpu(journal->j_superblock->s_nr_users));
++ goto out_journal;
++ }
++ EXT3COW_SB(sb)->journal_bdev = bdev;
++ ext3cow_init_journal_params(sb, journal);
++ return journal;
++out_journal:
++ journal_destroy(journal);
++out_bdev:
++ ext3cow_blkdev_put(bdev);
++ return NULL;
++}
++
++static int ext3cow_load_journal(struct super_block *sb,
++ struct ext3cow_super_block *es,
++ unsigned long journal_devnum)
++{
++ journal_t *journal;
++ unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
++ dev_t journal_dev;
++ int err = 0;
++ int really_read_only;
++
++ if (journal_devnum &&
++ journal_devnum != le32_to_cpu(es->s_journal_dev)) {
++ printk(KERN_INFO "EXT3COW-fs: external journal device major/minor "
++ "numbers have changed\n");
++ journal_dev = new_decode_dev(journal_devnum);
++ } else
++ journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
++
++ really_read_only = bdev_read_only(sb->s_bdev);
++
++ /*
++ * Are we loading a blank journal or performing recovery after a
++ * crash? For recovery, we need to check in advance whether we
++ * can get read-write access to the device.
++ */
++
++ if (EXT3COW_HAS_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER)) {
++ if (sb->s_flags & MS_RDONLY) {
++ printk(KERN_INFO "EXT3COW-fs: INFO: recovery "
++ "required on readonly filesystem.\n");
++ if (really_read_only) {
++ printk(KERN_ERR "EXT3COW-fs: write access "
++ "unavailable, cannot proceed.\n");
++ return -EROFS;
++ }
++ printk (KERN_INFO "EXT3COW-fs: write access will "
++ "be enabled during recovery.\n");
++ }
++ }
++
++ if (journal_inum && journal_dev) {
++ printk(KERN_ERR "EXT3COW-fs: filesystem has both journal "
++ "and inode journals!\n");
++ return -EINVAL;
++ }
++
++ if (journal_inum) {
++ if (!(journal = ext3cow_get_journal(sb, journal_inum)))
++ return -EINVAL;
++ } else {
++ if (!(journal = ext3cow_get_dev_journal(sb, journal_dev)))
++ return -EINVAL;
++ }
++
++ if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
++ err = journal_update_format(journal);
++ if (err) {
++ printk(KERN_ERR "EXT3COW-fs: error updating journal.\n");
++ journal_destroy(journal);
++ return err;
++ }
++ }
++
++ if (!EXT3COW_HAS_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER))
++ err = journal_wipe(journal, !really_read_only);
++ if (!err)
++ err = journal_load(journal);
++
++ if (err) {
++ printk(KERN_ERR "EXT3COW-fs: error loading journal.\n");
++ journal_destroy(journal);
++ return err;
++ }
++
++ EXT3COW_SB(sb)->s_journal = journal;
++ ext3cow_clear_journal_err(sb, es);
++
++ if (journal_devnum &&
++ journal_devnum != le32_to_cpu(es->s_journal_dev)) {
++ es->s_journal_dev = cpu_to_le32(journal_devnum);
++ sb->s_dirt = 1;
++
++ /* Make sure we flush the recovery flag to disk. */
++ ext3cow_commit_super(sb, es, 1);
++ }
++
++ return 0;
++}
++
++static int ext3cow_create_journal(struct super_block * sb,
++ struct ext3cow_super_block * es,
++ unsigned int journal_inum)
++{
++ journal_t *journal;
++
++ if (sb->s_flags & MS_RDONLY) {
++ printk(KERN_ERR "EXT3COW-fs: readonly filesystem when trying to "
++ "create journal.\n");
++ return -EROFS;
++ }
++
++ if (!(journal = ext3cow_get_journal(sb, journal_inum)))
++ return -EINVAL;
++
++ printk(KERN_INFO "EXT3COW-fs: creating new journal on inode %u\n",
++ journal_inum);
++
++ if (journal_create(journal)) {
++ printk(KERN_ERR "EXT3COW-fs: error creating journal.\n");
++ journal_destroy(journal);
++ return -EIO;
++ }
++
++ EXT3COW_SB(sb)->s_journal = journal;
++
++ ext3cow_update_dynamic_rev(sb);
++ EXT3COW_SET_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER);
++ EXT3COW_SET_COMPAT_FEATURE(sb, EXT3COW_FEATURE_COMPAT_HAS_JOURNAL);
++
++ es->s_journal_inum = cpu_to_le32(journal_inum);
++ sb->s_dirt = 1;
++
++ /* Make sure we flush the recovery flag to disk. */
++ ext3cow_commit_super(sb, es, 1);
++
++ return 0;
++}
++
++static void ext3cow_commit_super (struct super_block * sb,
++ struct ext3cow_super_block * es,
++ int sync)
++{
++ struct buffer_head *sbh = EXT3COW_SB(sb)->s_sbh;
++
++ if (!sbh)
++ return;
++ es->s_wtime = cpu_to_le32(get_seconds());
++ es->s_free_blocks_count = cpu_to_le32(ext3cow_count_free_blocks(sb));
++ es->s_free_inodes_count = cpu_to_le32(ext3cow_count_free_inodes(sb));
++ BUFFER_TRACE(sbh, "marking dirty");
++ mark_buffer_dirty(sbh);
++ if (sync)
++ sync_dirty_buffer(sbh);
++}
++
++
++/*
++ * Have we just finished recovery? If so, and if we are mounting (or
++ * remounting) the filesystem readonly, then we will end up with a
++ * consistent fs on disk. Record that fact.
++ */
++static void ext3cow_mark_recovery_complete(struct super_block * sb,
++ struct ext3cow_super_block * es)
++{
++ journal_t *journal = EXT3COW_SB(sb)->s_journal;
++
++ journal_lock_updates(journal);
++ journal_flush(journal);
++ if (EXT3COW_HAS_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER) &&
++ sb->s_flags & MS_RDONLY) {
++ EXT3COW_CLEAR_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER);
++ sb->s_dirt = 0;
++ ext3cow_commit_super(sb, es, 1);
++ }
++ journal_unlock_updates(journal);
++}
++
++/*
++ * If we are mounting (or read-write remounting) a filesystem whose journal
++ * has recorded an error from a previous lifetime, move that error to the
++ * main filesystem now.
++ */
++static void ext3cow_clear_journal_err(struct super_block * sb,
++ struct ext3cow_super_block * es)
++{
++ journal_t *journal;
++ int j_errno;
++ const char *errstr;
++
++ journal = EXT3COW_SB(sb)->s_journal;
++
++ /*
++ * Now check for any error status which may have been recorded in the
++ * journal by a prior ext3cow_error() or ext3cow_abort()
++ */
++
++ j_errno = journal_errno(journal);
++ if (j_errno) {
++ char nbuf[16];
++
++ errstr = ext3cow_decode_error(sb, j_errno, nbuf);
++ ext3cow_warning(sb, __FUNCTION__, "Filesystem error recorded "
++ "from previous mount: %s", errstr);
++ ext3cow_warning(sb, __FUNCTION__, "Marking fs in need of "
++ "filesystem check.");
++
++ EXT3COW_SB(sb)->s_mount_state |= EXT3COW_ERROR_FS;
++ es->s_state |= cpu_to_le16(EXT3COW_ERROR_FS);
++ ext3cow_commit_super (sb, es, 1);
++
++ journal_clear_err(journal);
++ }
++}
++
++/*
++ * Force the running and committing transactions to commit,
++ * and wait on the commit.
++ */
++int ext3cow_force_commit(struct super_block *sb)
++{
++ journal_t *journal;
++ int ret;
++
++ if (sb->s_flags & MS_RDONLY)
++ return 0;
++
++ journal = EXT3COW_SB(sb)->s_journal;
++ sb->s_dirt = 0;
++ ret = ext3cow_journal_force_commit(journal);
++ return ret;
++}
++
++/*
++ * Ext3 always journals updates to the superblock itself, so we don't
++ * have to propagate any other updates to the superblock on disk at this
++ * point. Just start an async writeback to get the buffers on their way
++ * to the disk.
++ *
++ * This implicitly triggers the writebehind on sync().
++ */
++
++static void ext3cow_write_super (struct super_block * sb)
++{
++ if (mutex_trylock(&sb->s_lock) != 0)
++ BUG();
++ sb->s_dirt = 0;
++}
++
++static int ext3cow_sync_fs(struct super_block *sb, int wait)
++{
++ tid_t target;
++
++ sb->s_dirt = 0;
++ if (journal_start_commit(EXT3COW_SB(sb)->s_journal, &target)) {
++ if (wait)
++ log_wait_commit(EXT3COW_SB(sb)->s_journal, target);
++ }
++ return 0;
++}
++
++/*
++ * LVM calls this function before a (read-only) snapshot is created. This
++ * gives us a chance to flush the journal completely and mark the fs clean.
++ */
++static void ext3cow_write_super_lockfs(struct super_block *sb)
++{
++ sb->s_dirt = 0;
++
++ if (!(sb->s_flags & MS_RDONLY)) {
++ journal_t *journal = EXT3COW_SB(sb)->s_journal;
++
++ /* Now we set up the journal barrier. */
++ journal_lock_updates(journal);
++ journal_flush(journal);
++
++ /* Journal blocked and flushed, clear needs_recovery flag. */
++ EXT3COW_CLEAR_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER);
++ ext3cow_commit_super(sb, EXT3COW_SB(sb)->s_es, 1);
++ }
++}
++
++/*
++ * Called by LVM after the snapshot is done. We need to reset the RECOVER
++ * flag here, even though the filesystem is not technically dirty yet.
++ */
++static void ext3cow_unlockfs(struct super_block *sb)
++{
++ if (!(sb->s_flags & MS_RDONLY)) {
++ lock_super(sb);
++ /* Reser the needs_recovery flag before the fs is unlocked. */
++ EXT3COW_SET_INCOMPAT_FEATURE(sb, EXT3COW_FEATURE_INCOMPAT_RECOVER);
++ ext3cow_commit_super(sb, EXT3COW_SB(sb)->s_es, 1);
++ unlock_super(sb);
++ journal_unlock_updates(EXT3COW_SB(sb)->s_journal);
++ }
++}
++
++static int ext3cow_remount (struct super_block * sb, int * flags, char * data)
++{
++ struct ext3cow_super_block * es;
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ ext3cow_fsblk_t n_blocks_count = 0;
++ unsigned long old_sb_flags;
++ struct ext3cow_mount_options old_opts;
++ int err;
++#ifdef CONFIG_QUOTA
++ int i;
++#endif
++
++ /* Store the original options */
++ old_sb_flags = sb->s_flags;
++ old_opts.s_mount_opt = sbi->s_mount_opt;
++ old_opts.s_resuid = sbi->s_resuid;
++ old_opts.s_resgid = sbi->s_resgid;
++ old_opts.s_commit_interval = sbi->s_commit_interval;
++#ifdef CONFIG_QUOTA
++ old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
++ for (i = 0; i < MAXQUOTAS; i++)
++ old_opts.s_qf_names[i] = sbi->s_qf_names[i];
++#endif
++
++ /*
++ * Allow the "check" option to be passed as a remount option.
++ */
++ if (!parse_options(data, sb, NULL, NULL, &n_blocks_count, 1)) {
++ err = -EINVAL;
++ goto restore_opts;
++ }
++
++ if (sbi->s_mount_opt & EXT3COW_MOUNT_ABORT)
++ ext3cow_abort(sb, __FUNCTION__, "Abort forced by user");
++
++ sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
++ ((sbi->s_mount_opt & EXT3COW_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
++
++ es = sbi->s_es;
++
++ ext3cow_init_journal_params(sb, sbi->s_journal);
++
++ if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
++ n_blocks_count > le32_to_cpu(es->s_blocks_count)) {
++ if (sbi->s_mount_opt & EXT3COW_MOUNT_ABORT) {
++ err = -EROFS;
++ goto restore_opts;
++ }
++
++ if (*flags & MS_RDONLY) {
++ /*
++ * First of all, the unconditional stuff we have to do
++ * to disable replay of the journal when we next remount
++ */
++ sb->s_flags |= MS_RDONLY;
++
++ /*
++ * OK, test if we are remounting a valid rw partition
++ * readonly, and if so set the rdonly flag and then
++ * mark the partition as valid again.
++ */
++ if (!(es->s_state & cpu_to_le16(EXT3COW_VALID_FS)) &&
++ (sbi->s_mount_state & EXT3COW_VALID_FS))
++ es->s_state = cpu_to_le16(sbi->s_mount_state);
++
++ ext3cow_mark_recovery_complete(sb, es);
++ } else {
++ __le32 ret;
++ if ((ret = EXT3COW_HAS_RO_COMPAT_FEATURE(sb,
++ ~EXT3COW_FEATURE_RO_COMPAT_SUPP))) {
++ printk(KERN_WARNING "EXT3COW-fs: %s: couldn't "
++ "remount RDWR because of unsupported "
++ "optional features (%x).\n",
++ sb->s_id, le32_to_cpu(ret));
++ err = -EROFS;
++ goto restore_opts;
++ }
++ /*
++ * Mounting a RDONLY partition read-write, so reread
++ * and store the current valid flag. (It may have
++ * been changed by e2fsck since we originally mounted
++ * the partition.)
++ */
++ ext3cow_clear_journal_err(sb, es);
++ sbi->s_mount_state = le16_to_cpu(es->s_state);
++ if ((err = ext3cow_group_extend(sb, es, n_blocks_count)))
++ goto restore_opts;
++ if (!ext3cow_setup_super (sb, es, 0))
++ sb->s_flags &= ~MS_RDONLY;
++ }
++ }
++#ifdef CONFIG_QUOTA
++ /* Release old quota file names */
++ for (i = 0; i < MAXQUOTAS; i++)
++ if (old_opts.s_qf_names[i] &&
++ old_opts.s_qf_names[i] != sbi->s_qf_names[i])
++ kfree(old_opts.s_qf_names[i]);
++#endif
++ return 0;
++restore_opts:
++ sb->s_flags = old_sb_flags;
++ sbi->s_mount_opt = old_opts.s_mount_opt;
++ sbi->s_resuid = old_opts.s_resuid;
++ sbi->s_resgid = old_opts.s_resgid;
++ sbi->s_commit_interval = old_opts.s_commit_interval;
++#ifdef CONFIG_QUOTA
++ sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
++ for (i = 0; i < MAXQUOTAS; i++) {
++ if (sbi->s_qf_names[i] &&
++ old_opts.s_qf_names[i] != sbi->s_qf_names[i])
++ kfree(sbi->s_qf_names[i]);
++ sbi->s_qf_names[i] = old_opts.s_qf_names[i];
++ }
++#endif
++ return err;
++}
++
++static int ext3cow_statfs (struct dentry * dentry, struct kstatfs * buf)
++{
++ struct super_block *sb = dentry->d_sb;
++ struct ext3cow_sb_info *sbi = EXT3COW_SB(sb);
++ struct ext3cow_super_block *es = sbi->s_es;
++ ext3cow_fsblk_t overhead;
++ int i;
++ u64 fsid;
++
++ if (test_opt (sb, MINIX_DF))
++ overhead = 0;
++ else {
++ unsigned long ngroups;
++ ngroups = EXT3COW_SB(sb)->s_groups_count;
++ smp_rmb();
++
++ /*
++ * Compute the overhead (FS structures)
++ */
++
++ /*
++ * All of the blocks before first_data_block are
++ * overhead
++ */
++ overhead = le32_to_cpu(es->s_first_data_block);
++
++ /*
++ * Add the overhead attributed to the superblock and
++ * block group descriptors. If the sparse superblocks
++ * feature is turned on, then not all groups have this.
++ */
++ for (i = 0; i < ngroups; i++) {
++ overhead += ext3cow_bg_has_super(sb, i) +
++ ext3cow_bg_num_gdb(sb, i);
++ cond_resched();
++ }
++
++ /*
++ * Every block group has an inode bitmap, a block
++ * bitmap, and an inode table.
++ */
++ overhead += (ngroups * (2 + EXT3COW_SB(sb)->s_itb_per_group));
++ }
++
++ buf->f_type = EXT3COW_SUPER_MAGIC;
++ buf->f_bsize = sb->s_blocksize;
++ buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
++ buf->f_bfree = percpu_counter_sum(&sbi->s_freeblocks_counter);
++ buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
++ if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
++ buf->f_bavail = 0;
++ buf->f_files = le32_to_cpu(es->s_inodes_count);
++ buf->f_ffree = percpu_counter_sum(&sbi->s_freeinodes_counter);
++ buf->f_namelen = EXT3COW_NAME_LEN;
++ fsid = le64_to_cpup((void *)es->s_uuid) ^
++ le64_to_cpup((void *)es->s_uuid + sizeof(u64));
++ buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
++ buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
++ return 0;
++}
++
++/* Helper function for writing quotas on sync - we need to start transaction before quota file
++ * is locked for write. Otherwise the are possible deadlocks:
++ * Process 1 Process 2
++ * ext3cow_create() quota_sync()
++ * journal_start() write_dquot()
++ * DQUOT_INIT() down(dqio_mutex)
++ * down(dqio_mutex) journal_start()
++ *
++ */
++
++#ifdef CONFIG_QUOTA
++
++static inline struct inode *dquot_to_inode(struct dquot *dquot)
++{
++ return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
++}
++
++static int ext3cow_dquot_initialize(struct inode *inode, int type)
++{
++ handle_t *handle;
++ int ret, err;
++
++ /* We may create quota structure so we need to reserve enough blocks */
++ handle = ext3cow_journal_start(inode, 2*EXT3COW_QUOTA_INIT_BLOCKS(inode->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ ret = dquot_initialize(inode, type);
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++ return ret;
++}
++
++static int ext3cow_dquot_drop(struct inode *inode)
++{
++ handle_t *handle;
++ int ret, err;
++
++ /* We may delete quota structure so we need to reserve enough blocks */
++ handle = ext3cow_journal_start(inode, 2*EXT3COW_QUOTA_DEL_BLOCKS(inode->i_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ ret = dquot_drop(inode);
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++ return ret;
++}
++
++static int ext3cow_write_dquot(struct dquot *dquot)
++{
++ int ret, err;
++ handle_t *handle;
++ struct inode *inode;
++
++ inode = dquot_to_inode(dquot);
++ handle = ext3cow_journal_start(inode,
++ EXT3COW_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ ret = dquot_commit(dquot);
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++ return ret;
++}
++
++static int ext3cow_acquire_dquot(struct dquot *dquot)
++{
++ int ret, err;
++ handle_t *handle;
++
++ handle = ext3cow_journal_start(dquot_to_inode(dquot),
++ EXT3COW_QUOTA_INIT_BLOCKS(dquot->dq_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ ret = dquot_acquire(dquot);
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++ return ret;
++}
++
++static int ext3cow_release_dquot(struct dquot *dquot)
++{
++ int ret, err;
++ handle_t *handle;
++
++ handle = ext3cow_journal_start(dquot_to_inode(dquot),
++ EXT3COW_QUOTA_DEL_BLOCKS(dquot->dq_sb));
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ ret = dquot_release(dquot);
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++ return ret;
++}
++
++static int ext3cow_mark_dquot_dirty(struct dquot *dquot)
++{
++ /* Are we journalling quotas? */
++ if (EXT3COW_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
++ EXT3COW_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
++ dquot_mark_dquot_dirty(dquot);
++ return ext3cow_write_dquot(dquot);
++ } else {
++ return dquot_mark_dquot_dirty(dquot);
++ }
++}
++
++static int ext3cow_write_info(struct super_block *sb, int type)
++{
++ int ret, err;
++ handle_t *handle;
++
++ /* Data block + inode block */
++ handle = ext3cow_journal_start(sb->s_root->d_inode, 2);
++ if (IS_ERR(handle))
++ return PTR_ERR(handle);
++ ret = dquot_commit_info(sb, type);
++ err = ext3cow_journal_stop(handle);
++ if (!ret)
++ ret = err;
++ return ret;
++}
++
++/*
++ * Turn on quotas during mount time - we need to find
++ * the quota file and such...
++ */
++static int ext3cow_quota_on_mount(struct super_block *sb, int type)
++{
++ return vfs_quota_on_mount(sb, EXT3COW_SB(sb)->s_qf_names[type],
++ EXT3COW_SB(sb)->s_jquota_fmt, type);
++}
++
++/*
++ * Standard function to be called on quota_on
++ */
++static int ext3cow_quota_on(struct super_block *sb, int type, int format_id,
++ char *path)
++{
++ int err;
++ struct nameidata nd;
++
++ if (!test_opt(sb, QUOTA))
++ return -EINVAL;
++ /* Not journalling quota? */
++ if (!EXT3COW_SB(sb)->s_qf_names[USRQUOTA] &&
++ !EXT3COW_SB(sb)->s_qf_names[GRPQUOTA])
++ return vfs_quota_on(sb, type, format_id, path);
++ err = path_lookup(path, LOOKUP_FOLLOW, &nd);
++ if (err)
++ return err;
++ /* Quotafile not on the same filesystem? */
++ if (nd.mnt->mnt_sb != sb) {
++ path_release(&nd);
++ return -EXDEV;
++ }
++ /* Quotafile not of fs root? */
++ if (nd.dentry->d_parent->d_inode != sb->s_root->d_inode)
++ printk(KERN_WARNING
++ "EXT3COW-fs: Quota file not on filesystem root. "
++ "Journalled quota will not work.\n");
++ path_release(&nd);
++ return vfs_quota_on(sb, type, format_id, path);
++}
++
++/* Read data from quotafile - avoid pagecache and such because we cannot afford
++ * acquiring the locks... As quota files are never truncated and quota code
++ * itself serializes the operations (and noone else should touch the files)
++ * we don't have to be afraid of races */
++static ssize_t ext3cow_quota_read(struct super_block *sb, int type, char *data,
++ size_t len, loff_t off)
++{
++ struct inode *inode = sb_dqopt(sb)->files[type];
++ sector_t blk = off >> EXT3COW_BLOCK_SIZE_BITS(sb);
++ int err = 0;
++ int offset = off & (sb->s_blocksize - 1);
++ int tocopy;
++ size_t toread;
++ struct buffer_head *bh;
++ loff_t i_size = i_size_read(inode);
++
++ if (off > i_size)
++ return 0;
++ if (off+len > i_size)
++ len = i_size-off;
++ toread = len;
++ while (toread > 0) {
++ tocopy = sb->s_blocksize - offset < toread ?
++ sb->s_blocksize - offset : toread;
++ bh = ext3cow_bread(NULL, inode, blk, 0, &err);
++ if (err)
++ return err;
++ if (!bh) /* A hole? */
++ memset(data, 0, tocopy);
++ else
++ memcpy(data, bh->b_data+offset, tocopy);
++ brelse(bh);
++ offset = 0;
++ toread -= tocopy;
++ data += tocopy;
++ blk++;
++ }
++ return len;
++}
++
++/* Write to quotafile (we know the transaction is already started and has
++ * enough credits) */
++static ssize_t ext3cow_quota_write(struct super_block *sb, int type,
++ const char *data, size_t len, loff_t off)
++{
++ struct inode *inode = sb_dqopt(sb)->files[type];
++ sector_t blk = off >> EXT3COW_BLOCK_SIZE_BITS(sb);
++ int err = 0;
++ int offset = off & (sb->s_blocksize - 1);
++ int tocopy;
++ int journal_quota = EXT3COW_SB(sb)->s_qf_names[type] != NULL;
++ size_t towrite = len;
++ struct buffer_head *bh;
++ handle_t *handle = journal_current_handle();
++
++ mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
++ while (towrite > 0) {
++ tocopy = sb->s_blocksize - offset < towrite ?
++ sb->s_blocksize - offset : towrite;
++ bh = ext3cow_bread(handle, inode, blk, 1, &err);
++ if (!bh)
++ goto out;
++ if (journal_quota) {
++ err = ext3cow_journal_get_write_access(handle, bh);
++ if (err) {
++ brelse(bh);
++ goto out;
++ }
++ }
++ lock_buffer(bh);
++ memcpy(bh->b_data+offset, data, tocopy);
++ flush_dcache_page(bh->b_page);
++ unlock_buffer(bh);
++ if (journal_quota)
++ err = ext3cow_journal_dirty_metadata(handle, bh);
++ else {
++ /* Always do at least ordered writes for quotas */
++ err = ext3cow_journal_dirty_data(handle, bh);
++ mark_buffer_dirty(bh);
++ }
++ brelse(bh);
++ if (err)
++ goto out;
++ offset = 0;
++ towrite -= tocopy;
++ data += tocopy;
++ blk++;
++ }
++out:
++ if (len == towrite)
++ return err;
++ if (inode->i_size < off+len-towrite) {
++ i_size_write(inode, off+len-towrite);
++ EXT3COW_I(inode)->i_disksize = inode->i_size;
++ }
++ inode->i_version++;
++ inode->i_mtime = inode->i_ctime = CURRENT_TIME;
++ ext3cow_mark_inode_dirty(handle, inode);
++ mutex_unlock(&inode->i_mutex);
++ return len - towrite;
++}
++
++#endif
++
++static int ext3cow_get_sb(struct file_system_type *fs_type,
++ int flags, const char *dev_name, void *data, struct vfsmount *mnt)
++{
++ return get_sb_bdev(fs_type, flags, dev_name, data, ext3cow_fill_super, mnt);
++}
++
++/* Code to update the epoch counter in the super block -znjp */
++unsigned int ext3cow_take_snapshot(struct super_block *sb){
++
++ struct ext3cow_sb_info *sbi = NULL;
++ struct ext3cow_super_block *es = NULL;
++ tid_t target;
++
++ if(NULL == sb){
++ printk("EXT3COW-fs: superblock is NULL when taking snapshot.\n");
++ return -1;
++ }
++
++ sbi = EXT3COW_SB(sb);
++ es = sbi->s_es;
++
++ /* Sync the dirty blocks */
++ if (journal_start_commit(EXT3COW_SB(sb)->s_journal, &target)) {
++ log_wait_commit(EXT3COW_SB(sb)->s_journal, target);
++ }
++
++
++ sbi->s_epoch_number = cpu_to_le32(get_seconds());
++ es->s_epoch_number = sbi->s_epoch_number;
++ sb->s_dirt = 1;
++
++ BUFFER_TRACE(EXT3COW_SB(sb)->s_sbh, "marking dirty");
++ mark_buffer_dirty(sbi->s_sbh);
++ ext3cow_commit_super (sb, es, 1);
++
++ return (unsigned int)sbi->s_epoch_number;
++}
++
++static struct file_system_type ext3cow_fs_type = {
++ .owner = THIS_MODULE,
++ .name = "ext3cow",
++ .get_sb = ext3cow_get_sb,
++ .kill_sb = kill_block_super,
++ .fs_flags = FS_REQUIRES_DEV,
++};
++
++static int __init init_ext3cow_fs(void)
++{
++ int err = init_ext3cow_xattr();
++ if (err)
++ return err;
++ err = init_inodecache();
++ if (err)
++ goto out1;
++ err = register_filesystem(&ext3cow_fs_type);
++ if (err)
++ goto out;
++ return 0;
++out:
++ destroy_inodecache();
++out1:
++ exit_ext3cow_xattr();
++ return err;
++}
++
++static void __exit exit_ext3cow_fs(void)
++{
++ unregister_filesystem(&ext3cow_fs_type);
++ destroy_inodecache();
++ exit_ext3cow_xattr();
++}
++
++MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
++MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
++MODULE_LICENSE("GPL");
++module_init(init_ext3cow_fs)
++module_exit(exit_ext3cow_fs)
+diff -ruN linux-2.6.20.3/fs/ext3cow/symlink.c linux-2.6.20.3-ext3cow/fs/ext3cow/symlink.c
+--- linux-2.6.20.3/fs/ext3cow/symlink.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/symlink.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,54 @@
++/*
++ * linux/fs/ext3cow/symlink.c
++ *
++ * Only fast symlinks left here - the rest is done by generic code. AV, 1999
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/fs/minix/symlink.c
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ *
++ * ext3cow symlink handling code
++ */
++
++#include
++#include
++#include
++#include
++#include "xattr.h"
++
++static void * ext3cow_follow_link(struct dentry *dentry, struct nameidata *nd)
++{
++ struct ext3cow_inode_info *ei = EXT3COW_I(dentry->d_inode);
++ nd_set_link(nd, (char*)ei->i_data);
++ return NULL;
++}
++
++struct inode_operations ext3cow_symlink_inode_operations = {
++ .readlink = generic_readlink,
++ .follow_link = page_follow_link_light,
++ .put_link = page_put_link,
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ .setxattr = generic_setxattr,
++ .getxattr = generic_getxattr,
++ .listxattr = ext3cow_listxattr,
++ .removexattr = generic_removexattr,
++#endif
++};
++
++struct inode_operations ext3cow_fast_symlink_inode_operations = {
++ .readlink = generic_readlink,
++ .follow_link = ext3cow_follow_link,
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ .setxattr = generic_setxattr,
++ .getxattr = generic_getxattr,
++ .listxattr = ext3cow_listxattr,
++ .removexattr = generic_removexattr,
++#endif
++};
+diff -ruN linux-2.6.20.3/fs/ext3cow/xattr.c linux-2.6.20.3-ext3cow/fs/ext3cow/xattr.c
+--- linux-2.6.20.3/fs/ext3cow/xattr.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/xattr.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,1314 @@
++/*
++ * linux/fs/ext3cow/xattr.c
++ *
++ * Copyright (C) 2001-2003 Andreas Gruenbacher,
++ *
++ * Fix by Harrison Xing .
++ * Ext3 code with a lot of help from Eric Jarman .
++ * Extended attributes for symlinks and special files added per
++ * suggestion of Luka Renko .
++ * xattr consolidation Copyright (c) 2004 James Morris ,
++ * Red Hat Inc.
++ * ea-in-inode support by Alex Tomas aka bzzz
++ * and Andreas Gruenbacher .
++ */
++
++/*
++ * Extended attributes are stored directly in inodes (on file systems with
++ * inodes bigger than 128 bytes) and on additional disk blocks. The i_file_acl
++ * field contains the block number if an inode uses an additional block. All
++ * attributes must fit in the inode and one additional block. Blocks that
++ * contain the identical set of attributes may be shared among several inodes.
++ * Identical blocks are detected by keeping a cache of blocks that have
++ * recently been accessed.
++ *
++ * The attributes in inodes and on blocks have a different header; the entries
++ * are stored in the same format:
++ *
++ * +------------------+
++ * | header |
++ * | entry 1 | |
++ * | entry 2 | | growing downwards
++ * | entry 3 | v
++ * | four null bytes |
++ * | . . . |
++ * | value 1 | ^
++ * | value 3 | | growing upwards
++ * | value 2 | |
++ * +------------------+
++ *
++ * The header is followed by multiple entry descriptors. In disk blocks, the
++ * entry descriptors are kept sorted. In inodes, they are unsorted. The
++ * attribute values are aligned to the end of the block in no specific order.
++ *
++ * Locking strategy
++ * ----------------
++ * EXT3COW_I(inode)->i_file_acl is protected by EXT3COW_I(inode)->xattr_sem.
++ * EA blocks are only changed if they are exclusive to an inode, so
++ * holding xattr_sem also means that nothing but the EA block's reference
++ * count can change. Multiple writers to the same block are synchronized
++ * by the buffer lock.
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include "xattr.h"
++#include "acl.h"
++
++#define BHDR(bh) ((struct ext3cow_xattr_header *)((bh)->b_data))
++#define ENTRY(ptr) ((struct ext3cow_xattr_entry *)(ptr))
++#define BFIRST(bh) ENTRY(BHDR(bh)+1)
++#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
++
++#define IHDR(inode, raw_inode) \
++ ((struct ext3cow_xattr_ibody_header *) \
++ ((void *)raw_inode + \
++ EXT3COW_GOOD_OLD_INODE_SIZE + \
++ EXT3COW_I(inode)->i_extra_isize))
++#define IFIRST(hdr) ((struct ext3cow_xattr_entry *)((hdr)+1))
++
++#ifdef EXT3COW_XATTR_DEBUG
++# define ea_idebug(inode, f...) do { \
++ printk(KERN_DEBUG "inode %s:%lu: ", \
++ inode->i_sb->s_id, inode->i_ino); \
++ printk(f); \
++ printk("\n"); \
++ } while (0)
++# define ea_bdebug(bh, f...) do { \
++ char b[BDEVNAME_SIZE]; \
++ printk(KERN_DEBUG "block %s:%lu: ", \
++ bdevname(bh->b_bdev, b), \
++ (unsigned long) bh->b_blocknr); \
++ printk(f); \
++ printk("\n"); \
++ } while (0)
++#else
++# define ea_idebug(f...)
++# define ea_bdebug(f...)
++#endif
++
++static void ext3cow_xattr_cache_insert(struct buffer_head *);
++static struct buffer_head *ext3cow_xattr_cache_find(struct inode *,
++ struct ext3cow_xattr_header *,
++ struct mb_cache_entry **);
++static void ext3cow_xattr_rehash(struct ext3cow_xattr_header *,
++ struct ext3cow_xattr_entry *);
++
++static struct mb_cache *ext3cow_xattr_cache;
++
++static struct xattr_handler *ext3cow_xattr_handler_map[] = {
++ [EXT3COW_XATTR_INDEX_USER] = &ext3cow_xattr_user_handler,
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++ [EXT3COW_XATTR_INDEX_POSIX_ACL_ACCESS] = &ext3cow_xattr_acl_access_handler,
++ [EXT3COW_XATTR_INDEX_POSIX_ACL_DEFAULT] = &ext3cow_xattr_acl_default_handler,
++#endif
++ [EXT3COW_XATTR_INDEX_TRUSTED] = &ext3cow_xattr_trusted_handler,
++#ifdef CONFIG_EXT3COW_FS_SECURITY
++ [EXT3COW_XATTR_INDEX_SECURITY] = &ext3cow_xattr_security_handler,
++#endif
++};
++
++struct xattr_handler *ext3cow_xattr_handlers[] = {
++ &ext3cow_xattr_user_handler,
++ &ext3cow_xattr_trusted_handler,
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++ &ext3cow_xattr_acl_access_handler,
++ &ext3cow_xattr_acl_default_handler,
++#endif
++#ifdef CONFIG_EXT3COW_FS_SECURITY
++ &ext3cow_xattr_security_handler,
++#endif
++ NULL
++};
++
++static inline struct xattr_handler *
++ext3cow_xattr_handler(int name_index)
++{
++ struct xattr_handler *handler = NULL;
++
++ if (name_index > 0 && name_index < ARRAY_SIZE(ext3cow_xattr_handler_map))
++ handler = ext3cow_xattr_handler_map[name_index];
++ return handler;
++}
++
++/*
++ * Inode operation listxattr()
++ *
++ * dentry->d_inode->i_mutex: don't care
++ */
++ssize_t
++ext3cow_listxattr(struct dentry *dentry, char *buffer, size_t size)
++{
++ return ext3cow_xattr_list(dentry->d_inode, buffer, size);
++}
++
++static int
++ext3cow_xattr_check_names(struct ext3cow_xattr_entry *entry, void *end)
++{
++ while (!IS_LAST_ENTRY(entry)) {
++ struct ext3cow_xattr_entry *next = EXT3COW_XATTR_NEXT(entry);
++ if ((void *)next >= end)
++ return -EIO;
++ entry = next;
++ }
++ return 0;
++}
++
++static inline int
++ext3cow_xattr_check_block(struct buffer_head *bh)
++{
++ int error;
++
++ if (BHDR(bh)->h_magic != cpu_to_le32(EXT3COW_XATTR_MAGIC) ||
++ BHDR(bh)->h_blocks != cpu_to_le32(1))
++ return -EIO;
++ error = ext3cow_xattr_check_names(BFIRST(bh), bh->b_data + bh->b_size);
++ return error;
++}
++
++static inline int
++ext3cow_xattr_check_entry(struct ext3cow_xattr_entry *entry, size_t size)
++{
++ size_t value_size = le32_to_cpu(entry->e_value_size);
++
++ if (entry->e_value_block != 0 || value_size > size ||
++ le16_to_cpu(entry->e_value_offs) + value_size > size)
++ return -EIO;
++ return 0;
++}
++
++static int
++ext3cow_xattr_find_entry(struct ext3cow_xattr_entry **pentry, int name_index,
++ const char *name, size_t size, int sorted)
++{
++ struct ext3cow_xattr_entry *entry;
++ size_t name_len;
++ int cmp = 1;
++
++ if (name == NULL)
++ return -EINVAL;
++ name_len = strlen(name);
++ entry = *pentry;
++ for (; !IS_LAST_ENTRY(entry); entry = EXT3COW_XATTR_NEXT(entry)) {
++ cmp = name_index - entry->e_name_index;
++ if (!cmp)
++ cmp = name_len - entry->e_name_len;
++ if (!cmp)
++ cmp = memcmp(name, entry->e_name, name_len);
++ if (cmp <= 0 && (sorted || cmp == 0))
++ break;
++ }
++ *pentry = entry;
++ if (!cmp && ext3cow_xattr_check_entry(entry, size))
++ return -EIO;
++ return cmp ? -ENODATA : 0;
++}
++
++static int
++ext3cow_xattr_block_get(struct inode *inode, int name_index, const char *name,
++ void *buffer, size_t buffer_size)
++{
++ struct buffer_head *bh = NULL;
++ struct ext3cow_xattr_entry *entry;
++ size_t size;
++ int error;
++
++ ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
++ name_index, name, buffer, (long)buffer_size);
++
++ error = -ENODATA;
++ if (!EXT3COW_I(inode)->i_file_acl)
++ goto cleanup;
++ ea_idebug(inode, "reading block %u", EXT3COW_I(inode)->i_file_acl);
++ bh = sb_bread(inode->i_sb, EXT3COW_I(inode)->i_file_acl);
++ if (!bh)
++ goto cleanup;
++ ea_bdebug(bh, "b_count=%d, refcount=%d",
++ atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
++ if (ext3cow_xattr_check_block(bh)) {
++bad_block: ext3cow_error(inode->i_sb, __FUNCTION__,
++ "inode %lu: bad block "E3FSBLK, inode->i_ino,
++ EXT3COW_I(inode)->i_file_acl);
++ error = -EIO;
++ goto cleanup;
++ }
++ ext3cow_xattr_cache_insert(bh);
++ entry = BFIRST(bh);
++ error = ext3cow_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
++ if (error == -EIO)
++ goto bad_block;
++ if (error)
++ goto cleanup;
++ size = le32_to_cpu(entry->e_value_size);
++ if (buffer) {
++ error = -ERANGE;
++ if (size > buffer_size)
++ goto cleanup;
++ memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
++ size);
++ }
++ error = size;
++
++cleanup:
++ brelse(bh);
++ return error;
++}
++
++static int
++ext3cow_xattr_ibody_get(struct inode *inode, int name_index, const char *name,
++ void *buffer, size_t buffer_size)
++{
++ struct ext3cow_xattr_ibody_header *header;
++ struct ext3cow_xattr_entry *entry;
++ struct ext3cow_inode *raw_inode;
++ struct ext3cow_iloc iloc;
++ size_t size;
++ void *end;
++ int error;
++
++ if (!(EXT3COW_I(inode)->i_state & EXT3COW_STATE_XATTR))
++ return -ENODATA;
++ error = ext3cow_get_inode_loc(inode, &iloc);
++ if (error)
++ return error;
++ raw_inode = ext3cow_raw_inode(&iloc);
++ header = IHDR(inode, raw_inode);
++ entry = IFIRST(header);
++ end = (void *)raw_inode + EXT3COW_SB(inode->i_sb)->s_inode_size;
++ error = ext3cow_xattr_check_names(entry, end);
++ if (error)
++ goto cleanup;
++ error = ext3cow_xattr_find_entry(&entry, name_index, name,
++ end - (void *)entry, 0);
++ if (error)
++ goto cleanup;
++ size = le32_to_cpu(entry->e_value_size);
++ if (buffer) {
++ error = -ERANGE;
++ if (size > buffer_size)
++ goto cleanup;
++ memcpy(buffer, (void *)IFIRST(header) +
++ le16_to_cpu(entry->e_value_offs), size);
++ }
++ error = size;
++
++cleanup:
++ brelse(iloc.bh);
++ return error;
++}
++
++/*
++ * ext3cow_xattr_get()
++ *
++ * Copy an extended attribute into the buffer
++ * provided, or compute the buffer size required.
++ * Buffer is NULL to compute the size of the buffer required.
++ *
++ * Returns a negative error number on failure, or the number of bytes
++ * used / required on success.
++ */
++int
++ext3cow_xattr_get(struct inode *inode, int name_index, const char *name,
++ void *buffer, size_t buffer_size)
++{
++ int error;
++
++ down_read(&EXT3COW_I(inode)->xattr_sem);
++ error = ext3cow_xattr_ibody_get(inode, name_index, name, buffer,
++ buffer_size);
++ if (error == -ENODATA)
++ error = ext3cow_xattr_block_get(inode, name_index, name, buffer,
++ buffer_size);
++ up_read(&EXT3COW_I(inode)->xattr_sem);
++ return error;
++}
++
++static int
++ext3cow_xattr_list_entries(struct inode *inode, struct ext3cow_xattr_entry *entry,
++ char *buffer, size_t buffer_size)
++{
++ size_t rest = buffer_size;
++
++ for (; !IS_LAST_ENTRY(entry); entry = EXT3COW_XATTR_NEXT(entry)) {
++ struct xattr_handler *handler =
++ ext3cow_xattr_handler(entry->e_name_index);
++
++ if (handler) {
++ size_t size = handler->list(inode, buffer, rest,
++ entry->e_name,
++ entry->e_name_len);
++ if (buffer) {
++ if (size > rest)
++ return -ERANGE;
++ buffer += size;
++ }
++ rest -= size;
++ }
++ }
++ return buffer_size - rest;
++}
++
++static int
++ext3cow_xattr_block_list(struct inode *inode, char *buffer, size_t buffer_size)
++{
++ struct buffer_head *bh = NULL;
++ int error;
++
++ ea_idebug(inode, "buffer=%p, buffer_size=%ld",
++ buffer, (long)buffer_size);
++
++ error = 0;
++ if (!EXT3COW_I(inode)->i_file_acl)
++ goto cleanup;
++ ea_idebug(inode, "reading block %u", EXT3COW_I(inode)->i_file_acl);
++ bh = sb_bread(inode->i_sb, EXT3COW_I(inode)->i_file_acl);
++ error = -EIO;
++ if (!bh)
++ goto cleanup;
++ ea_bdebug(bh, "b_count=%d, refcount=%d",
++ atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
++ if (ext3cow_xattr_check_block(bh)) {
++ ext3cow_error(inode->i_sb, __FUNCTION__,
++ "inode %lu: bad block "E3FSBLK, inode->i_ino,
++ EXT3COW_I(inode)->i_file_acl);
++ error = -EIO;
++ goto cleanup;
++ }
++ ext3cow_xattr_cache_insert(bh);
++ error = ext3cow_xattr_list_entries(inode, BFIRST(bh), buffer, buffer_size);
++
++cleanup:
++ brelse(bh);
++
++ return error;
++}
++
++static int
++ext3cow_xattr_ibody_list(struct inode *inode, char *buffer, size_t buffer_size)
++{
++ struct ext3cow_xattr_ibody_header *header;
++ struct ext3cow_inode *raw_inode;
++ struct ext3cow_iloc iloc;
++ void *end;
++ int error;
++
++ if (!(EXT3COW_I(inode)->i_state & EXT3COW_STATE_XATTR))
++ return 0;
++ error = ext3cow_get_inode_loc(inode, &iloc);
++ if (error)
++ return error;
++ raw_inode = ext3cow_raw_inode(&iloc);
++ header = IHDR(inode, raw_inode);
++ end = (void *)raw_inode + EXT3COW_SB(inode->i_sb)->s_inode_size;
++ error = ext3cow_xattr_check_names(IFIRST(header), end);
++ if (error)
++ goto cleanup;
++ error = ext3cow_xattr_list_entries(inode, IFIRST(header),
++ buffer, buffer_size);
++
++cleanup:
++ brelse(iloc.bh);
++ return error;
++}
++
++/*
++ * ext3cow_xattr_list()
++ *
++ * Copy a list of attribute names into the buffer
++ * provided, or compute the buffer size required.
++ * Buffer is NULL to compute the size of the buffer required.
++ *
++ * Returns a negative error number on failure, or the number of bytes
++ * used / required on success.
++ */
++int
++ext3cow_xattr_list(struct inode *inode, char *buffer, size_t buffer_size)
++{
++ int i_error, b_error;
++
++ down_read(&EXT3COW_I(inode)->xattr_sem);
++ i_error = ext3cow_xattr_ibody_list(inode, buffer, buffer_size);
++ if (i_error < 0) {
++ b_error = 0;
++ } else {
++ if (buffer) {
++ buffer += i_error;
++ buffer_size -= i_error;
++ }
++ b_error = ext3cow_xattr_block_list(inode, buffer, buffer_size);
++ if (b_error < 0)
++ i_error = 0;
++ }
++ up_read(&EXT3COW_I(inode)->xattr_sem);
++ return i_error + b_error;
++}
++
++/*
++ * If the EXT3COW_FEATURE_COMPAT_EXT_ATTR feature of this file system is
++ * not set, set it.
++ */
++static void ext3cow_xattr_update_super_block(handle_t *handle,
++ struct super_block *sb)
++{
++ if (EXT3COW_HAS_COMPAT_FEATURE(sb, EXT3COW_FEATURE_COMPAT_EXT_ATTR))
++ return;
++
++ if (ext3cow_journal_get_write_access(handle, EXT3COW_SB(sb)->s_sbh) == 0) {
++ EXT3COW_SET_COMPAT_FEATURE(sb, EXT3COW_FEATURE_COMPAT_EXT_ATTR);
++ sb->s_dirt = 1;
++ ext3cow_journal_dirty_metadata(handle, EXT3COW_SB(sb)->s_sbh);
++ }
++}
++
++/*
++ * Release the xattr block BH: If the reference count is > 1, decrement
++ * it; otherwise free the block.
++ */
++static void
++ext3cow_xattr_release_block(handle_t *handle, struct inode *inode,
++ struct buffer_head *bh)
++{
++ struct mb_cache_entry *ce = NULL;
++
++ ce = mb_cache_entry_get(ext3cow_xattr_cache, bh->b_bdev, bh->b_blocknr);
++ if (BHDR(bh)->h_refcount == cpu_to_le32(1)) {
++ ea_bdebug(bh, "refcount now=0; freeing");
++ if (ce)
++ mb_cache_entry_free(ce);
++ ext3cow_free_blocks(handle, inode, bh->b_blocknr, 1);
++ get_bh(bh);
++ ext3cow_forget(handle, 1, inode, bh, bh->b_blocknr);
++ } else {
++ if (ext3cow_journal_get_write_access(handle, bh) == 0) {
++ lock_buffer(bh);
++ BHDR(bh)->h_refcount = cpu_to_le32(
++ le32_to_cpu(BHDR(bh)->h_refcount) - 1);
++ ext3cow_journal_dirty_metadata(handle, bh);
++ if (IS_SYNC(inode))
++ handle->h_sync = 1;
++ DQUOT_FREE_BLOCK(inode, 1);
++ unlock_buffer(bh);
++ ea_bdebug(bh, "refcount now=%d; releasing",
++ le32_to_cpu(BHDR(bh)->h_refcount));
++ }
++ if (ce)
++ mb_cache_entry_release(ce);
++ }
++}
++
++struct ext3cow_xattr_info {
++ int name_index;
++ const char *name;
++ const void *value;
++ size_t value_len;
++};
++
++struct ext3cow_xattr_search {
++ struct ext3cow_xattr_entry *first;
++ void *base;
++ void *end;
++ struct ext3cow_xattr_entry *here;
++ int not_found;
++};
++
++static int
++ext3cow_xattr_set_entry(struct ext3cow_xattr_info *i, struct ext3cow_xattr_search *s)
++{
++ struct ext3cow_xattr_entry *last;
++ size_t free, min_offs = s->end - s->base, name_len = strlen(i->name);
++
++ /* Compute min_offs and last. */
++ last = s->first;
++ for (; !IS_LAST_ENTRY(last); last = EXT3COW_XATTR_NEXT(last)) {
++ if (!last->e_value_block && last->e_value_size) {
++ size_t offs = le16_to_cpu(last->e_value_offs);
++ if (offs < min_offs)
++ min_offs = offs;
++ }
++ }
++ free = min_offs - ((void *)last - s->base) - sizeof(__u32);
++ if (!s->not_found) {
++ if (!s->here->e_value_block && s->here->e_value_size) {
++ size_t size = le32_to_cpu(s->here->e_value_size);
++ free += EXT3COW_XATTR_SIZE(size);
++ }
++ free += EXT3COW_XATTR_LEN(name_len);
++ }
++ if (i->value) {
++ if (free < EXT3COW_XATTR_SIZE(i->value_len) ||
++ free < EXT3COW_XATTR_LEN(name_len) +
++ EXT3COW_XATTR_SIZE(i->value_len))
++ return -ENOSPC;
++ }
++
++ if (i->value && s->not_found) {
++ /* Insert the new name. */
++ size_t size = EXT3COW_XATTR_LEN(name_len);
++ size_t rest = (void *)last - (void *)s->here + sizeof(__u32);
++ memmove((void *)s->here + size, s->here, rest);
++ memset(s->here, 0, size);
++ s->here->e_name_index = i->name_index;
++ s->here->e_name_len = name_len;
++ memcpy(s->here->e_name, i->name, name_len);
++ } else {
++ if (!s->here->e_value_block && s->here->e_value_size) {
++ void *first_val = s->base + min_offs;
++ size_t offs = le16_to_cpu(s->here->e_value_offs);
++ void *val = s->base + offs;
++ size_t size = EXT3COW_XATTR_SIZE(
++ le32_to_cpu(s->here->e_value_size));
++
++ if (i->value && size == EXT3COW_XATTR_SIZE(i->value_len)) {
++ /* The old and the new value have the same
++ size. Just replace. */
++ s->here->e_value_size =
++ cpu_to_le32(i->value_len);
++ memset(val + size - EXT3COW_XATTR_PAD, 0,
++ EXT3COW_XATTR_PAD); /* Clear pad bytes. */
++ memcpy(val, i->value, i->value_len);
++ return 0;
++ }
++
++ /* Remove the old value. */
++ memmove(first_val + size, first_val, val - first_val);
++ memset(first_val, 0, size);
++ s->here->e_value_size = 0;
++ s->here->e_value_offs = 0;
++ min_offs += size;
++
++ /* Adjust all value offsets. */
++ last = s->first;
++ while (!IS_LAST_ENTRY(last)) {
++ size_t o = le16_to_cpu(last->e_value_offs);
++ if (!last->e_value_block &&
++ last->e_value_size && o < offs)
++ last->e_value_offs =
++ cpu_to_le16(o + size);
++ last = EXT3COW_XATTR_NEXT(last);
++ }
++ }
++ if (!i->value) {
++ /* Remove the old name. */
++ size_t size = EXT3COW_XATTR_LEN(name_len);
++ last = ENTRY((void *)last - size);
++ memmove(s->here, (void *)s->here + size,
++ (void *)last - (void *)s->here + sizeof(__u32));
++ memset(last, 0, size);
++ }
++ }
++
++ if (i->value) {
++ /* Insert the new value. */
++ s->here->e_value_size = cpu_to_le32(i->value_len);
++ if (i->value_len) {
++ size_t size = EXT3COW_XATTR_SIZE(i->value_len);
++ void *val = s->base + min_offs - size;
++ s->here->e_value_offs = cpu_to_le16(min_offs - size);
++ memset(val + size - EXT3COW_XATTR_PAD, 0,
++ EXT3COW_XATTR_PAD); /* Clear the pad bytes. */
++ memcpy(val, i->value, i->value_len);
++ }
++ }
++ return 0;
++}
++
++struct ext3cow_xattr_block_find {
++ struct ext3cow_xattr_search s;
++ struct buffer_head *bh;
++};
++
++static int
++ext3cow_xattr_block_find(struct inode *inode, struct ext3cow_xattr_info *i,
++ struct ext3cow_xattr_block_find *bs)
++{
++ struct super_block *sb = inode->i_sb;
++ int error;
++
++ ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
++ i->name_index, i->name, i->value, (long)i->value_len);
++
++ if (EXT3COW_I(inode)->i_file_acl) {
++ /* The inode already has an extended attribute block. */
++ bs->bh = sb_bread(sb, EXT3COW_I(inode)->i_file_acl);
++ error = -EIO;
++ if (!bs->bh)
++ goto cleanup;
++ ea_bdebug(bs->bh, "b_count=%d, refcount=%d",
++ atomic_read(&(bs->bh->b_count)),
++ le32_to_cpu(BHDR(bs->bh)->h_refcount));
++ if (ext3cow_xattr_check_block(bs->bh)) {
++ ext3cow_error(sb, __FUNCTION__,
++ "inode %lu: bad block "E3FSBLK, inode->i_ino,
++ EXT3COW_I(inode)->i_file_acl);
++ error = -EIO;
++ goto cleanup;
++ }
++ /* Find the named attribute. */
++ bs->s.base = BHDR(bs->bh);
++ bs->s.first = BFIRST(bs->bh);
++ bs->s.end = bs->bh->b_data + bs->bh->b_size;
++ bs->s.here = bs->s.first;
++ error = ext3cow_xattr_find_entry(&bs->s.here, i->name_index,
++ i->name, bs->bh->b_size, 1);
++ if (error && error != -ENODATA)
++ goto cleanup;
++ bs->s.not_found = error;
++ }
++ error = 0;
++
++cleanup:
++ return error;
++}
++
++static int
++ext3cow_xattr_block_set(handle_t *handle, struct inode *inode,
++ struct ext3cow_xattr_info *i,
++ struct ext3cow_xattr_block_find *bs)
++{
++ struct super_block *sb = inode->i_sb;
++ struct buffer_head *new_bh = NULL;
++ struct ext3cow_xattr_search *s = &bs->s;
++ struct mb_cache_entry *ce = NULL;
++ int error;
++
++#define header(x) ((struct ext3cow_xattr_header *)(x))
++
++ if (i->value && i->value_len > sb->s_blocksize)
++ return -ENOSPC;
++ if (s->base) {
++ ce = mb_cache_entry_get(ext3cow_xattr_cache, bs->bh->b_bdev,
++ bs->bh->b_blocknr);
++ if (header(s->base)->h_refcount == cpu_to_le32(1)) {
++ if (ce) {
++ mb_cache_entry_free(ce);
++ ce = NULL;
++ }
++ ea_bdebug(bs->bh, "modifying in-place");
++ error = ext3cow_journal_get_write_access(handle, bs->bh);
++ if (error)
++ goto cleanup;
++ lock_buffer(bs->bh);
++ error = ext3cow_xattr_set_entry(i, s);
++ if (!error) {
++ if (!IS_LAST_ENTRY(s->first))
++ ext3cow_xattr_rehash(header(s->base),
++ s->here);
++ ext3cow_xattr_cache_insert(bs->bh);
++ }
++ unlock_buffer(bs->bh);
++ if (error == -EIO)
++ goto bad_block;
++ if (!error)
++ error = ext3cow_journal_dirty_metadata(handle,
++ bs->bh);
++ if (error)
++ goto cleanup;
++ goto inserted;
++ } else {
++ int offset = (char *)s->here - bs->bh->b_data;
++
++ if (ce) {
++ mb_cache_entry_release(ce);
++ ce = NULL;
++ }
++ ea_bdebug(bs->bh, "cloning");
++ s->base = kmalloc(bs->bh->b_size, GFP_KERNEL);
++ error = -ENOMEM;
++ if (s->base == NULL)
++ goto cleanup;
++ memcpy(s->base, BHDR(bs->bh), bs->bh->b_size);
++ s->first = ENTRY(header(s->base)+1);
++ header(s->base)->h_refcount = cpu_to_le32(1);
++ s->here = ENTRY(s->base + offset);
++ s->end = s->base + bs->bh->b_size;
++ }
++ } else {
++ /* Allocate a buffer where we construct the new block. */
++ s->base = kmalloc(sb->s_blocksize, GFP_KERNEL);
++ /* assert(header == s->base) */
++ error = -ENOMEM;
++ if (s->base == NULL)
++ goto cleanup;
++ memset(s->base, 0, sb->s_blocksize);
++ header(s->base)->h_magic = cpu_to_le32(EXT3COW_XATTR_MAGIC);
++ header(s->base)->h_blocks = cpu_to_le32(1);
++ header(s->base)->h_refcount = cpu_to_le32(1);
++ s->first = ENTRY(header(s->base)+1);
++ s->here = ENTRY(header(s->base)+1);
++ s->end = s->base + sb->s_blocksize;
++ }
++
++ error = ext3cow_xattr_set_entry(i, s);
++ if (error == -EIO)
++ goto bad_block;
++ if (error)
++ goto cleanup;
++ if (!IS_LAST_ENTRY(s->first))
++ ext3cow_xattr_rehash(header(s->base), s->here);
++
++inserted:
++ if (!IS_LAST_ENTRY(s->first)) {
++ new_bh = ext3cow_xattr_cache_find(inode, header(s->base), &ce);
++ if (new_bh) {
++ /* We found an identical block in the cache. */
++ if (new_bh == bs->bh)
++ ea_bdebug(new_bh, "keeping");
++ else {
++ /* The old block is released after updating
++ the inode. */
++ error = -EDQUOT;
++ if (DQUOT_ALLOC_BLOCK(inode, 1))
++ goto cleanup;
++ error = ext3cow_journal_get_write_access(handle,
++ new_bh);
++ if (error)
++ goto cleanup_dquot;
++ lock_buffer(new_bh);
++ BHDR(new_bh)->h_refcount = cpu_to_le32(1 +
++ le32_to_cpu(BHDR(new_bh)->h_refcount));
++ ea_bdebug(new_bh, "reusing; refcount now=%d",
++ le32_to_cpu(BHDR(new_bh)->h_refcount));
++ unlock_buffer(new_bh);
++ error = ext3cow_journal_dirty_metadata(handle,
++ new_bh);
++ if (error)
++ goto cleanup_dquot;
++ }
++ mb_cache_entry_release(ce);
++ ce = NULL;
++ } else if (bs->bh && s->base == bs->bh->b_data) {
++ /* We were modifying this block in-place. */
++ ea_bdebug(bs->bh, "keeping this block");
++ new_bh = bs->bh;
++ get_bh(new_bh);
++ } else {
++ /* We need to allocate a new block */
++ ext3cow_fsblk_t goal = le32_to_cpu(
++ EXT3COW_SB(sb)->s_es->s_first_data_block) +
++ (ext3cow_fsblk_t)EXT3COW_I(inode)->i_block_group *
++ EXT3COW_BLOCKS_PER_GROUP(sb);
++ ext3cow_fsblk_t block = ext3cow_new_block(handle, inode,
++ goal, &error);
++ if (error)
++ goto cleanup;
++ ea_idebug(inode, "creating block %d", block);
++
++ new_bh = sb_getblk(sb, block);
++ if (!new_bh) {
++getblk_failed:
++ ext3cow_free_blocks(handle, inode, block, 1);
++ error = -EIO;
++ goto cleanup;
++ }
++ lock_buffer(new_bh);
++ error = ext3cow_journal_get_create_access(handle, new_bh);
++ if (error) {
++ unlock_buffer(new_bh);
++ goto getblk_failed;
++ }
++ memcpy(new_bh->b_data, s->base, new_bh->b_size);
++ set_buffer_uptodate(new_bh);
++ unlock_buffer(new_bh);
++ ext3cow_xattr_cache_insert(new_bh);
++ error = ext3cow_journal_dirty_metadata(handle, new_bh);
++ if (error)
++ goto cleanup;
++ }
++ }
++
++ /* Update the inode. */
++ EXT3COW_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
++
++ /* Drop the previous xattr block. */
++ if (bs->bh && bs->bh != new_bh)
++ ext3cow_xattr_release_block(handle, inode, bs->bh);
++ error = 0;
++
++cleanup:
++ if (ce)
++ mb_cache_entry_release(ce);
++ brelse(new_bh);
++ if (!(bs->bh && s->base == bs->bh->b_data))
++ kfree(s->base);
++
++ return error;
++
++cleanup_dquot:
++ DQUOT_FREE_BLOCK(inode, 1);
++ goto cleanup;
++
++bad_block:
++ ext3cow_error(inode->i_sb, __FUNCTION__,
++ "inode %lu: bad block "E3FSBLK, inode->i_ino,
++ EXT3COW_I(inode)->i_file_acl);
++ goto cleanup;
++
++#undef header
++}
++
++struct ext3cow_xattr_ibody_find {
++ struct ext3cow_xattr_search s;
++ struct ext3cow_iloc iloc;
++};
++
++static int
++ext3cow_xattr_ibody_find(struct inode *inode, struct ext3cow_xattr_info *i,
++ struct ext3cow_xattr_ibody_find *is)
++{
++ struct ext3cow_xattr_ibody_header *header;
++ struct ext3cow_inode *raw_inode;
++ int error;
++
++ if (EXT3COW_I(inode)->i_extra_isize == 0)
++ return 0;
++ raw_inode = ext3cow_raw_inode(&is->iloc);
++ header = IHDR(inode, raw_inode);
++ is->s.base = is->s.first = IFIRST(header);
++ is->s.here = is->s.first;
++ is->s.end = (void *)raw_inode + EXT3COW_SB(inode->i_sb)->s_inode_size;
++ if (EXT3COW_I(inode)->i_state & EXT3COW_STATE_XATTR) {
++ error = ext3cow_xattr_check_names(IFIRST(header), is->s.end);
++ if (error)
++ return error;
++ /* Find the named attribute. */
++ error = ext3cow_xattr_find_entry(&is->s.here, i->name_index,
++ i->name, is->s.end -
++ (void *)is->s.base, 0);
++ if (error && error != -ENODATA)
++ return error;
++ is->s.not_found = error;
++ }
++ return 0;
++}
++
++static int
++ext3cow_xattr_ibody_set(handle_t *handle, struct inode *inode,
++ struct ext3cow_xattr_info *i,
++ struct ext3cow_xattr_ibody_find *is)
++{
++ struct ext3cow_xattr_ibody_header *header;
++ struct ext3cow_xattr_search *s = &is->s;
++ int error;
++
++ if (EXT3COW_I(inode)->i_extra_isize == 0)
++ return -ENOSPC;
++ error = ext3cow_xattr_set_entry(i, s);
++ if (error)
++ return error;
++ header = IHDR(inode, ext3cow_raw_inode(&is->iloc));
++ if (!IS_LAST_ENTRY(s->first)) {
++ header->h_magic = cpu_to_le32(EXT3COW_XATTR_MAGIC);
++ EXT3COW_I(inode)->i_state |= EXT3COW_STATE_XATTR;
++ } else {
++ header->h_magic = cpu_to_le32(0);
++ EXT3COW_I(inode)->i_state &= ~EXT3COW_STATE_XATTR;
++ }
++ return 0;
++}
++
++/*
++ * ext3cow_xattr_set_handle()
++ *
++ * Create, replace or remove an extended attribute for this inode. Buffer
++ * is NULL to remove an existing extended attribute, and non-NULL to
++ * either replace an existing extended attribute, or create a new extended
++ * attribute. The flags XATTR_REPLACE and XATTR_CREATE
++ * specify that an extended attribute must exist and must not exist
++ * previous to the call, respectively.
++ *
++ * Returns 0, or a negative error number on failure.
++ */
++int
++ext3cow_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
++ const char *name, const void *value, size_t value_len,
++ int flags)
++{
++ struct ext3cow_xattr_info i = {
++ .name_index = name_index,
++ .name = name,
++ .value = value,
++ .value_len = value_len,
++
++ };
++ struct ext3cow_xattr_ibody_find is = {
++ .s = { .not_found = -ENODATA, },
++ };
++ struct ext3cow_xattr_block_find bs = {
++ .s = { .not_found = -ENODATA, },
++ };
++ int error;
++
++ if (!name)
++ return -EINVAL;
++ if (strlen(name) > 255)
++ return -ERANGE;
++ down_write(&EXT3COW_I(inode)->xattr_sem);
++ error = ext3cow_get_inode_loc(inode, &is.iloc);
++ if (error)
++ goto cleanup;
++
++ if (EXT3COW_I(inode)->i_state & EXT3COW_STATE_NEW) {
++ struct ext3cow_inode *raw_inode = ext3cow_raw_inode(&is.iloc);
++ memset(raw_inode, 0, EXT3COW_SB(inode->i_sb)->s_inode_size);
++ EXT3COW_I(inode)->i_state &= ~EXT3COW_STATE_NEW;
++ }
++
++ error = ext3cow_xattr_ibody_find(inode, &i, &is);
++ if (error)
++ goto cleanup;
++ if (is.s.not_found)
++ error = ext3cow_xattr_block_find(inode, &i, &bs);
++ if (error)
++ goto cleanup;
++ if (is.s.not_found && bs.s.not_found) {
++ error = -ENODATA;
++ if (flags & XATTR_REPLACE)
++ goto cleanup;
++ error = 0;
++ if (!value)
++ goto cleanup;
++ } else {
++ error = -EEXIST;
++ if (flags & XATTR_CREATE)
++ goto cleanup;
++ }
++ error = ext3cow_journal_get_write_access(handle, is.iloc.bh);
++ if (error)
++ goto cleanup;
++ if (!value) {
++ if (!is.s.not_found)
++ error = ext3cow_xattr_ibody_set(handle, inode, &i, &is);
++ else if (!bs.s.not_found)
++ error = ext3cow_xattr_block_set(handle, inode, &i, &bs);
++ } else {
++ error = ext3cow_xattr_ibody_set(handle, inode, &i, &is);
++ if (!error && !bs.s.not_found) {
++ i.value = NULL;
++ error = ext3cow_xattr_block_set(handle, inode, &i, &bs);
++ } else if (error == -ENOSPC) {
++ error = ext3cow_xattr_block_set(handle, inode, &i, &bs);
++ if (error)
++ goto cleanup;
++ if (!is.s.not_found) {
++ i.value = NULL;
++ error = ext3cow_xattr_ibody_set(handle, inode, &i,
++ &is);
++ }
++ }
++ }
++ if (!error) {
++ ext3cow_xattr_update_super_block(handle, inode->i_sb);
++ inode->i_ctime = CURRENT_TIME_SEC;
++ error = ext3cow_mark_iloc_dirty(handle, inode, &is.iloc);
++ /*
++ * The bh is consumed by ext3cow_mark_iloc_dirty, even with
++ * error != 0.
++ */
++ is.iloc.bh = NULL;
++ if (IS_SYNC(inode))
++ handle->h_sync = 1;
++ }
++
++cleanup:
++ brelse(is.iloc.bh);
++ brelse(bs.bh);
++ up_write(&EXT3COW_I(inode)->xattr_sem);
++ return error;
++}
++
++/*
++ * ext3cow_xattr_set()
++ *
++ * Like ext3cow_xattr_set_handle, but start from an inode. This extended
++ * attribute modification is a filesystem transaction by itself.
++ *
++ * Returns 0, or a negative error number on failure.
++ */
++int
++ext3cow_xattr_set(struct inode *inode, int name_index, const char *name,
++ const void *value, size_t value_len, int flags)
++{
++ handle_t *handle;
++ int error, retries = 0;
++
++retry:
++ handle = ext3cow_journal_start(inode, EXT3COW_DATA_TRANS_BLOCKS(inode->i_sb));
++ if (IS_ERR(handle)) {
++ error = PTR_ERR(handle);
++ } else {
++ int error2;
++
++ error = ext3cow_xattr_set_handle(handle, inode, name_index, name,
++ value, value_len, flags);
++ error2 = ext3cow_journal_stop(handle);
++ if (error == -ENOSPC &&
++ ext3cow_should_retry_alloc(inode->i_sb, &retries))
++ goto retry;
++ if (error == 0)
++ error = error2;
++ }
++
++ return error;
++}
++
++/*
++ * ext3cow_xattr_delete_inode()
++ *
++ * Free extended attribute resources associated with this inode. This
++ * is called immediately before an inode is freed. We have exclusive
++ * access to the inode.
++ */
++void
++ext3cow_xattr_delete_inode(handle_t *handle, struct inode *inode)
++{
++ struct buffer_head *bh = NULL;
++
++ if (!EXT3COW_I(inode)->i_file_acl)
++ goto cleanup;
++ bh = sb_bread(inode->i_sb, EXT3COW_I(inode)->i_file_acl);
++ if (!bh) {
++ ext3cow_error(inode->i_sb, __FUNCTION__,
++ "inode %lu: block "E3FSBLK" read error", inode->i_ino,
++ EXT3COW_I(inode)->i_file_acl);
++ goto cleanup;
++ }
++ if (BHDR(bh)->h_magic != cpu_to_le32(EXT3COW_XATTR_MAGIC) ||
++ BHDR(bh)->h_blocks != cpu_to_le32(1)) {
++ ext3cow_error(inode->i_sb, __FUNCTION__,
++ "inode %lu: bad block "E3FSBLK, inode->i_ino,
++ EXT3COW_I(inode)->i_file_acl);
++ goto cleanup;
++ }
++ ext3cow_xattr_release_block(handle, inode, bh);
++ EXT3COW_I(inode)->i_file_acl = 0;
++
++cleanup:
++ brelse(bh);
++}
++
++/*
++ * ext3cow_xattr_put_super()
++ *
++ * This is called when a file system is unmounted.
++ */
++void
++ext3cow_xattr_put_super(struct super_block *sb)
++{
++ mb_cache_shrink(sb->s_bdev);
++}
++
++/*
++ * ext3cow_xattr_cache_insert()
++ *
++ * Create a new entry in the extended attribute cache, and insert
++ * it unless such an entry is already in the cache.
++ *
++ * Returns 0, or a negative error number on failure.
++ */
++static void
++ext3cow_xattr_cache_insert(struct buffer_head *bh)
++{
++ __u32 hash = le32_to_cpu(BHDR(bh)->h_hash);
++ struct mb_cache_entry *ce;
++ int error;
++
++ ce = mb_cache_entry_alloc(ext3cow_xattr_cache);
++ if (!ce) {
++ ea_bdebug(bh, "out of memory");
++ return;
++ }
++ error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, &hash);
++ if (error) {
++ mb_cache_entry_free(ce);
++ if (error == -EBUSY) {
++ ea_bdebug(bh, "already in cache");
++ error = 0;
++ }
++ } else {
++ ea_bdebug(bh, "inserting [%x]", (int)hash);
++ mb_cache_entry_release(ce);
++ }
++}
++
++/*
++ * ext3cow_xattr_cmp()
++ *
++ * Compare two extended attribute blocks for equality.
++ *
++ * Returns 0 if the blocks are equal, 1 if they differ, and
++ * a negative error number on errors.
++ */
++static int
++ext3cow_xattr_cmp(struct ext3cow_xattr_header *header1,
++ struct ext3cow_xattr_header *header2)
++{
++ struct ext3cow_xattr_entry *entry1, *entry2;
++
++ entry1 = ENTRY(header1+1);
++ entry2 = ENTRY(header2+1);
++ while (!IS_LAST_ENTRY(entry1)) {
++ if (IS_LAST_ENTRY(entry2))
++ return 1;
++ if (entry1->e_hash != entry2->e_hash ||
++ entry1->e_name_index != entry2->e_name_index ||
++ entry1->e_name_len != entry2->e_name_len ||
++ entry1->e_value_size != entry2->e_value_size ||
++ memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
++ return 1;
++ if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
++ return -EIO;
++ if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
++ (char *)header2 + le16_to_cpu(entry2->e_value_offs),
++ le32_to_cpu(entry1->e_value_size)))
++ return 1;
++
++ entry1 = EXT3COW_XATTR_NEXT(entry1);
++ entry2 = EXT3COW_XATTR_NEXT(entry2);
++ }
++ if (!IS_LAST_ENTRY(entry2))
++ return 1;
++ return 0;
++}
++
++/*
++ * ext3cow_xattr_cache_find()
++ *
++ * Find an identical extended attribute block.
++ *
++ * Returns a pointer to the block found, or NULL if such a block was
++ * not found or an error occurred.
++ */
++static struct buffer_head *
++ext3cow_xattr_cache_find(struct inode *inode, struct ext3cow_xattr_header *header,
++ struct mb_cache_entry **pce)
++{
++ __u32 hash = le32_to_cpu(header->h_hash);
++ struct mb_cache_entry *ce;
++
++ if (!header->h_hash)
++ return NULL; /* never share */
++ ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
++again:
++ ce = mb_cache_entry_find_first(ext3cow_xattr_cache, 0,
++ inode->i_sb->s_bdev, hash);
++ while (ce) {
++ struct buffer_head *bh;
++
++ if (IS_ERR(ce)) {
++ if (PTR_ERR(ce) == -EAGAIN)
++ goto again;
++ break;
++ }
++ bh = sb_bread(inode->i_sb, ce->e_block);
++ if (!bh) {
++ ext3cow_error(inode->i_sb, __FUNCTION__,
++ "inode %lu: block %lu read error",
++ inode->i_ino, (unsigned long) ce->e_block);
++ } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=
++ EXT3COW_XATTR_REFCOUNT_MAX) {
++ ea_idebug(inode, "block %lu refcount %d>=%d",
++ (unsigned long) ce->e_block,
++ le32_to_cpu(BHDR(bh)->h_refcount),
++ EXT3COW_XATTR_REFCOUNT_MAX);
++ } else if (ext3cow_xattr_cmp(header, BHDR(bh)) == 0) {
++ *pce = ce;
++ return bh;
++ }
++ brelse(bh);
++ ce = mb_cache_entry_find_next(ce, 0, inode->i_sb->s_bdev, hash);
++ }
++ return NULL;
++}
++
++#define NAME_HASH_SHIFT 5
++#define VALUE_HASH_SHIFT 16
++
++/*
++ * ext3cow_xattr_hash_entry()
++ *
++ * Compute the hash of an extended attribute.
++ */
++static inline void ext3cow_xattr_hash_entry(struct ext3cow_xattr_header *header,
++ struct ext3cow_xattr_entry *entry)
++{
++ __u32 hash = 0;
++ char *name = entry->e_name;
++ int n;
++
++ for (n=0; n < entry->e_name_len; n++) {
++ hash = (hash << NAME_HASH_SHIFT) ^
++ (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
++ *name++;
++ }
++
++ if (entry->e_value_block == 0 && entry->e_value_size != 0) {
++ __le32 *value = (__le32 *)((char *)header +
++ le16_to_cpu(entry->e_value_offs));
++ for (n = (le32_to_cpu(entry->e_value_size) +
++ EXT3COW_XATTR_ROUND) >> EXT3COW_XATTR_PAD_BITS; n; n--) {
++ hash = (hash << VALUE_HASH_SHIFT) ^
++ (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
++ le32_to_cpu(*value++);
++ }
++ }
++ entry->e_hash = cpu_to_le32(hash);
++}
++
++#undef NAME_HASH_SHIFT
++#undef VALUE_HASH_SHIFT
++
++#define BLOCK_HASH_SHIFT 16
++
++/*
++ * ext3cow_xattr_rehash()
++ *
++ * Re-compute the extended attribute hash value after an entry has changed.
++ */
++static void ext3cow_xattr_rehash(struct ext3cow_xattr_header *header,
++ struct ext3cow_xattr_entry *entry)
++{
++ struct ext3cow_xattr_entry *here;
++ __u32 hash = 0;
++
++ ext3cow_xattr_hash_entry(header, entry);
++ here = ENTRY(header+1);
++ while (!IS_LAST_ENTRY(here)) {
++ if (!here->e_hash) {
++ /* Block is not shared if an entry's hash value == 0 */
++ hash = 0;
++ break;
++ }
++ hash = (hash << BLOCK_HASH_SHIFT) ^
++ (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
++ le32_to_cpu(here->e_hash);
++ here = EXT3COW_XATTR_NEXT(here);
++ }
++ header->h_hash = cpu_to_le32(hash);
++}
++
++#undef BLOCK_HASH_SHIFT
++
++int __init
++init_ext3cow_xattr(void)
++{
++ ext3cow_xattr_cache = mb_cache_create("ext3cow_xattr", NULL,
++ sizeof(struct mb_cache_entry) +
++ sizeof(((struct mb_cache_entry *) 0)->e_indexes[0]), 1, 6);
++ if (!ext3cow_xattr_cache)
++ return -ENOMEM;
++ return 0;
++}
++
++void
++exit_ext3cow_xattr(void)
++{
++ if (ext3cow_xattr_cache)
++ mb_cache_destroy(ext3cow_xattr_cache);
++ ext3cow_xattr_cache = NULL;
++}
+diff -ruN linux-2.6.20.3/fs/ext3cow/xattr.h linux-2.6.20.3-ext3cow/fs/ext3cow/xattr.h
+--- linux-2.6.20.3/fs/ext3cow/xattr.h 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/xattr.h 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,145 @@
++/*
++ File: fs/ext3cow/xattr.h
++
++ On-disk format of extended attributes for the ext3cow filesystem.
++
++ (C) 2001 Andreas Gruenbacher,
++*/
++
++#include
++
++/* Magic value in attribute blocks */
++#define EXT3COW_XATTR_MAGIC 0xEA020000
++
++/* Maximum number of references to one attribute block */
++#define EXT3COW_XATTR_REFCOUNT_MAX 1024
++
++/* Name indexes */
++#define EXT3COW_XATTR_INDEX_USER 1
++#define EXT3COW_XATTR_INDEX_POSIX_ACL_ACCESS 2
++#define EXT3COW_XATTR_INDEX_POSIX_ACL_DEFAULT 3
++#define EXT3COW_XATTR_INDEX_TRUSTED 4
++#define EXT3COW_XATTR_INDEX_LUSTRE 5
++#define EXT3COW_XATTR_INDEX_SECURITY 6
++
++struct ext3cow_xattr_header {
++ __le32 h_magic; /* magic number for identification */
++ __le32 h_refcount; /* reference count */
++ __le32 h_blocks; /* number of disk blocks used */
++ __le32 h_hash; /* hash value of all attributes */
++ __u32 h_reserved[4]; /* zero right now */
++};
++
++struct ext3cow_xattr_ibody_header {
++ __le32 h_magic; /* magic number for identification */
++};
++
++struct ext3cow_xattr_entry {
++ __u8 e_name_len; /* length of name */
++ __u8 e_name_index; /* attribute name index */
++ __le16 e_value_offs; /* offset in disk block of value */
++ __le32 e_value_block; /* disk block attribute is stored on (n/i) */
++ __le32 e_value_size; /* size of attribute value */
++ __le32 e_hash; /* hash value of name and value */
++ char e_name[0]; /* attribute name */
++};
++
++#define EXT3COW_XATTR_PAD_BITS 2
++#define EXT3COW_XATTR_PAD (1<e_name_len)) )
++#define EXT3COW_XATTR_SIZE(size) \
++ (((size) + EXT3COW_XATTR_ROUND) & ~EXT3COW_XATTR_ROUND)
++
++# ifdef CONFIG_EXT3COW_FS_XATTR
++
++extern struct xattr_handler ext3cow_xattr_user_handler;
++extern struct xattr_handler ext3cow_xattr_trusted_handler;
++extern struct xattr_handler ext3cow_xattr_acl_access_handler;
++extern struct xattr_handler ext3cow_xattr_acl_default_handler;
++extern struct xattr_handler ext3cow_xattr_security_handler;
++
++extern ssize_t ext3cow_listxattr(struct dentry *, char *, size_t);
++
++extern int ext3cow_xattr_get(struct inode *, int, const char *, void *, size_t);
++extern int ext3cow_xattr_list(struct inode *, char *, size_t);
++extern int ext3cow_xattr_set(struct inode *, int, const char *, const void *, size_t, int);
++extern int ext3cow_xattr_set_handle(handle_t *, struct inode *, int, const char *, const void *, size_t, int);
++
++extern void ext3cow_xattr_delete_inode(handle_t *, struct inode *);
++extern void ext3cow_xattr_put_super(struct super_block *);
++
++extern int init_ext3cow_xattr(void);
++extern void exit_ext3cow_xattr(void);
++
++extern struct xattr_handler *ext3cow_xattr_handlers[];
++
++# else /* CONFIG_EXT3COW_FS_XATTR */
++
++static inline int
++ext3cow_xattr_get(struct inode *inode, int name_index, const char *name,
++ void *buffer, size_t size, int flags)
++{
++ return -EOPNOTSUPP;
++}
++
++static inline int
++ext3cow_xattr_list(struct inode *inode, void *buffer, size_t size)
++{
++ return -EOPNOTSUPP;
++}
++
++static inline int
++ext3cow_xattr_set(struct inode *inode, int name_index, const char *name,
++ const void *value, size_t size, int flags)
++{
++ return -EOPNOTSUPP;
++}
++
++static inline int
++ext3cow_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
++ const char *name, const void *value, size_t size, int flags)
++{
++ return -EOPNOTSUPP;
++}
++
++static inline void
++ext3cow_xattr_delete_inode(handle_t *handle, struct inode *inode)
++{
++}
++
++static inline void
++ext3cow_xattr_put_super(struct super_block *sb)
++{
++}
++
++static inline int
++init_ext3cow_xattr(void)
++{
++ return 0;
++}
++
++static inline void
++exit_ext3cow_xattr(void)
++{
++}
++
++#define ext3cow_xattr_handlers NULL
++
++# endif /* CONFIG_EXT3COW_FS_XATTR */
++
++#ifdef CONFIG_EXT3COW_FS_SECURITY
++extern int ext3cow_init_security(handle_t *handle, struct inode *inode,
++ struct inode *dir);
++#else
++static inline int ext3cow_init_security(handle_t *handle, struct inode *inode,
++ struct inode *dir)
++{
++ return 0;
++}
++#endif
+diff -ruN linux-2.6.20.3/fs/ext3cow/xattr_security.c linux-2.6.20.3-ext3cow/fs/ext3cow/xattr_security.c
+--- linux-2.6.20.3/fs/ext3cow/xattr_security.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/xattr_security.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,77 @@
++/*
++ * linux/fs/ext3cow/xattr_security.c
++ * Handler for storing security labels as extended attributes.
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include "xattr.h"
++
++static size_t
++ext3cow_xattr_security_list(struct inode *inode, char *list, size_t list_size,
++ const char *name, size_t name_len)
++{
++ const size_t prefix_len = sizeof(XATTR_SECURITY_PREFIX)-1;
++ const size_t total_len = prefix_len + name_len + 1;
++
++
++ if (list && total_len <= list_size) {
++ memcpy(list, XATTR_SECURITY_PREFIX, prefix_len);
++ memcpy(list+prefix_len, name, name_len);
++ list[prefix_len + name_len] = '\0';
++ }
++ return total_len;
++}
++
++static int
++ext3cow_xattr_security_get(struct inode *inode, const char *name,
++ void *buffer, size_t size)
++{
++ if (strcmp(name, "") == 0)
++ return -EINVAL;
++ return ext3cow_xattr_get(inode, EXT3COW_XATTR_INDEX_SECURITY, name,
++ buffer, size);
++}
++
++static int
++ext3cow_xattr_security_set(struct inode *inode, const char *name,
++ const void *value, size_t size, int flags)
++{
++ if (strcmp(name, "") == 0)
++ return -EINVAL;
++ return ext3cow_xattr_set(inode, EXT3COW_XATTR_INDEX_SECURITY, name,
++ value, size, flags);
++}
++
++int
++ext3cow_init_security(handle_t *handle, struct inode *inode, struct inode *dir)
++{
++ int err;
++ size_t len;
++ void *value;
++ char *name;
++
++ err = security_inode_init_security(inode, dir, &name, &value, &len);
++ if (err) {
++ if (err == -EOPNOTSUPP)
++ return 0;
++ return err;
++ }
++ err = ext3cow_xattr_set_handle(handle, inode, EXT3COW_XATTR_INDEX_SECURITY,
++ name, value, len, 0);
++ kfree(name);
++ kfree(value);
++ return err;
++}
++
++struct xattr_handler ext3cow_xattr_security_handler = {
++ .prefix = XATTR_SECURITY_PREFIX,
++ .list = ext3cow_xattr_security_list,
++ .get = ext3cow_xattr_security_get,
++ .set = ext3cow_xattr_security_set,
++};
+diff -ruN linux-2.6.20.3/fs/ext3cow/xattr_trusted.c linux-2.6.20.3-ext3cow/fs/ext3cow/xattr_trusted.c
+--- linux-2.6.20.3/fs/ext3cow/xattr_trusted.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/xattr_trusted.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,62 @@
++/*
++ * linux/fs/ext3cow/xattr_trusted.c
++ * Handler for trusted extended attributes.
++ *
++ * Copyright (C) 2003 by Andreas Gruenbacher,
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include
++#include "xattr.h"
++
++#define XATTR_TRUSTED_PREFIX "trusted."
++
++static size_t
++ext3cow_xattr_trusted_list(struct inode *inode, char *list, size_t list_size,
++ const char *name, size_t name_len)
++{
++ const size_t prefix_len = sizeof(XATTR_TRUSTED_PREFIX)-1;
++ const size_t total_len = prefix_len + name_len + 1;
++
++ if (!capable(CAP_SYS_ADMIN))
++ return 0;
++
++ if (list && total_len <= list_size) {
++ memcpy(list, XATTR_TRUSTED_PREFIX, prefix_len);
++ memcpy(list+prefix_len, name, name_len);
++ list[prefix_len + name_len] = '\0';
++ }
++ return total_len;
++}
++
++static int
++ext3cow_xattr_trusted_get(struct inode *inode, const char *name,
++ void *buffer, size_t size)
++{
++ if (strcmp(name, "") == 0)
++ return -EINVAL;
++ return ext3cow_xattr_get(inode, EXT3COW_XATTR_INDEX_TRUSTED, name,
++ buffer, size);
++}
++
++static int
++ext3cow_xattr_trusted_set(struct inode *inode, const char *name,
++ const void *value, size_t size, int flags)
++{
++ if (strcmp(name, "") == 0)
++ return -EINVAL;
++ return ext3cow_xattr_set(inode, EXT3COW_XATTR_INDEX_TRUSTED, name,
++ value, size, flags);
++}
++
++struct xattr_handler ext3cow_xattr_trusted_handler = {
++ .prefix = XATTR_TRUSTED_PREFIX,
++ .list = ext3cow_xattr_trusted_list,
++ .get = ext3cow_xattr_trusted_get,
++ .set = ext3cow_xattr_trusted_set,
++};
+diff -ruN linux-2.6.20.3/fs/ext3cow/xattr_user.c linux-2.6.20.3-ext3cow/fs/ext3cow/xattr_user.c
+--- linux-2.6.20.3/fs/ext3cow/xattr_user.c 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/fs/ext3cow/xattr_user.c 2007-04-07 14:23:50.000000000 -0400
+@@ -0,0 +1,64 @@
++/*
++ * linux/fs/ext3cow/xattr_user.c
++ * Handler for extended user attributes.
++ *
++ * Copyright (C) 2001 by Andreas Gruenbacher,
++ */
++
++#include
++#include
++#include
++#include
++#include
++#include
++#include "xattr.h"
++
++#define XATTR_USER_PREFIX "user."
++
++static size_t
++ext3cow_xattr_user_list(struct inode *inode, char *list, size_t list_size,
++ const char *name, size_t name_len)
++{
++ const size_t prefix_len = sizeof(XATTR_USER_PREFIX)-1;
++ const size_t total_len = prefix_len + name_len + 1;
++
++ if (!test_opt(inode->i_sb, XATTR_USER))
++ return 0;
++
++ if (list && total_len <= list_size) {
++ memcpy(list, XATTR_USER_PREFIX, prefix_len);
++ memcpy(list+prefix_len, name, name_len);
++ list[prefix_len + name_len] = '\0';
++ }
++ return total_len;
++}
++
++static int
++ext3cow_xattr_user_get(struct inode *inode, const char *name,
++ void *buffer, size_t size)
++{
++ if (strcmp(name, "") == 0)
++ return -EINVAL;
++ if (!test_opt(inode->i_sb, XATTR_USER))
++ return -EOPNOTSUPP;
++ return ext3cow_xattr_get(inode, EXT3COW_XATTR_INDEX_USER, name, buffer, size);
++}
++
++static int
++ext3cow_xattr_user_set(struct inode *inode, const char *name,
++ const void *value, size_t size, int flags)
++{
++ if (strcmp(name, "") == 0)
++ return -EINVAL;
++ if (!test_opt(inode->i_sb, XATTR_USER))
++ return -EOPNOTSUPP;
++ return ext3cow_xattr_set(inode, EXT3COW_XATTR_INDEX_USER, name,
++ value, size, flags);
++}
++
++struct xattr_handler ext3cow_xattr_user_handler = {
++ .prefix = XATTR_USER_PREFIX,
++ .list = ext3cow_xattr_user_list,
++ .get = ext3cow_xattr_user_get,
++ .set = ext3cow_xattr_user_set,
++};
+diff -ruN linux-2.6.20.3/include/linux/ext3cow_fs.h linux-2.6.20.3-ext3cow/include/linux/ext3cow_fs.h
+--- linux-2.6.20.3/include/linux/ext3cow_fs.h 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/include/linux/ext3cow_fs.h 2007-04-07 15:30:04.000000000 -0400
+@@ -0,0 +1,947 @@
++/*
++ * linux/include/linux/ext3cow_fs.h
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/include/linux/minix_fs.h
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ */
++
++#ifndef _LINUX_EXT3COW_FS_H
++#define _LINUX_EXT3COW_FS_H
++
++#include
++#include
++
++/*
++ * The second extended filesystem constants/structures
++ */
++
++/*
++ * Define EXT3COWFS_DEBUG to produce debug messages
++ */
++#undef EXT3COWFS_DEBUG
++
++/*
++ * Define EXT3COW_RESERVATION to reserve data blocks for expanding files
++ */
++#define EXT3COW_DEFAULT_RESERVE_BLOCKS 8
++/*max window size: 1024(direct blocks) + 3([t,d]indirect blocks) */
++#define EXT3COW_MAX_RESERVE_BLOCKS 1027
++#define EXT3COW_RESERVE_WINDOW_NOT_ALLOCATED 0
++/*
++ * Always enable hashed directories
++ */
++//#define CONFIG_EXT3COW_INDEX
++
++/*
++ * Debug code
++ */
++#ifdef EXT3COWFS_DEBUG
++#define ext3cow_debug(f, a...) \
++ do { \
++ printk (KERN_DEBUG "EXT3COW-fs DEBUG (%s, %d): %s:", \
++ __FILE__, __LINE__, __FUNCTION__); \
++ printk (KERN_DEBUG f, ## a); \
++ } while (0)
++#else
++#define ext3cow_debug(f, a...) do {} while (0)
++#endif
++
++/*
++ * Special inodes numbers
++ */
++#define EXT3COW_BAD_INO 1 /* Bad blocks inode */
++#define EXT3COW_ROOT_INO 2 /* Root inode */
++#define EXT3COW_BOOT_LOADER_INO 5 /* Boot loader inode */
++#define EXT3COW_UNDEL_DIR_INO 6 /* Undelete directory inode */
++#define EXT3COW_RESIZE_INO 7 /* Reserved group descriptors inode */
++#define EXT3COW_JOURNAL_INO 8 /* Journal inode */
++
++/* First non-reserved inode for old ext3cow filesystems */
++#define EXT3COW_GOOD_OLD_FIRST_INO 11
++
++/*
++ * Maximal count of links to a file
++ */
++#define EXT3COW_LINK_MAX 32000
++
++/* For versioning -znjp */
++#define EXT3COW_FLUX_TOKEN '@'
++/* Macros for scoping - in seconds -znjp */
++#define ONEHOUR 3600
++#define YESTERDAY 86400
++#define ONEWEEK 604800
++#define ONEMONTH 2419200
++#define ONEYEAR 31449600
++
++/*
++ * Macro-instructions used to manage several block sizes
++ */
++#define EXT3COW_MIN_BLOCK_SIZE 1024
++#define EXT3COW_MAX_BLOCK_SIZE 4096
++#define EXT3COW_MIN_BLOCK_LOG_SIZE 10
++#ifdef __KERNEL__
++# define EXT3COW_BLOCK_SIZE(s) ((s)->s_blocksize)
++#else
++# define EXT3COW_BLOCK_SIZE(s) (EXT3COW_MIN_BLOCK_SIZE << (s)->s_log_block_size)
++#endif
++//#define EXT3COW_ADDR_PER_BLOCK(s) (EXT3COW_BLOCK_SIZE(s) / sizeof (__u32))
++#ifdef __KERNEL__
++# define EXT3COW_BLOCK_SIZE_BITS(s) ((s)->s_blocksize_bits)
++#else
++# define EXT3COW_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10)
++#endif
++#ifdef __KERNEL__
++#define EXT3COW_ADDR_PER_BLOCK_BITS(s) (EXT3COW_SB(s)->s_addr_per_block_bits)
++#define EXT3COW_INODE_SIZE(s) (EXT3COW_SB(s)->s_inode_size)
++#define EXT3COW_FIRST_INO(s) (EXT3COW_SB(s)->s_first_ino)
++#else
++#define EXT3COW_INODE_SIZE(s) (((s)->s_rev_level == EXT3COW_GOOD_OLD_REV) ? \
++ EXT3COW_GOOD_OLD_INODE_SIZE : \
++ (s)->s_inode_size)
++#define EXT3COW_FIRST_INO(s) (((s)->s_rev_level == EXT3COW_GOOD_OLD_REV) ? \
++ EXT3COW_GOOD_OLD_FIRST_INO : \
++ (s)->s_first_ino)
++#endif
++/*
++ * Macro-instructions for versioning support - znjp
++ */
++#define EXT3COW_COWBITMAP_SIZE (sizeof(__u32) * 8) /* one word */
++#define EXT3COW_COWBITMAPS_PER_IBLOCK(s) \
++ (( (EXT3COW_BLOCK_SIZE(s) / sizeof(__u32)) / (EXT3COW_COWBITMAP_SIZE)))
++/* Accounts for COW bitmaps */
++#define EXT3COW_ADDR_PER_BLOCK(s) ((EXT3COW_BLOCK_SIZE(s) / sizeof(__u32)) - EXT3COW_COWBITMAPS_PER_IBLOCK(s))
++
++/*
++ * Macro-instructions used to manage fragments
++ */
++#define EXT3COW_MIN_FRAG_SIZE 1024
++#define EXT3COW_MAX_FRAG_SIZE 4096
++#define EXT3COW_MIN_FRAG_LOG_SIZE 10
++#ifdef __KERNEL__
++# define EXT3COW_FRAG_SIZE(s) (EXT3COW_SB(s)->s_frag_size)
++# define EXT3COW_FRAGS_PER_BLOCK(s) (EXT3COW_SB(s)->s_frags_per_block)
++#else
++# define EXT3COW_FRAG_SIZE(s) (EXT3COW_MIN_FRAG_SIZE << (s)->s_log_frag_size)
++# define EXT3COW_FRAGS_PER_BLOCK(s) (EXT3COW_BLOCK_SIZE(s) / EXT3COW_FRAG_SIZE(s))
++#endif
++
++/*
++ * Structure of a blocks group descriptor
++ */
++struct ext3cow_group_desc
++{
++ __le32 bg_block_bitmap; /* Blocks bitmap block */
++ __le32 bg_inode_bitmap; /* Inodes bitmap block */
++ __le32 bg_inode_table; /* Inodes table block */
++ __le16 bg_free_blocks_count; /* Free blocks count */
++ __le16 bg_free_inodes_count; /* Free inodes count */
++ __le16 bg_used_dirs_count; /* Directories count */
++ __u16 bg_pad;
++ __le32 bg_reserved[3];
++};
++
++/*
++ * Macro-instructions used to manage group descriptors
++ */
++#ifdef __KERNEL__
++# define EXT3COW_BLOCKS_PER_GROUP(s) (EXT3COW_SB(s)->s_blocks_per_group)
++# define EXT3COW_DESC_PER_BLOCK(s) (EXT3COW_SB(s)->s_desc_per_block)
++# define EXT3COW_INODES_PER_GROUP(s) (EXT3COW_SB(s)->s_inodes_per_group)
++# define EXT3COW_DESC_PER_BLOCK_BITS(s) (EXT3COW_SB(s)->s_desc_per_block_bits)
++#else
++# define EXT3COW_BLOCKS_PER_GROUP(s) ((s)->s_blocks_per_group)
++# define EXT3COW_DESC_PER_BLOCK(s) (EXT3COW_BLOCK_SIZE(s) / sizeof (struct ext3cow_group_desc))
++# define EXT3COW_INODES_PER_GROUP(s) ((s)->s_inodes_per_group)
++#endif
++
++/*
++ * Constants relative to the data blocks
++ */
++#define EXT3COW_NDIR_BLOCKS 12
++#define EXT3COW_IND_BLOCK EXT3COW_NDIR_BLOCKS
++#define EXT3COW_DIND_BLOCK (EXT3COW_IND_BLOCK + 1)
++#define EXT3COW_TIND_BLOCK (EXT3COW_DIND_BLOCK + 1)
++#define EXT3COW_N_BLOCKS (EXT3COW_TIND_BLOCK + 1)
++
++/*
++ * Inode flags
++ */
++#define EXT3COW_SECRM_FL 0x00000001 /* Secure deletion */
++#define EXT3COW_UNRM_FL 0x00000002 /* Undelete */
++#define EXT3COW_COMPR_FL 0x00000004 /* Compress file */
++#define EXT3COW_SYNC_FL 0x00000008 /* Synchronous updates */
++#define EXT3COW_IMMUTABLE_FL 0x00000010 /* Immutable file */
++#define EXT3COW_APPEND_FL 0x00000020 /* writes to file may only append */
++#define EXT3COW_NODUMP_FL 0x00000040 /* do not dump file */
++#define EXT3COW_NOATIME_FL 0x00000080 /* do not update atime */
++/* Reserved for compression usage... */
++#define EXT3COW_DIRTY_FL 0x00000100
++#define EXT3COW_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
++#define EXT3COW_NOCOMPR_FL 0x00000400 /* Don't compress */
++#define EXT3COW_ECOMPR_FL 0x00000800 /* Compression error */
++/* End compression flags --- maybe not all used */
++#define EXT3COW_INDEX_FL 0x00001000 /* hash-indexed directory */
++#define EXT3COW_IMAGIC_FL 0x00002000 /* AFS directory */
++#define EXT3COW_JOURNAL_DATA_FL 0x00004000 /* file data should be journaled */
++#define EXT3COW_NOTAIL_FL 0x00008000 /* file tail should not be merged */
++#define EXT3COW_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
++#define EXT3COW_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
++/* Used for Versioning - znjp */
++#define EXT3COW_UNCHANGEABLE_FL 0x00040000
++#define EXT3COW_UNVERSIONABLE_FL 0x00080000
++#define EXT3COW_FAKEINODE_FL 0x00100000
++#define EXT3COW_RESERVED_FL 0x80000000 /* reserved for ext3cow lib */
++
++#define EXT3COW_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */
++#define EXT3COW_FL_USER_MODIFIABLE 0x000380FF /* User modifiable flags */
++
++/*
++ * Inode dynamic state flags
++ */
++#define EXT3COW_STATE_JDATA 0x00000001 /* journaled data exists */
++#define EXT3COW_STATE_NEW 0x00000002 /* inode is newly created */
++#define EXT3COW_STATE_XATTR 0x00000004 /* has in-inode xattrs */
++
++/* Used to pass group descriptor data when online resize is done */
++struct ext3cow_new_group_input {
++ __u32 group; /* Group number for this data */
++ __u32 block_bitmap; /* Absolute block number of block bitmap */
++ __u32 inode_bitmap; /* Absolute block number of inode bitmap */
++ __u32 inode_table; /* Absolute block number of inode table start */
++ __u32 blocks_count; /* Total number of blocks in this group */
++ __u16 reserved_blocks; /* Number of reserved blocks in this group */
++ __u16 unused;
++};
++
++/* The struct ext3cow_new_group_input in kernel space, with free_blocks_count */
++struct ext3cow_new_group_data {
++ __u32 group;
++ __u32 block_bitmap;
++ __u32 inode_bitmap;
++ __u32 inode_table;
++ __u32 blocks_count;
++ __u16 reserved_blocks;
++ __u16 unused;
++ __u32 free_blocks_count;
++};
++
++
++/*
++ * ioctl commands
++ */
++#define EXT3COW_IOC_GETFLAGS FS_IOC_GETFLAGS
++#define EXT3COW_IOC_SETFLAGS FS_IOC_SETFLAGS
++#define EXT3COW_IOC_GETVERSION _IOR('f', 3, long)
++#define EXT3COW_IOC_SETVERSION _IOW('f', 4, long)
++#define EXT3COW_IOC_GROUP_EXTEND _IOW('f', 7, unsigned long)
++#define EXT3COW_IOC_GROUP_ADD _IOW('f', 8,struct ext3cow_new_group_input)
++#define EXT3COW_IOC_GETVERSION_OLD FS_IOC_GETVERSION
++#define EXT3COW_IOC_SETVERSION_OLD FS_IOC_SETVERSION
++#ifdef CONFIG_JBD_DEBUG
++#define EXT3COW_IOC_WAIT_FOR_READONLY _IOR('f', 99, long)
++#endif
++#define EXT3COW_IOC_GETRSVSZ _IOR('f', 5, long)
++#define EXT3COW_IOC_SETRSVSZ _IOW('f', 6, long)
++/* ioctls for versioning - znjp */
++#define EXT3COW_IOC_TAKESNAPSHOT _IOR('f', 7, long)
++#define EXT3COW_IOC_GETEPOCH _IOR('f', 8, long)
++
++/*
++ * ioctl commands in 32 bit emulation
++ */
++#define EXT3COW_IOC32_GETFLAGS FS_IOC32_GETFLAGS
++#define EXT3COW_IOC32_SETFLAGS FS_IOC32_SETFLAGS
++#define EXT3COW_IOC32_GETVERSION _IOR('f', 3, int)
++#define EXT3COW_IOC32_SETVERSION _IOW('f', 4, int)
++#define EXT3COW_IOC32_GETRSVSZ _IOR('f', 5, int)
++#define EXT3COW_IOC32_SETRSVSZ _IOW('f', 6, int)
++#define EXT3COW_IOC32_GROUP_EXTEND _IOW('f', 7, unsigned int)
++#ifdef CONFIG_JBD_DEBUG
++#define EXT3COW_IOC32_WAIT_FOR_READONLY _IOR('f', 99, int)
++#endif
++#define EXT3COW_IOC32_GETVERSION_OLD FS_IOC32_GETVERSION
++#define EXT3COW_IOC32_SETVERSION_OLD FS_IOC32_SETVERSION
++
++
++/*
++ * Mount options
++ */
++struct ext3cow_mount_options {
++ unsigned long s_mount_opt;
++ uid_t s_resuid;
++ gid_t s_resgid;
++ unsigned long s_commit_interval;
++#ifdef CONFIG_QUOTA
++ int s_jquota_fmt;
++ char *s_qf_names[MAXQUOTAS];
++#endif
++};
++
++/*
++ * Structure of an inode on the disk
++ */
++struct ext3cow_inode {
++ __le16 i_mode; /* File mode */
++ __le16 i_uid; /* Low 16 bits of Owner Uid */
++ __le32 i_size; /* Size in bytes */
++ __le32 i_atime; /* Access time */
++ __le32 i_ctime; /* Creation time */
++ __le32 i_mtime; /* Modification time */
++ __le32 i_dtime; /* Deletion Time */
++ __le16 i_gid; /* Low 16 bits of Group Id */
++ __le16 i_links_count; /* Links count */
++ __le32 i_blocks; /* Blocks count */
++ __le32 i_flags; /* File flags */
++ union {
++ struct {
++ //__u32 l_i_reserved1;
++ /* Direct block COW bitmap -znjp */
++ __u16 l_i_direct_cow_bitmap;
++ __u16 l_i_pad1;
++ } linux1;
++ struct {
++ __u32 h_i_translator;
++ } hurd1;
++ struct {
++ __u32 m_i_reserved1;
++ } masix1;
++ } osd1; /* OS dependent 1 */
++ __le32 i_block[EXT3COW_N_BLOCKS];/* Pointers to blocks */
++ __le32 i_generation; /* File version (for NFS) */
++ __le32 i_file_acl; /* File ACL */
++ __le32 i_dir_acl; /* Directory ACL */
++ __le32 i_faddr; /* Fragment address */
++ union {
++ struct {
++ __u8 l_i_frag; /* Fragment number */
++ __u8 l_i_fsize; /* Fragment size */
++ __u16 i_pad1;
++ //__le16 l_i_uid_high; /* these 2 fields */
++ //__le16 l_i_gid_high; /* were reserved2[0] */
++ //__u32 l_i_reserved2;
++ /* Epoch number for versioning -znjp */
++ __le32 l_i_epoch_number;
++ __u32 l_i_next_inode;
++ } linux2;
++ struct {
++ __u8 h_i_frag; /* Fragment number */
++ __u8 h_i_fsize; /* Fragment size */
++ __u16 h_i_mode_high;
++ __u16 h_i_uid_high;
++ __u16 h_i_gid_high;
++ __u32 h_i_author;
++ } hurd2;
++ struct {
++ __u8 m_i_frag; /* Fragment number */
++ __u8 m_i_fsize; /* Fragment size */
++ __u16 m_pad1;
++ __u32 m_i_reserved2[2];
++ } masix2;
++ } osd2; /* OS dependent 2 */
++ __le16 i_extra_isize;
++ __le16 i_pad1;
++};
++
++#define i_size_high i_dir_acl
++
++#if defined(__KERNEL__) || defined(__linux__)
++/* For versioning -znjp */
++//#define i_reserved1 osd1.linux1.l_i_reserved1
++#define i_cowbitmap osd1.linux1.l_i_direct_cow_bitmap
++#define i_frag osd2.linux2.l_i_frag
++#define i_fsize osd2.linux2.l_i_fsize
++#define i_uid_low i_uid
++#define i_gid_low i_gid
++/* For versioning -znjp */
++//#define i_uid_high osd2.linux2.l_i_uid_high
++//#define i_gid_high osd2.linux2.l_i_gid_high
++//#define i_reserved2 osd2.linux2.l_i_reserved2
++#define i_epch_number osd2.linux2.l_i_epoch_number
++#define i_nxt_inode osd2.linux2.l_i_next_inode
++
++#elif defined(__GNU__)
++
++#define i_translator osd1.hurd1.h_i_translator
++#define i_frag osd2.hurd2.h_i_frag;
++#define i_fsize osd2.hurd2.h_i_fsize;
++#define i_uid_high osd2.hurd2.h_i_uid_high
++#define i_gid_high osd2.hurd2.h_i_gid_high
++#define i_author osd2.hurd2.h_i_author
++
++#elif defined(__masix__)
++
++#define i_reserved1 osd1.masix1.m_i_reserved1
++#define i_frag osd2.masix2.m_i_frag
++#define i_fsize osd2.masix2.m_i_fsize
++#define i_reserved2 osd2.masix2.m_i_reserved2
++
++#endif /* defined(__KERNEL__) || defined(__linux__) */
++
++/*
++ * File system states
++ */
++#define EXT3COW_VALID_FS 0x0001 /* Unmounted cleanly */
++#define EXT3COW_ERROR_FS 0x0002 /* Errors detected */
++#define EXT3COW_ORPHAN_FS 0x0004 /* Orphans being recovered */
++
++/*
++ * Mount flags
++ */
++#define EXT3COW_MOUNT_CHECK 0x00001 /* Do mount-time checks */
++#define EXT3COW_MOUNT_OLDALLOC 0x00002 /* Don't use the new Orlov allocator */
++#define EXT3COW_MOUNT_GRPID 0x00004 /* Create files with directory's group */
++#define EXT3COW_MOUNT_DEBUG 0x00008 /* Some debugging messages */
++#define EXT3COW_MOUNT_ERRORS_CONT 0x00010 /* Continue on errors */
++#define EXT3COW_MOUNT_ERRORS_RO 0x00020 /* Remount fs ro on errors */
++#define EXT3COW_MOUNT_ERRORS_PANIC 0x00040 /* Panic on errors */
++#define EXT3COW_MOUNT_MINIX_DF 0x00080 /* Mimics the Minix statfs */
++#define EXT3COW_MOUNT_NOLOAD 0x00100 /* Don't use existing journal*/
++#define EXT3COW_MOUNT_ABORT 0x00200 /* Fatal error detected */
++#define EXT3COW_MOUNT_DATA_FLAGS 0x00C00 /* Mode for data writes: */
++#define EXT3COW_MOUNT_JOURNAL_DATA 0x00400 /* Write data to journal */
++#define EXT3COW_MOUNT_ORDERED_DATA 0x00800 /* Flush data before commit */
++#define EXT3COW_MOUNT_WRITEBACK_DATA 0x00C00 /* No data ordering */
++#define EXT3COW_MOUNT_UPDATE_JOURNAL 0x01000 /* Update the journal format */
++#define EXT3COW_MOUNT_NO_UID32 0x02000 /* Disable 32-bit UIDs */
++#define EXT3COW_MOUNT_XATTR_USER 0x04000 /* Extended user attributes */
++#define EXT3COW_MOUNT_POSIX_ACL 0x08000 /* POSIX Access Control Lists */
++#define EXT3COW_MOUNT_RESERVATION 0x10000 /* Preallocation */
++#define EXT3COW_MOUNT_BARRIER 0x20000 /* Use block barriers */
++#define EXT3COW_MOUNT_NOBH 0x40000 /* No bufferheads */
++#define EXT3COW_MOUNT_QUOTA 0x80000 /* Some quota option set */
++#define EXT3COW_MOUNT_USRQUOTA 0x100000 /* "old" user quota */
++#define EXT3COW_MOUNT_GRPQUOTA 0x200000 /* "old" group quota */
++
++/* Compatibility, for having both ext2_fs.h and ext3cow_fs.h included at once */
++#ifndef _LINUX_EXT2_FS_H
++#define clear_opt(o, opt) o &= ~EXT3COW_MOUNT_##opt
++#define set_opt(o, opt) o |= EXT3COW_MOUNT_##opt
++#define test_opt(sb, opt) (EXT3COW_SB(sb)->s_mount_opt & \
++ EXT3COW_MOUNT_##opt)
++#else
++#define EXT2_MOUNT_NOLOAD EXT3COW_MOUNT_NOLOAD
++#define EXT2_MOUNT_ABORT EXT3COW_MOUNT_ABORT
++#define EXT2_MOUNT_DATA_FLAGS EXT3COW_MOUNT_DATA_FLAGS
++#endif
++
++#define ext3cow_set_bit ext2_set_bit
++#define ext3cow_set_bit_atomic ext2_set_bit_atomic
++#define ext3cow_clear_bit ext2_clear_bit
++#define ext3cow_clear_bit_atomic ext2_clear_bit_atomic
++#define ext3cow_test_bit ext2_test_bit
++#define ext3cow_find_first_zero_bit ext2_find_first_zero_bit
++#define ext3cow_find_next_zero_bit ext2_find_next_zero_bit
++
++/*
++ * Maximal mount counts between two filesystem checks
++ */
++#define EXT3COW_DFL_MAX_MNT_COUNT 20 /* Allow 20 mounts */
++#define EXT3COW_DFL_CHECKINTERVAL 0 /* Don't use interval check */
++
++/*
++ * Behaviour when detecting errors
++ */
++#define EXT3COW_ERRORS_CONTINUE 1 /* Continue execution */
++#define EXT3COW_ERRORS_RO 2 /* Remount fs read-only */
++#define EXT3COW_ERRORS_PANIC 3 /* Panic */
++#define EXT3COW_ERRORS_DEFAULT EXT3COW_ERRORS_CONTINUE
++
++/*
++ * Structure of the super block
++ */
++struct ext3cow_super_block {
++/*00*/ __le32 s_inodes_count; /* Inodes count */
++ __le32 s_blocks_count; /* Blocks count */
++ __le32 s_r_blocks_count; /* Reserved blocks count */
++ __le32 s_free_blocks_count; /* Free blocks count */
++/*10*/ __le32 s_free_inodes_count; /* Free inodes count */
++ __le32 s_first_data_block; /* First Data Block */
++ __le32 s_log_block_size; /* Block size */
++ __le32 s_log_frag_size; /* Fragment size */
++/*20*/ __le32 s_blocks_per_group; /* # Blocks per group */
++ __le32 s_frags_per_group; /* # Fragments per group */
++ __le32 s_inodes_per_group; /* # Inodes per group */
++ __le32 s_mtime; /* Mount time */
++/*30*/ __le32 s_wtime; /* Write time */
++ __le16 s_mnt_count; /* Mount count */
++ __le16 s_max_mnt_count; /* Maximal mount count */
++ __le16 s_magic; /* Magic signature */
++ __le16 s_state; /* File system state */
++ __le16 s_errors; /* Behaviour when detecting errors */
++ __le16 s_minor_rev_level; /* minor revision level */
++/*40*/ __le32 s_lastcheck; /* time of last check */
++ __le32 s_checkinterval; /* max. time between checks */
++ __le32 s_creator_os; /* OS */
++ __le32 s_rev_level; /* Revision level */
++/*50*/ __le16 s_def_resuid; /* Default uid for reserved blocks */
++ __le16 s_def_resgid; /* Default gid for reserved blocks */
++ /*
++ * These fields are for EXT3COW_DYNAMIC_REV superblocks only.
++ *
++ * Note: the difference between the compatible feature set and
++ * the incompatible feature set is that if there is a bit set
++ * in the incompatible feature set that the kernel doesn't
++ * know about, it should refuse to mount the filesystem.
++ *
++ * e2fsck's requirements are more strict; if it doesn't know
++ * about a feature in either the compatible or incompatible
++ * feature set, it must abort and not try to meddle with
++ * things it doesn't understand...
++ */
++ __le32 s_first_ino; /* First non-reserved inode */
++ __le16 s_inode_size; /* size of inode structure */
++ __le16 s_block_group_nr; /* block group # of this superblock */
++ __le32 s_feature_compat; /* compatible feature set */
++/*60*/ __le32 s_feature_incompat; /* incompatible feature set */
++ __le32 s_feature_ro_compat; /* readonly-compatible feature set */
++/*68*/ __u8 s_uuid[16]; /* 128-bit uuid for volume */
++/*78*/ char s_volume_name[16]; /* volume name */
++/*88*/ char s_last_mounted[64]; /* directory where last mounted */
++/*C8*/ __le32 s_algorithm_usage_bitmap; /* For compression */
++ /*
++ * Performance hints. Directory preallocation should only
++ * happen if the EXT3COW_FEATURE_COMPAT_DIR_PREALLOC flag is on.
++ */
++ __u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/
++ __u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */
++ __le16 s_reserved_gdt_blocks; /* Per group desc for online growth */
++ /*
++ * Journaling support valid if EXT3COW_FEATURE_COMPAT_HAS_JOURNAL set.
++ */
++/*D0*/ __u8 s_journal_uuid[16]; /* uuid of journal superblock */
++/*E0*/ __le32 s_journal_inum; /* inode number of journal file */
++ __le32 s_journal_dev; /* device number of journal file */
++ __le32 s_last_orphan; /* start of list of inodes to delete */
++ __le32 s_hash_seed[4]; /* HTREE hash seed */
++ __u8 s_def_hash_version; /* Default hash version to use */
++ __u8 s_reserved_char_pad;
++ __u16 s_reserved_word_pad;
++ __le32 s_default_mount_opts;
++ __le32 s_first_meta_bg; /* First metablock block group */
++ /* Added for version - znjp */
++ __le32 s_epoch_number;
++ __u32 s_reserved[189]; /* Padding to the end of the block */
++};
++
++#ifdef __KERNEL__
++#include
++#include
++static inline struct ext3cow_sb_info * EXT3COW_SB(struct super_block *sb)
++{
++ return sb->s_fs_info;
++}
++static inline struct ext3cow_inode_info *EXT3COW_I(struct inode *inode)
++{
++ return container_of(inode, struct ext3cow_inode_info, vfs_inode);
++}
++
++static inline int ext3cow_valid_inum(struct super_block *sb, unsigned long ino)
++{
++ return ino == EXT3COW_ROOT_INO ||
++ ino == EXT3COW_JOURNAL_INO ||
++ ino == EXT3COW_RESIZE_INO ||
++ (ino >= EXT3COW_FIRST_INO(sb) &&
++ ino <= le32_to_cpu(EXT3COW_SB(sb)->s_es->s_inodes_count));
++}
++#else
++/* Assume that user mode programs are passing in an ext3cowfs superblock, not
++ * a kernel struct super_block. This will allow us to call the feature-test
++ * macros from user land. */
++#define EXT3COW_SB(sb) (sb)
++#endif
++
++#define NEXT_ORPHAN(inode) EXT3COW_I(inode)->i_dtime
++
++/*
++ * Codes for operating systems
++ */
++#define EXT3COW_OS_LINUX 0
++#define EXT3COW_OS_HURD 1
++#define EXT3COW_OS_MASIX 2
++#define EXT3COW_OS_FREEBSD 3
++#define EXT3COW_OS_LITES 4
++
++/*
++ * Revision levels
++ */
++#define EXT3COW_GOOD_OLD_REV 0 /* The good old (original) format */
++#define EXT3COW_DYNAMIC_REV 1 /* V2 format w/ dynamic inode sizes */
++
++#define EXT3COW_CURRENT_REV EXT3COW_GOOD_OLD_REV
++#define EXT3COW_MAX_SUPP_REV EXT3COW_DYNAMIC_REV
++
++#define EXT3COW_GOOD_OLD_INODE_SIZE 128
++
++/*
++ * Feature set definitions
++ */
++
++#define EXT3COW_HAS_COMPAT_FEATURE(sb,mask) \
++ ( EXT3COW_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
++#define EXT3COW_HAS_RO_COMPAT_FEATURE(sb,mask) \
++ ( EXT3COW_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
++#define EXT3COW_HAS_INCOMPAT_FEATURE(sb,mask) \
++ ( EXT3COW_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
++#define EXT3COW_SET_COMPAT_FEATURE(sb,mask) \
++ EXT3COW_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
++#define EXT3COW_SET_RO_COMPAT_FEATURE(sb,mask) \
++ EXT3COW_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
++#define EXT3COW_SET_INCOMPAT_FEATURE(sb,mask) \
++ EXT3COW_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
++#define EXT3COW_CLEAR_COMPAT_FEATURE(sb,mask) \
++ EXT3COW_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
++#define EXT3COW_CLEAR_RO_COMPAT_FEATURE(sb,mask) \
++ EXT3COW_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
++#define EXT3COW_CLEAR_INCOMPAT_FEATURE(sb,mask) \
++ EXT3COW_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
++
++#define EXT3COW_FEATURE_COMPAT_DIR_PREALLOC 0x0001
++#define EXT3COW_FEATURE_COMPAT_IMAGIC_INODES 0x0002
++#define EXT3COW_FEATURE_COMPAT_HAS_JOURNAL 0x0004
++#define EXT3COW_FEATURE_COMPAT_EXT_ATTR 0x0008
++#define EXT3COW_FEATURE_COMPAT_RESIZE_INODE 0x0010
++#define EXT3COW_FEATURE_COMPAT_DIR_INDEX 0x0020
++
++#define EXT3COW_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001
++#define EXT3COW_FEATURE_RO_COMPAT_LARGE_FILE 0x0002
++#define EXT3COW_FEATURE_RO_COMPAT_BTREE_DIR 0x0004
++
++#define EXT3COW_FEATURE_INCOMPAT_COMPRESSION 0x0001
++#define EXT3COW_FEATURE_INCOMPAT_FILETYPE 0x0002
++#define EXT3COW_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */
++#define EXT3COW_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Journal device */
++#define EXT3COW_FEATURE_INCOMPAT_META_BG 0x0010
++
++#define EXT3COW_FEATURE_COMPAT_SUPP EXT2_FEATURE_COMPAT_EXT_ATTR
++#define EXT3COW_FEATURE_INCOMPAT_SUPP (EXT3COW_FEATURE_INCOMPAT_FILETYPE| \
++ EXT3COW_FEATURE_INCOMPAT_RECOVER| \
++ EXT3COW_FEATURE_INCOMPAT_META_BG)
++#define EXT3COW_FEATURE_RO_COMPAT_SUPP (EXT3COW_FEATURE_RO_COMPAT_SPARSE_SUPER| \
++ EXT3COW_FEATURE_RO_COMPAT_LARGE_FILE| \
++ EXT3COW_FEATURE_RO_COMPAT_BTREE_DIR)
++
++/*
++ * Default values for user and/or group using reserved blocks
++ */
++#define EXT3COW_DEF_RESUID 0
++#define EXT3COW_DEF_RESGID 0
++
++/*
++ * Default mount options
++ */
++#define EXT3COW_DEFM_DEBUG 0x0001
++#define EXT3COW_DEFM_BSDGROUPS 0x0002
++#define EXT3COW_DEFM_XATTR_USER 0x0004
++#define EXT3COW_DEFM_ACL 0x0008
++#define EXT3COW_DEFM_UID16 0x0010
++#define EXT3COW_DEFM_JMODE 0x0060
++#define EXT3COW_DEFM_JMODE_DATA 0x0020
++#define EXT3COW_DEFM_JMODE_ORDERED 0x0040
++#define EXT3COW_DEFM_JMODE_WBACK 0x0060
++
++/*
++ * Structure of a directory entry
++ */
++#define EXT3COW_NAME_LEN 255
++
++struct ext3cow_dir_entry {
++ __le32 inode; /* Inode number */
++ __le16 rec_len; /* Directory entry length */
++ __le16 name_len; /* Name length */
++ char name[EXT3COW_NAME_LEN]; /* File name */
++};
++
++/*
++ * The new version of the directory entry. Since EXT3COW structures are
++ * stored in intel byte order, and the name_len field could never be
++ * bigger than 255 chars, it's safe to reclaim the extra byte for the
++ * file_type field.
++ */
++struct ext3cow_dir_entry_2 {
++ __le32 inode; /* Inode number */
++ __le16 rec_len; /* Directory entry length */
++ __u8 name_len; /* Name length */
++ __u8 file_type;
++ /* Added for versioning - znjp */
++ __u32 birth_epoch;
++ __u32 death_epoch;
++ char name[EXT3COW_NAME_LEN]; /* File name */
++};
++
++/*
++ * Ext3 directory file types. Only the low 3 bits are used. The
++ * other bits are reserved for now.
++ */
++#define EXT3COW_FT_UNKNOWN 0
++#define EXT3COW_FT_REG_FILE 1
++#define EXT3COW_FT_DIR 2
++#define EXT3COW_FT_CHRDEV 3
++#define EXT3COW_FT_BLKDEV 4
++#define EXT3COW_FT_FIFO 5
++#define EXT3COW_FT_SOCK 6
++#define EXT3COW_FT_SYMLINK 7
++
++#define EXT3COW_FT_MAX 8
++
++/* Versioning macros - znjp */
++#define EXT3COW_DIRENT_ALIVE 0
++#define EXT3COW_IS_DIRENT_ALIVE(de) ((le32_to_cpu(de->death_epoch) == EXT3COW_DIRENT_ALIVE))
++#define EXT3COW_IS_DIRENT_SCOPED(de, epoch) \
++((le32_to_cpu(de->birth_epoch) <= epoch) && \
++(EXT3COW_IS_DIRENT_ALIVE(de) || (!EXT3COW_IS_DIRENT_ALIVE(de) && \
++le32_to_cpu(de->death_epoch) > epoch)))
++#define EXT3COW_I_EPOCHNUMBER(inode) (((unsigned int)EXT3COW_I(inode)->i_epoch_number))
++#define EXT3COW_S_EPOCHNUMBER(sb) (((unsigned int)EXT3COW_SB(sb)->s_epoch_number))
++#define EXT3COW_I_NEXT_INODE(inode) (((unsigned int)EXT3COW_I(inode)->i_next_inode))
++#define EXT3COW_IS_UNVERSIONABLE(inode) (((unsigned int)EXT3COW_I(inode)->i_flags & EXT3COW_UNVERSIONABLE_FL))
++#define EXT3COW_IS_UNCHANGEABLE(inode) (((unsigned int)EXT3COW_I(inode)->i_flags & EXT3COW_UNCHANGEABLE_FL))
++#define EXT3COW_IS_FAKEINODE(inode) (((unsigned int)EXT3COW_I(inode)->i_flags & EXT3COW_FAKEINODE_FL))
++
++
++/*
++ * EXT3COW_DIR_PAD defines the directory entries boundaries
++ *
++ * NOTE: It must be a multiple of 4
++ */
++#define EXT3COW_DIR_PAD 4
++#define EXT3COW_DIR_ROUND (EXT3COW_DIR_PAD - 1)
++/* Added 8 to account for birth and death epochs -znjp */
++#define EXT3COW_DIR_REC_LEN(name_len) (((name_len) + 16 + EXT3COW_DIR_ROUND) & \
++ ~EXT3COW_DIR_ROUND)
++/*
++ * Hash Tree Directory indexing
++ * (c) Daniel Phillips, 2001
++ */
++
++#ifdef CONFIG_EXT3COW_INDEX
++ #define is_dx(dir) (EXT3COW_HAS_COMPAT_FEATURE(dir->i_sb, \
++ EXT3COW_FEATURE_COMPAT_DIR_INDEX) && \
++ (EXT3COW_I(dir)->i_flags & EXT3COW_INDEX_FL))
++#define EXT3COW_DIR_LINK_MAX(dir) (!is_dx(dir) && (dir)->i_nlink >= EXT3COW_LINK_MAX)
++#define EXT3COW_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2 || (dir)->i_nlink == 1)
++#else
++ #define is_dx(dir) 0
++#define EXT3COW_DIR_LINK_MAX(dir) ((dir)->i_nlink >= EXT3COW_LINK_MAX)
++#define EXT3COW_DIR_LINK_EMPTY(dir) ((dir)->i_nlink == 2)
++#endif
++
++/* Legal values for the dx_root hash_version field: */
++
++#define DX_HASH_LEGACY 0
++#define DX_HASH_HALF_MD4 1
++#define DX_HASH_TEA 2
++
++#ifdef __KERNEL__
++
++/* hash info structure used by the directory hash */
++struct dx_hash_info
++{
++ u32 hash;
++ u32 minor_hash;
++ int hash_version;
++ u32 *seed;
++};
++
++#define EXT3COW_HTREE_EOF 0x7fffffff
++
++/*
++ * Control parameters used by ext3cow_htree_next_block
++ */
++#define HASH_NB_ALWAYS 1
++
++
++/*
++ * Describe an inode's exact location on disk and in memory
++ */
++struct ext3cow_iloc
++{
++ struct buffer_head *bh;
++ unsigned long offset;
++ unsigned long block_group;
++};
++
++static inline struct ext3cow_inode *ext3cow_raw_inode(struct ext3cow_iloc *iloc)
++{
++ return (struct ext3cow_inode *) (iloc->bh->b_data + iloc->offset);
++}
++
++/*
++ * This structure is stuffed into the struct file's private_data field
++ * for directories. It is where we put information so that we can do
++ * readdir operations in hash tree order.
++ */
++struct dir_private_info {
++ struct rb_root root;
++ struct rb_node *curr_node;
++ struct fname *extra_fname;
++ loff_t last_pos;
++ __u32 curr_hash;
++ __u32 curr_minor_hash;
++ __u32 next_hash;
++};
++
++/* calculate the first block number of the group */
++static inline ext3cow_fsblk_t
++ext3cow_group_first_block_no(struct super_block *sb, unsigned long group_no)
++{
++ return group_no * (ext3cow_fsblk_t)EXT3COW_BLOCKS_PER_GROUP(sb) +
++ le32_to_cpu(EXT3COW_SB(sb)->s_es->s_first_data_block);
++}
++
++/*
++ * Special error return code only used by dx_probe() and its callers.
++ */
++#define ERR_BAD_DX_DIR -75000
++
++/*
++ * Function prototypes
++ */
++
++/*
++ * Ok, these declarations are also in but none of the
++ * ext3cow source programs needs to include it so they are duplicated here.
++ */
++# define NORET_TYPE /**/
++# define ATTRIB_NORET __attribute__((noreturn))
++# define NORET_AND noreturn,
++
++/* balloc.c */
++extern int ext3cow_bg_has_super(struct super_block *sb, int group);
++extern unsigned long ext3cow_bg_num_gdb(struct super_block *sb, int group);
++extern ext3cow_fsblk_t ext3cow_new_block (handle_t *handle, struct inode *inode,
++ ext3cow_fsblk_t goal, int *errp);
++extern ext3cow_fsblk_t ext3cow_new_blocks (handle_t *handle, struct inode *inode,
++ ext3cow_fsblk_t goal, unsigned long *count, int *errp);
++extern void ext3cow_free_blocks (handle_t *handle, struct inode *inode,
++ ext3cow_fsblk_t block, unsigned long count);
++extern void ext3cow_free_blocks_sb (handle_t *handle, struct super_block *sb,
++ ext3cow_fsblk_t block, unsigned long count,
++ unsigned long *pdquot_freed_blocks);
++extern ext3cow_fsblk_t ext3cow_count_free_blocks (struct super_block *);
++extern void ext3cow_check_blocks_bitmap (struct super_block *);
++extern struct ext3cow_group_desc * ext3cow_get_group_desc(struct super_block * sb,
++ unsigned int block_group,
++ struct buffer_head ** bh);
++extern int ext3cow_should_retry_alloc(struct super_block *sb, int *retries);
++extern void ext3cow_init_block_alloc_info(struct inode *);
++extern void ext3cow_rsv_window_add(struct super_block *sb, struct ext3cow_reserve_window_node *rsv);
++
++
++/* dir.c */
++extern int ext3cow_check_dir_entry(const char *, struct inode *,
++ struct ext3cow_dir_entry_2 *,
++ struct buffer_head *, unsigned long);
++extern int ext3cow_htree_store_dirent(struct file *dir_file, __u32 hash,
++ __u32 minor_hash,
++ struct ext3cow_dir_entry_2 *dirent);
++extern void ext3cow_htree_free_dir_info(struct dir_private_info *p);
++
++/* fsync.c */
++extern int ext3cow_sync_file (struct file *, struct dentry *, int);
++
++/* hash.c */
++extern int ext3cowfs_dirhash(const char *name, int len, struct
++ dx_hash_info *hinfo);
++
++/* ialloc.c */
++extern struct inode * ext3cow_new_inode (handle_t *, struct inode *, int);
++extern void ext3cow_free_inode (handle_t *, struct inode *);
++extern struct inode * ext3cow_orphan_get (struct super_block *, unsigned long);
++extern unsigned long ext3cow_count_free_inodes (struct super_block *);
++extern unsigned long ext3cow_count_dirs (struct super_block *);
++extern void ext3cow_check_inodes_bitmap (struct super_block *);
++extern unsigned long ext3cow_count_free (struct buffer_head *, unsigned);
++
++
++/* inode.c */
++int ext3cow_forget(handle_t *handle, int is_metadata, struct inode *inode,
++ struct buffer_head *bh, ext3cow_fsblk_t blocknr);
++struct buffer_head * ext3cow_getblk (handle_t *, struct inode *, long, int, int *);
++struct buffer_head * ext3cow_bread (handle_t *, struct inode *, int, int, int *);
++int ext3cow_get_blocks_handle(handle_t *handle, struct inode *inode,
++ sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result,
++ int create, int extend_disksize);
++
++extern void ext3cow_read_inode (struct inode *);
++extern int ext3cow_write_inode (struct inode *, int);
++extern int ext3cow_setattr (struct dentry *, struct iattr *);
++extern void ext3cow_delete_inode (struct inode *);
++extern int ext3cow_sync_inode (handle_t *, struct inode *);
++extern void ext3cow_discard_reservation (struct inode *);
++extern void ext3cow_dirty_inode(struct inode *);
++extern int ext3cow_change_inode_journal_flag(struct inode *, int);
++extern int ext3cow_get_inode_loc(struct inode *, struct ext3cow_iloc *);
++extern void ext3cow_truncate (struct inode *);
++extern void ext3cow_set_inode_flags(struct inode *);
++extern void ext3cow_set_aops(struct inode *inode);
++
++/* ioctl.c */
++extern int ext3cow_ioctl (struct inode *, struct file *, unsigned int,
++ unsigned long);
++extern long ext3cow_compat_ioctl (struct file *, unsigned int, unsigned long);
++
++/* namei.c */
++extern int is_unchangeable(struct inode *, struct dentry *);
++extern int ext3cow_orphan_add(handle_t *, struct inode *);
++extern int ext3cow_orphan_del(handle_t *, struct inode *);
++extern int ext3cow_htree_fill_tree(struct file *dir_file, __u32 start_hash,
++ __u32 start_minor_hash, __u32 *next_hash);
++extern struct inode *ext3cow_fake_inode(struct inode *, unsigned int);
++extern int ext3cow_dup_inode(struct inode *, struct inode *);
++extern int ext3cow_reclaim_dup_inode(struct inode *, struct inode *);
++
++/* resize.c */
++extern int ext3cow_group_add(struct super_block *sb,
++ struct ext3cow_new_group_data *input);
++extern int ext3cow_group_extend(struct super_block *sb,
++ struct ext3cow_super_block *es,
++ ext3cow_fsblk_t n_blocks_count);
++
++/* super.c */
++extern void ext3cow_error (struct super_block *, const char *, const char *, ...)
++ __attribute__ ((format (printf, 3, 4)));
++extern void __ext3cow_std_error (struct super_block *, const char *, int);
++extern void ext3cow_abort (struct super_block *, const char *, const char *, ...)
++ __attribute__ ((format (printf, 3, 4)));
++extern void ext3cow_warning (struct super_block *, const char *, const char *, ...)
++ __attribute__ ((format (printf, 3, 4)));
++extern void ext3cow_update_dynamic_rev (struct super_block *sb);
++extern unsigned int ext3cow_take_snapshot(struct super_block *sb);
++
++#define ext3cow_std_error(sb, errno) \
++do { \
++ if ((errno)) \
++ __ext3cow_std_error((sb), __FUNCTION__, (errno)); \
++} while (0)
++
++/*
++ * Inodes and files operations
++ */
++
++/* dir.c */
++extern const struct file_operations ext3cow_dir_operations;
++
++/* file.c */
++extern struct inode_operations ext3cow_file_inode_operations;
++extern const struct file_operations ext3cow_file_operations;
++
++/* namei.c */
++extern struct inode_operations ext3cow_dir_inode_operations;
++extern struct inode_operations ext3cow_special_inode_operations;
++
++/* symlink.c */
++extern struct inode_operations ext3cow_symlink_inode_operations;
++extern struct inode_operations ext3cow_fast_symlink_inode_operations;
++
++
++#endif /* __KERNEL__ */
++
++#endif /* _LINUX_EXT3COW_FS_H */
+diff -ruN linux-2.6.20.3/include/linux/ext3cow_fs_i.h linux-2.6.20.3-ext3cow/include/linux/ext3cow_fs_i.h
+--- linux-2.6.20.3/include/linux/ext3cow_fs_i.h 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/include/linux/ext3cow_fs_i.h 2007-03-24 15:22:06.000000000 -0400
+@@ -0,0 +1,152 @@
++/*
++ * linux/include/linux/ext3cow_fs_i.h
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/include/linux/minix_fs_i.h
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ */
++
++#ifndef _LINUX_EXT3COW_FS_I
++#define _LINUX_EXT3COW_FS_I
++
++#include
++#include
++#include
++#include
++
++/* data type for block offset of block group */
++typedef int ext3cow_grpblk_t;
++
++/* data type for filesystem-wide blocks number */
++typedef unsigned long ext3cow_fsblk_t;
++
++#define E3FSBLK "%lu"
++
++struct ext3cow_reserve_window {
++ ext3cow_fsblk_t _rsv_start; /* First byte reserved */
++ ext3cow_fsblk_t _rsv_end; /* Last byte reserved or 0 */
++};
++
++struct ext3cow_reserve_window_node {
++ struct rb_node rsv_node;
++ __u32 rsv_goal_size;
++ __u32 rsv_alloc_hit;
++ struct ext3cow_reserve_window rsv_window;
++};
++
++struct ext3cow_block_alloc_info {
++ /* information about reservation window */
++ struct ext3cow_reserve_window_node rsv_window_node;
++ /*
++ * was i_next_alloc_block in ext3cow_inode_info
++ * is the logical (file-relative) number of the
++ * most-recently-allocated block in this file.
++ * We use this for detecting linearly ascending allocation requests.
++ */
++ __u32 last_alloc_logical_block;
++ /*
++ * Was i_next_alloc_goal in ext3cow_inode_info
++ * is the *physical* companion to i_next_alloc_block.
++ * it the the physical block number of the block which was most-recentl
++ * allocated to this file. This give us the goal (target) for the next
++ * allocation when we detect linearly ascending requests.
++ */
++ ext3cow_fsblk_t last_alloc_physical_block;
++};
++
++#define rsv_start rsv_window._rsv_start
++#define rsv_end rsv_window._rsv_end
++
++/*
++ * third extended file system inode data in memory
++ */
++struct ext3cow_inode_info {
++ __le32 i_data[15]; /* unconverted */
++ __u32 i_flags;
++#ifdef EXT3COW_FRAGMENTS
++ __u32 i_faddr;
++ __u8 i_frag_no;
++ __u8 i_frag_size;
++#endif
++ ext3cow_fsblk_t i_file_acl;
++ __u32 i_dir_acl;
++ __u32 i_dtime;
++
++ /*
++ * i_block_group is the number of the block group which contains
++ * this file's inode. Constant across the lifetime of the inode,
++ * it is ued for making block allocation decisions - we try to
++ * place a file's data blocks near its inode block, and new inodes
++ * near to their parent directory's inode.
++ */
++ __u32 i_block_group;
++ __u32 i_state; /* Dynamic state flags for ext3cow */
++
++ /* block reservation info */
++ struct ext3cow_block_alloc_info *i_block_alloc_info;
++
++ __u32 i_dir_start_lookup;
++
++ /* For versioning -znjp */
++ __u16 i_cow_bitmap;
++ __u32 i_epoch_number;
++ __u32 i_next_inode;
++#ifdef CONFIG_EXT3COW_FS_XATTR
++ /*
++ * Extended attributes can be read independently of the main file
++ * data. Taking i_mutex even when reading would cause contention
++ * between readers of EAs and writers of regular file data, so
++ * instead we synchronize on xattr_sem when reading or changing
++ * EAs.
++ */
++ struct rw_semaphore xattr_sem;
++#endif
++#ifdef CONFIG_EXT3COW_FS_POSIX_ACL
++ struct posix_acl *i_acl;
++ struct posix_acl *i_default_acl;
++#endif
++
++ struct list_head i_orphan; /* unlinked but open inodes */
++
++ /*
++ * i_disksize keeps track of what the inode size is ON DISK, not
++ * in memory. During truncate, i_size is set to the new size by
++ * the VFS prior to calling ext3cow_truncate(), but the filesystem won't
++ * set i_disksize to 0 until the truncate is actually under way.
++ *
++ * The intent is that i_disksize always represents the blocks which
++ * are used by this file. This allows recovery to restart truncate
++ * on orphans if we crash during truncate. We actually write i_disksize
++ * into the on-disk inode when writing inodes out, instead of i_size.
++ *
++ * The only time when i_disksize and i_size may be different is when
++ * a truncate is in progress. The only things which change i_disksize
++ * are ext3cow_get_block (growth) and ext3cow_truncate (shrinkth).
++ */
++ loff_t i_disksize;
++
++ /* on-disk additional length */
++ __u16 i_extra_isize;
++
++ /*
++ * truncate_mutex is for serialising ext3cow_truncate() against
++ * ext3cow_getblock(). In the 2.4 ext2 design, great chunks of inode's
++ * data tree are chopped off during truncate. We can't do that in
++ * ext3cow because whenever we perform intermediate commits during
++ * truncate, the inode and all the metadata blocks *must* be in a
++ * consistent state which allows truncation of the orphans to restart
++ * during recovery. Hence we must fix the get_block-vs-truncate race
++ * by other means, so we have truncate_mutex.
++ */
++ struct mutex truncate_mutex;
++ struct inode vfs_inode;
++};
++
++#endif /* _LINUX_EXT3COW_FS_I */
+diff -ruN linux-2.6.20.3/include/linux/ext3cow_fs_sb.h linux-2.6.20.3-ext3cow/include/linux/ext3cow_fs_sb.h
+--- linux-2.6.20.3/include/linux/ext3cow_fs_sb.h 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/include/linux/ext3cow_fs_sb.h 2007-03-24 15:22:35.000000000 -0400
+@@ -0,0 +1,86 @@
++/*
++ * linux/include/linux/ext3cow_fs_sb.h
++ *
++ * Copyright (C) 1992, 1993, 1994, 1995
++ * Remy Card (card@masi.ibp.fr)
++ * Laboratoire MASI - Institut Blaise Pascal
++ * Universite Pierre et Marie Curie (Paris VI)
++ *
++ * from
++ *
++ * linux/include/linux/minix_fs_sb.h
++ *
++ * Copyright (C) 1991, 1992 Linus Torvalds
++ */
++
++#ifndef _LINUX_EXT3COW_FS_SB
++#define _LINUX_EXT3COW_FS_SB
++
++#ifdef __KERNEL__
++#include
++#include
++#include
++#include
++#endif
++#include
++
++/*
++ * third extended-fs super-block data in memory
++ */
++struct ext3cow_sb_info {
++ unsigned long s_frag_size; /* Size of a fragment in bytes */
++ unsigned long s_frags_per_block;/* Number of fragments per block */
++ unsigned long s_inodes_per_block;/* Number of inodes per block */
++ unsigned long s_frags_per_group;/* Number of fragments in a group */
++ unsigned long s_blocks_per_group;/* Number of blocks in a group */
++ unsigned long s_inodes_per_group;/* Number of inodes in a group */
++ unsigned long s_itb_per_group; /* Number of inode table blocks per group */
++ unsigned long s_gdb_count; /* Number of group descriptor blocks */
++ unsigned long s_desc_per_block; /* Number of group descriptors per block */
++ unsigned long s_groups_count; /* Number of groups in the fs */
++ struct buffer_head * s_sbh; /* Buffer containing the super block */
++ struct ext3cow_super_block * s_es; /* Pointer to the super block in the buffer */
++ struct buffer_head ** s_group_desc;
++ unsigned long s_mount_opt;
++ uid_t s_resuid;
++ gid_t s_resgid;
++ unsigned short s_mount_state;
++ unsigned short s_pad;
++ int s_addr_per_block_bits;
++ int s_desc_per_block_bits;
++ int s_inode_size;
++ int s_first_ino;
++ spinlock_t s_next_gen_lock;
++ u32 s_next_generation;
++ u32 s_hash_seed[4];
++ int s_def_hash_version;
++ struct percpu_counter s_freeblocks_counter;
++ struct percpu_counter s_freeinodes_counter;
++ struct percpu_counter s_dirs_counter;
++ struct blockgroup_lock s_blockgroup_lock;
++
++ /* root of the per fs reservation window tree */
++ spinlock_t s_rsv_window_lock;
++ struct rb_root s_rsv_window_root;
++ struct ext3cow_reserve_window_node s_rsv_window_head;
++
++ /* For versioning -znjp */
++ u32 s_epoch_number;
++
++ /* Journaling */
++ struct inode * s_journal_inode;
++ struct journal_s * s_journal;
++ struct list_head s_orphan;
++ unsigned long s_commit_interval;
++ struct block_device *journal_bdev;
++#ifdef CONFIG_JBD_DEBUG
++ struct timer_list turn_ro_timer; /* For turning read-only (crash simulation) */
++ wait_queue_head_t ro_wait_queue; /* For people waiting for the fs to go read-only */
++#endif
++#ifdef CONFIG_QUOTA
++ char *s_qf_names[MAXQUOTAS]; /* Names of quota files with journalled quota */
++ int s_jquota_fmt; /* Format of quota to use */
++#endif
++};
++
++#endif /* _LINUX_EXT3COW_FS_SB */
+diff -ruN linux-2.6.20.3/include/linux/ext3cow_jbd.h linux-2.6.20.3-ext3cow/include/linux/ext3cow_jbd.h
+--- linux-2.6.20.3/include/linux/ext3cow_jbd.h 1969-12-31 19:00:00.000000000 -0500
++++ linux-2.6.20.3-ext3cow/include/linux/ext3cow_jbd.h 2007-03-24 13:58:07.000000000 -0400
+@@ -0,0 +1,226 @@
++/*
++ * linux/include/linux/ext3cow_jbd.h
++ *
++ * Written by Stephen C. Tweedie , 1999
++ *
++ * Copyright 1998--1999 Red Hat corp --- All Rights Reserved
++ *
++ * This file is part of the Linux kernel and is made available under
++ * the terms of the GNU General Public License, version 2, or at your
++ * option, any later version, incorporated herein by reference.
++ *
++ * Ext3-specific journaling extensions.
++ */
++
++#ifndef _LINUX_EXT3COW_JBD_H
++#define _LINUX_EXT3COW_JBD_H
++
++#include
++#include
++#include
++
++#define EXT3COW_JOURNAL(inode) (EXT3COW_SB((inode)->i_sb)->s_journal)
++
++/* Define the number of blocks we need to account to a transaction to
++ * modify one block of data.
++ *
++ * We may have to touch one inode, one bitmap buffer, up to three
++ * indirection blocks, the group and superblock summaries, and the data
++ * block to complete the transaction. */
++
++#define EXT3COW_SINGLEDATA_TRANS_BLOCKS 8U
++
++/* Extended attribute operations touch at most two data buffers,
++ * two bitmap buffers, and two group summaries, in addition to the inode
++ * and the superblock, which are already accounted for. */
++
++#define EXT3COW_XATTR_TRANS_BLOCKS 6U
++
++/* Define the minimum size for a transaction which modifies data. This
++ * needs to take into account the fact that we may end up modifying two
++ * quota files too (one for the group, one for the user quota). The
++ * superblock only gets updated once, of course, so don't bother
++ * counting that again for the quota updates. */
++
++#define EXT3COW_DATA_TRANS_BLOCKS(sb) (EXT3COW_SINGLEDATA_TRANS_BLOCKS + \
++ EXT3COW_XATTR_TRANS_BLOCKS - 2 + \
++ 2*EXT3COW_QUOTA_TRANS_BLOCKS(sb))
++
++/* Delete operations potentially hit one directory's namespace plus an
++ * entire inode, plus arbitrary amounts of bitmap/indirection data. Be
++ * generous. We can grow the delete transaction later if necessary. */
++
++#define EXT3COW_DELETE_TRANS_BLOCKS(sb) (2 * EXT3COW_DATA_TRANS_BLOCKS(sb) + 64)
++
++/* Define an arbitrary limit for the amount of data we will anticipate
++ * writing to any given transaction. For unbounded transactions such as
++ * write(2) and truncate(2) we can write more than this, but we always
++ * start off at the maximum transaction size and grow the transaction
++ * optimistically as we go. */
++
++#define EXT3COW_MAX_TRANS_DATA 64U
++
++/* We break up a large truncate or write transaction once the handle's
++ * buffer credits gets this low, we need either to extend the
++ * transaction or to start a new one. Reserve enough space here for
++ * inode, bitmap, superblock, group and indirection updates for at least
++ * one block, plus two quota updates. Quota allocations are not
++ * needed. */
++
++#define EXT3COW_RESERVE_TRANS_BLOCKS 12U
++
++#define EXT3COW_INDEX_EXTRA_TRANS_BLOCKS 8
++
++#ifdef CONFIG_QUOTA
++/* Amount of blocks needed for quota update - we know that the structure was
++ * allocated so we need to update only inode+data */
++#define EXT3COW_QUOTA_TRANS_BLOCKS(sb) (test_opt(sb, QUOTA) ? 2 : 0)
++/* Amount of blocks needed for quota insert/delete - we do some block writes
++ * but inode, sb and group updates are done only once */
++#define EXT3COW_QUOTA_INIT_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_INIT_ALLOC*\
++ (EXT3COW_SINGLEDATA_TRANS_BLOCKS-3)+3+DQUOT_INIT_REWRITE) : 0)
++#define EXT3COW_QUOTA_DEL_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_DEL_ALLOC*\
++ (EXT3COW_SINGLEDATA_TRANS_BLOCKS-3)+3+DQUOT_DEL_REWRITE) : 0)
++#else
++#define EXT3COW_QUOTA_TRANS_BLOCKS(sb) 0
++#define EXT3COW_QUOTA_INIT_BLOCKS(sb) 0
++#define EXT3COW_QUOTA_DEL_BLOCKS(sb) 0
++#endif
++
++int
++ext3cow_mark_iloc_dirty(handle_t *handle,
++ struct inode *inode,
++ struct ext3cow_iloc *iloc);
++
++/*
++ * On success, We end up with an outstanding reference count against
++ * iloc->bh. This _must_ be cleaned up later.
++ */
++
++int ext3cow_reserve_inode_write(handle_t *handle, struct inode *inode,
++ struct ext3cow_iloc *iloc);
++
++int ext3cow_mark_inode_dirty(handle_t *handle, struct inode *inode);
++
++/*
++ * Wrapper functions with which ext3cow calls into JBD. The intent here is
++ * to allow these to be turned into appropriate stubs so ext3cow can control
++ * ext2 filesystems, so ext2+ext3cow systems only nee one fs. This work hasn't
++ * been done yet.
++ */
++
++static inline void ext3cow_journal_release_buffer(handle_t *handle,
++ struct buffer_head *bh)
++{
++ journal_release_buffer(handle, bh);
++}
++
++void ext3cow_journal_abort_handle(const char *caller, const char *err_fn,
++ struct buffer_head *bh, handle_t *handle, int err);
++
++int __ext3cow_journal_get_undo_access(const char *where, handle_t *handle,
++ struct buffer_head *bh);
++
++int __ext3cow_journal_get_write_access(const char *where, handle_t *handle,
++ struct buffer_head *bh);
++
++int __ext3cow_journal_forget(const char *where, handle_t *handle,
++ struct buffer_head *bh);
++
++int __ext3cow_journal_revoke(const char *where, handle_t *handle,
++ unsigned long blocknr, struct buffer_head *bh);
++
++int __ext3cow_journal_get_create_access(const char *where,
++ handle_t *handle, struct buffer_head *bh);
++
++int __ext3cow_journal_dirty_metadata(const char *where,
++ handle_t *handle, struct buffer_head *bh);
++
++#define ext3cow_journal_get_undo_access(handle, bh) \
++ __ext3cow_journal_get_undo_access(__FUNCTION__, (handle), (bh))
++#define ext3cow_journal_get_write_access(handle, bh) \
++ __ext3cow_journal_get_write_access(__FUNCTION__, (handle), (bh))
++#define ext3cow_journal_revoke(handle, blocknr, bh) \
++ __ext3cow_journal_revoke(__FUNCTION__, (handle), (blocknr), (bh))
++#define ext3cow_journal_get_create_access(handle, bh) \
++ __ext3cow_journal_get_create_access(__FUNCTION__, (handle), (bh))
++#define ext3cow_journal_dirty_metadata(handle, bh) \
++ __ext3cow_journal_dirty_metadata(__FUNCTION__, (handle), (bh))
++#define ext3cow_journal_forget(handle, bh) \
++ __ext3cow_journal_forget(__FUNCTION__, (handle), (bh))
++
++int ext3cow_journal_dirty_data(handle_t *handle, struct buffer_head *bh);
++
++handle_t *ext3cow_journal_start_sb(struct super_block *sb, int nblocks);
++int __ext3cow_journal_stop(const char *where, handle_t *handle);
++
++static inline handle_t *ext3cow_journal_start(struct inode *inode, int nblocks)
++{
++ return ext3cow_journal_start_sb(inode->i_sb, nblocks);
++}
++
++#define ext3cow_journal_stop(handle) \
++ __ext3cow_journal_stop(__FUNCTION__, (handle))
++
++static inline handle_t *ext3cow_journal_current_handle(void)
++{
++ return journal_current_handle();
++}
++
++static inline int ext3cow_journal_extend(handle_t *handle, int nblocks)
++{
++ return journal_extend(handle, nblocks);
++}
++
++static inline int ext3cow_journal_restart(handle_t *handle, int nblocks)
++{
++ return journal_restart(handle, nblocks);
++}
++
++static inline int ext3cow_journal_blocks_per_page(struct inode *inode)
++{
++ return journal_blocks_per_page(inode);
++}
++
++static inline int ext3cow_journal_force_commit(journal_t *journal)
++{
++ return journal_force_commit(journal);
++}
++
++/* super.c */
++int ext3cow_force_commit(struct super_block *sb);
++
++static inline int ext3cow_should_journal_data(struct inode *inode)
++{
++ if (!S_ISREG(inode->i_mode))
++ return 1;
++ if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3COW_MOUNT_JOURNAL_DATA)
++ return 1;
++ if (EXT3COW_I(inode)->i_flags & EXT3COW_JOURNAL_DATA_FL)
++ return 1;
++ return 0;
++}
++
++static inline int ext3cow_should_order_data(struct inode *inode)
++{
++ if (!S_ISREG(inode->i_mode))
++ return 0;
++ if (EXT3COW_I(inode)->i_flags & EXT3COW_JOURNAL_DATA_FL)
++ return 0;
++ if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3COW_MOUNT_ORDERED_DATA)
++ return 1;
++ return 0;
++}
++
++static inline int ext3cow_should_writeback_data(struct inode *inode)
++{
++ if (!S_ISREG(inode->i_mode))
++ return 0;
++ if (EXT3COW_I(inode)->i_flags & EXT3COW_JOURNAL_DATA_FL)
++ return 0;
++ if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3COW_MOUNT_WRITEBACK_DATA)
++ return 1;
++ return 0;
++}
++
++#endif /* _LINUX_EXT3COW_JBD_H */
+diff -ruN linux-2.6.20.3/include/linux/magic.h linux-2.6.20.3-ext3cow/include/linux/magic.h
+--- linux-2.6.20.3/include/linux/magic.h 2007-03-13 14:27:08.000000000 -0400
++++ linux-2.6.20.3-ext3cow/include/linux/magic.h 2007-03-24 14:06:39.000000000 -0400
+@@ -9,6 +9,7 @@
+ #define EFS_SUPER_MAGIC 0x414A53
+ #define EXT2_SUPER_MAGIC 0xEF53
+ #define EXT3_SUPER_MAGIC 0xEF53
++#define EXT3COW_SUPER_MAGIC 0xEF53
+ #define EXT4_SUPER_MAGIC 0xEF53
+ #define HPFS_SUPER_MAGIC 0xf995e849
+ #define ISOFS_SUPER_MAGIC 0x9660
+