[PATCH 1/9] Amiga SmartFileSystem, revision 2

[Pavel Fedin <sonic.amiga@gmail.com>]

diff -ruN linux-source-2.6.24.orig/Documentation/filesystems/00-INDEX linux-source-2.6.24/Documentation/filesystems/00-INDEX
--- linux-source-2.6.24.orig/Documentation/filesystems/00-INDEX 2008-01-25 01:58:37.000000000 +0300
+++ linux-source-2.6.24/Documentation/filesystems/00-INDEX      2008-12-14 23:05:04.000000000 +0300
@@ -12,6 +12,8 @@
        - info and examples for the distributed AFS (Andrew File System) fs.
 affs.txt
        - info and mount options for the Amiga Fast File System.
+asfs.txt
+       - info and mount options for the Amiga Smart File System.
 automount-support.txt
        - information about filesystem automount support.
 befs.txt
diff -ruN linux-source-2.6.24.orig/Documentation/filesystems/asfs.txt linux-source-2.6.24/Documentation/filesystems/asfs.txt
--- linux-source-2.6.24.orig/Documentation/filesystems/asfs.txt 1970-01-01 03:00:00.000000000 +0300
+++ linux-source-2.6.24/Documentation/filesystems/asfs.txt      2008-12-14 23:05:04.000000000 +0300
@@ -0,0 +1,161 @@
+
+Amiga SmartFileSystem, Linux implementation
+===========================================
+
+ASFS is a Amiga Smart FileSystem driver for Linux. It supports reading
+files and directories. From version 1.0 there is also an experimental 
+(almost full) write support. Experimental means that it hasn't been 
+tested enough yet, so use it with care. Symbolic links (in AmigaOS
+called soft links) are also supported read/write. Read notes below 
+about symlinks support.
+
+
+Unsupported features of Amiga SFS
+================================
+
+ASFS currently does not support safe-delete feature of Amiga SFS 
+filesystem. It simply deletes files instead of moving them to 
+".recycled" directory. It also doesn't remove files from ".recycled" 
+directory, when there is no space left on drive. 
+
+If there is no space left, you need to manually remove files from 
+".recycled" directory. Also if you want to delete a file in a safe 
+way, you need to move it to ".recycled" directory by hand.
+
+Because of all of above, the amount of free space on disk does not 
+include space used by all files from ".recycled" directory.
+
+
+Limitations
+===========
+
+There is no Amiga protection bits into Linux permission bits tranlation
+and vice versa. If you need this feature, mail me.
+
+ASFS will always keep some amount of blocks free. This means that you 
+cannot fill the drive completely. It is because Amiga SFS uses some 
+special methods of writing data (called safe write), which needs some
+additional free space.
+
+File systems with unfinished transactions (this happens when system crashed
+during writing data to disk on AmigaOS/MorphOS) will be mounted read-only
+to protect data. The only way to fix such filesystem is to mount it under
+AmigaOS or MorphOS.
+
+Do not try to mount and write to filesystem with errors. Bad things will
+happen.
+
+
+Mount options for the ASFS
+==========================
+
+setuid=uid     
+               This sets the owner of all files and directories in the file
+               system to uid.
+
+setgid=gid     
+               Same as above, but for gid.
+
+mode=mode      
+               Sets the mode flags to the given (octal) value. Directories 
+               will get an x permission if the corresponding r bit is set.
+               The default mode is 0644, which means that everybody are allowed 
+               to read files, but only root can write to them.
+               (for directories this means also that search bits are set).
+
+prefix=path    
+               Path will be prefixed to every absolute path name of symbolic 
+               links on an ASFS/AFFS partition. Default = "/". (See below.)
+
+volume=name
+               When symbolic links with an absolute path are created
+               on an ASFS/AFFS partition, name will be prepended as the
+               volume name. Default = "" (empty string). (See below.)
+
+lowercasevol
+               Translate all volume names in symlinks to lower case.
+               Disabled by default. (See below.)
+
+iocharset=name
+               Character set to use for converting file names. Specifies 
+               character set used by your Linux system. 
+codepage=name
+               Set the codepage number for converting file names. Specifies
+               character set used by your Amiga. Use full name (for example
+               'cp1251' instead of '1251') here, this allows to specify any
+               character set, not only numbered one (like 'iso8859-2').
+               Use special name 'none' to disable the NLS file name 
+               translation.
+
+Symbolic links
+==============
+
+Although the Amiga and Linux file systems resemble each other, there
+are some, not always subtle, differences. One of them becomes apparent
+with symbolic links. While Linux has a file system with exactly one
+root directory, the Amiga has a separate root directory for each
+file system (for example, partition, floppy disk, ...). With the Amiga,
+these entities are called "volumes". They have symbolic names which
+can be used to access them. Thus, symbolic links can point to a
+different volume. ASFS turns the volume name into a directory name
+and prepends the prefix path (see prefix option) to it. When option
+"lowercasevol" is set, it also translates volume names to lower case.
+If the volume name is the same as a name given in "volume" option,
+it will be ignored and an absolute path will be created.
+
+Example:
+You mount all your Amiga partitions under /amiga/<volume> (where
+<volume> is the name of the volume), and you give options
+`prefix="/amiga/",volume="Linux",lowercasevol' when mounting all your 
+ASFS partitions. (They might be "User", "WB" and "Graphics", the mount 
+points /amiga/user, /amiga/wb and /amiga/graphics). 
+
+A symbolic link referring to "USER:sc/include/dos/dos.h" will be 
+translated to "/amiga/user/sc/include/dos/dos.h".
+A symbolic link referring to "Linux:etc/fstab" will be translated to
+"/etc/fstab".
+If you create a symlink referring to "/amiga/graphics/data/pict.jpg",
+it will be saved as "graphics:data/pict.jpg".
+If you create a symlink referring to "/boot/System.map", it will be 
+saved as "Linux:boot/System.map".
+
+
+Other information
+=================
+
+Supported block sizes are: 512, 1024, 2048 and 4096 bytes. Larger blocks
+speed up almost everything at the expense of wasted disk space. The speed
+gain above 4K seems not really worth the price, so you don't lose too
+much here, either.
+
+This file system has been tested on Motorola PPC and 68k, as well as 
+Intel x86 systems. I don't know, if it works on other Linux systems.
+
+This filesystem is in BETA STAGE. This means that driver MIGHT corrupt
+or damage data on your disk. Remember! YOU USE IT ON YOUR OWN RISK! 
+
+I made almost all I could to minimalize this risk. On my systems several 
+gigabytes has been succesfully copied from and to SFS disks. I would also 
+appreciate any infomation if this filesystem works on your system or not. 
+See next paragraph for my email.
+
+Some parts of this documentation has been adapted from AFFS driver docs.
+
+
+Author, contact and copyright infos
+===================================
+
+ASFS has been written by Marek 'March' Szyprowski <marek@amiga.pl>.
+Mail me if you have any suggestions or found a bug.
+
+Copyright (C) 2003,2004,2005  Marek 'March' Szyprowski <marek@amiga.pl>
+
+Thanks to Marcin Kurek (Morgoth/Dreamolers-CAPS) for help and parts 
+of original amiga version of SmartFilesystem source code. 
+
+SmartFilesystem is copyrighted (C) 2003,2004 by: John Hendrikx, 
+Ralph Schmidt, Emmanuel Lesueur, David Gerber and Marcin Kurek
+
+The ASFS driver is realased under the terms of of the GNU General 
+Public License. See source code for more details.
+
diff -ruN linux-source-2.6.24.orig/fs/asfs/adminspace.c linux-source-2.6.24/fs/asfs/adminspace.c
--- linux-source-2.6.24.orig/fs/asfs/adminspace.c       1970-01-01 03:00:00.000000000 +0300
+++ linux-source-2.6.24/fs/asfs/adminspace.c    2008-12-14 23:05:05.000000000 +0300
@@ -0,0 +1,446 @@
+/*
+ *
+ * Amiga Smart File System, Linux implementation
+ * version: 1.0beta7
+ *
+ * This file contains some parts of the original amiga version of 
+ * SmartFilesystem source code.
+ *
+ * SmartFilesystem is copyrighted (C) 2003 by: John Hendrikx, 
+ * Ralph Schmidt, Emmanuel Lesueur, David Gerber, and Marcin Kurek
+ * 
+ * Adapted and modified by Marek 'March' Szyprowski <marek@amiga.pl>
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/buffer_head.h>
+#include <linux/vfs.h>
+#include "asfs_fs.h"
+#include "bitfuncs.h"
+
+#include <asm/byteorder.h>
+
+#ifdef CONFIG_ASFS_RW
+
+static int setfreeblocks(struct super_block *sb, u32 freeblocks)
+{
+       struct buffer_head *bh;
+       if ((bh = asfs_breadcheck(sb, ASFS_SB(sb)->rootobjectcontainer, ASFS_OBJECTCONTAINER_ID))) {
+               struct fsRootInfo *ri = (struct fsRootInfo *) ((u8 *) bh->b_data + sb->s_blocksize - sizeof(struct fsRootInfo));
+               ASFS_SB(sb)->freeblocks = freeblocks;
+               ri->freeblocks = cpu_to_be32(freeblocks);
+               asfs_bstore(sb, bh);
+               asfs_brelse(bh);
+               return 0;
+       }
+       return -EIO;
+}
+
+static inline int enoughspace(struct super_block *sb, u32 blocks)
+{
+       if (ASFS_SB(sb)->freeblocks - ASFS_ALWAYSFREE < blocks)
+               return FALSE;
+
+       return TRUE;
+}
+
+       /* Determines the amount of free blocks starting from block /block/.
+          If there are no blocks found or if there was an error -1 is returned,
+          otherwise this function will count the number of free blocks until
+          an allocated block is encountered or until maxneeded has been
+          exceeded. */
+
+static int availablespace(struct super_block *sb, u32 block, u32 maxneeded)
+{
+       struct buffer_head *bh = NULL;
+       struct fsBitmap *b;
+       u32 longs = ASFS_SB(sb)->blocks_inbitmap >> 5;
+       u32 maxbitmapblock = ASFS_SB(sb)->bitmapbase + ASFS_SB(sb)->blocks_bitmap;
+       int blocksfound = 0;
+       u32 bitstart;
+       int bitend;
+       u32 nextblock = ASFS_SB(sb)->bitmapbase + block / ASFS_SB(sb)->blocks_inbitmap;
+
+       bitstart = block % ASFS_SB(sb)->blocks_inbitmap;
+
+       while (nextblock < maxbitmapblock && (bh = asfs_breadcheck(sb, nextblock++, ASFS_BITMAP_ID))) {
+               b = (void *) bh->b_data;
+
+               if ((bitend = bmffz(b->bitmap, longs, bitstart)) >= 0) {
+                       blocksfound += bitend - bitstart;
+                       asfs_brelse(bh);
+                       return blocksfound;
+               }
+               blocksfound += ASFS_SB(sb)->blocks_inbitmap - bitstart;
+               if (blocksfound >= maxneeded) {
+                       asfs_brelse(bh);
+                       return blocksfound;
+               }
+               bitstart = 0;
+               asfs_brelse(bh);
+       }
+
+       if (bh == NULL)
+               return (-1);
+
+       return (blocksfound);
+}
+
+int asfs_findspace(struct super_block *sb, u32 maxneeded, u32 start, u32 end, u32 * returned_block, u32 * returned_blocks)
+{
+       struct buffer_head *bh;
+       u32 longs = ASFS_SB(sb)->blocks_inbitmap >> 5;
+       u32 space = 0;
+       u32 block;
+       u32 bitmapblock = ASFS_SB(sb)->bitmapbase + start / ASFS_SB(sb)->blocks_inbitmap;
+       u32 breakpoint;
+       int bitstart, bitend;
+       int reads;
+
+       if (enoughspace(sb, maxneeded) == FALSE) {
+               *returned_block = 0;
+               *returned_blocks = 0;
+               return -ENOSPC;
+       }
+
+       if (start >= ASFS_SB(sb)->totalblocks)
+               start -= ASFS_SB(sb)->totalblocks;
+
+       if (end == 0)
+               end = ASFS_SB(sb)->totalblocks;
+
+       reads = ((end - 1) / ASFS_SB(sb)->blocks_inbitmap) + 1 - start / ASFS_SB(sb)->blocks_inbitmap;
+
+       if (start >= end)
+               reads += (ASFS_SB(sb)->totalblocks - 1) / ASFS_SB(sb)->blocks_inbitmap + 1;
+
+       breakpoint = (start < end ? end : ASFS_SB(sb)->totalblocks);
+
+       *returned_block = 0;
+       *returned_blocks = 0;
+
+       bitend = start % ASFS_SB(sb)->blocks_inbitmap;
+       block = start - bitend;
+
+       while ((bh = asfs_breadcheck(sb, bitmapblock++, ASFS_BITMAP_ID))) {
+               struct fsBitmap *b = (void *) bh->b_data;
+               u32 localbreakpoint = breakpoint - block;
+
+               if (localbreakpoint > ASFS_SB(sb)->blocks_inbitmap)
+                       localbreakpoint = ASFS_SB(sb)->blocks_inbitmap;
+
+               /* At this point space contains the amount of free blocks at
+                  the end of the previous bitmap block.  If there are no
+                  free blocks at the start of this bitmap block, space will
+                  be set to zero, since in that case the space isn't adjacent. */
+
+               while ((bitstart = bmffo(b->bitmap, longs, bitend)) < ASFS_SB(sb)->blocks_inbitmap) {
+                       /* found the start of an empty space, now find out how large it is */
+
+                       if (bitstart >= localbreakpoint)
+                               break;
+
+                       if (bitstart != 0)
+                               space = 0;
+
+                       bitend = bmffz(b->bitmap, longs, bitstart);
+
+                       if (bitend > localbreakpoint)
+                               bitend = localbreakpoint;
+
+                       space += bitend - bitstart;
+
+                       if (*returned_blocks < space) {
+                               *returned_block = block + bitend - space;
+                               if (space >= maxneeded) {
+                                       *returned_blocks = maxneeded;
+                                       asfs_brelse(bh);
+                                       return 0;
+                               }
+                               *returned_blocks = space;
+                       }
+
+                       if (bitend >= localbreakpoint)
+                               break;
+               }
+
+               if (--reads == 0)
+                       break;
+
+               /* no (more) empty spaces found in this block */
+
+               if (bitend != ASFS_SB(sb)->blocks_inbitmap)
+                       space = 0;
+
+               bitend = 0;
+               block += ASFS_SB(sb)->blocks_inbitmap;
+
+               if (block >= ASFS_SB(sb)->totalblocks) {
+                       block = 0;
+                       space = 0;
+                       breakpoint = end;
+                       bitmapblock = ASFS_SB(sb)->bitmapbase;
+               }
+               asfs_brelse(bh);
+       }
+
+       if (bh == NULL)
+               return -EIO;
+
+       asfs_brelse(bh);
+
+       if (*returned_blocks == 0)
+               return -ENOSPC;
+       else
+               return 0;
+}
+
+int asfs_markspace(struct super_block *sb, u32 block, u32 blocks)
+{
+       int errorcode;
+
+       asfs_debug("markspace: Marking %d blocks from block %d\n", blocks, block);
+
+       if ((availablespace(sb, block, blocks)) < blocks) {
+               printk("ASFS: Attempted to mark %d blocks from block %d, but some of them were already full!\n", blocks, block);
+               return -EIO;
+       }
+
+       if ((errorcode = setfreeblocks(sb, ASFS_SB(sb)->freeblocks - blocks)) == 0) {
+               struct buffer_head *bh;
+               u32 skipblocks = block / ASFS_SB(sb)->blocks_inbitmap;
+               u32 longs = (sb->s_blocksize - sizeof(struct fsBitmap)) >> 2;
+               u32 bitmapblock;
+
+               block -= skipblocks * ASFS_SB(sb)->blocks_inbitmap;
+               bitmapblock = ASFS_SB(sb)->bitmapbase + skipblocks;
+
+               while (blocks > 0) {
+                       if ((bh = asfs_breadcheck(sb, bitmapblock++, ASFS_BITMAP_ID))) {
+                               struct fsBitmap *b = (void *) bh->b_data;
+
+                               blocks -= bmclr(b->bitmap, longs, block, blocks);
+                               block = 0;
+
+                               asfs_bstore(sb, bh);
+                               asfs_brelse(bh);
+                       } else
+                               return -EIO;
+               }
+       }
+
+       return (errorcode);
+}
+
+       /* This function checks the bitmap and tries to locate at least /blocksneeded/
+          adjacent unused blocks.  If found it sets returned_block to the start block
+          and returns no error.  If not found, ERROR_DISK_IS_FULL is returned and
+          returned_block is set to zero.  Any other errors are returned as well. */
+
+static inline int internalfindspace(struct super_block *sb, u32 blocksneeded, u32 startblock, u32 endblock, u32 * returned_block)
+{
+       u32 blocks;
+       int errorcode;
+
+       if ((errorcode = asfs_findspace(sb, blocksneeded, startblock, endblock, returned_block, &blocks)) == 0)
+               if (blocks != blocksneeded)
+                       return -ENOSPC;
+
+       return errorcode;
+}
+
+static int findandmarkspace(struct super_block *sb, u32 blocksneeded, u32 * returned_block)
+{
+       int errorcode;
+
+       if (enoughspace(sb, blocksneeded) != FALSE) {
+               if ((errorcode = internalfindspace(sb, blocksneeded, 0, ASFS_SB(sb)->totalblocks, returned_block)) == 0)
+                       errorcode = asfs_markspace(sb, *returned_block, blocksneeded);
+       } else
+               errorcode = -ENOSPC;
+
+       return (errorcode);
+}
+
+/* ************************** */
+
+int asfs_freespace(struct super_block *sb, u32 block, u32 blocks)
+{
+       int errorcode;
+
+       asfs_debug("freespace: Freeing %d blocks from block %d\n", blocks, block);
+
+       if ((errorcode = setfreeblocks(sb, ASFS_SB(sb)->freeblocks + blocks)) == 0) {
+               struct buffer_head *bh;
+               u32 skipblocks = block / ASFS_SB(sb)->blocks_inbitmap;
+               u32 longs = (sb->s_blocksize - sizeof(struct fsBitmap)) >> 2;
+               u32 bitmapblock;
+
+               block -= skipblocks * ASFS_SB(sb)->blocks_inbitmap;
+               bitmapblock = ASFS_SB(sb)->bitmapbase + skipblocks;
+
+               while (blocks > 0) {
+                       if ((bh = asfs_breadcheck(sb, bitmapblock++, ASFS_BITMAP_ID))) {
+                               struct fsBitmap *b = (void *) bh->b_data;
+
+                               blocks -= bmset(b->bitmap, longs, block, blocks);
+                               block = 0;
+
+                               asfs_bstore(sb, bh);
+                               asfs_brelse(bh);
+                       } else
+                               return -EIO;
+               }
+       }
+
+       return (errorcode);
+}
+
+/*************** admin space containers ****************/
+
+int asfs_allocadminspace(struct super_block *sb, u32 *returned_block)
+{
+       struct buffer_head *bh;
+       u32 adminspaceblock = ASFS_SB(sb)->adminspacecontainer;
+       int errorcode = -EIO;
+
+       asfs_debug("allocadminspace: allocating new block\n");
+
+       while ((bh = asfs_breadcheck(sb, adminspaceblock, ASFS_ADMINSPACECONTAINER_ID))) {
+               struct fsAdminSpaceContainer *asc1 = (void *) bh->b_data;
+               struct fsAdminSpace *as1 = asc1->adminspace;
+               int adminspaces1 = (sb->s_blocksize - sizeof(struct fsAdminSpaceContainer)) / sizeof(struct fsAdminSpace);
+
+               while (adminspaces1-- > 0) {
+                       s16 bitoffset;
+
+                       if (as1->space != 0 && (bitoffset = bfffz(be32_to_cpu(as1->bits), 0)) >= 0) {
+                               u32 emptyadminblock = be32_to_cpu(as1->space) + bitoffset;
+                               as1->bits |= cpu_to_be32(1 << (31 - bitoffset));
+                               asfs_bstore(sb, bh);
+                               *returned_block = emptyadminblock;
+                               asfs_brelse(bh);
+                               asfs_debug("allocadminspace: found block %d\n", *returned_block);
+                               return 0;
+                       }
+                       as1++;
+               }
+
+               adminspaceblock = be32_to_cpu(asc1->next);
+               asfs_brelse(bh);
+
+               if (adminspaceblock == 0) {
+                       u32 startblock;
+
+                       asfs_debug("allocadminspace: allocating new adminspace area\n");
+
+                       /* If we get here it means current adminspace areas are all filled.
+                          We would now need to find a new area and create a fsAdminSpace
+                          structure in one of the AdminSpaceContainer blocks.  If these
+                          don't have any room left for new adminspace areas a new
+                          AdminSpaceContainer would have to be created first which is
+                          placed as the first block in the newly found admin area. */
+
+                       adminspaceblock = ASFS_SB(sb)->adminspacecontainer;
+
+                       if ((errorcode = findandmarkspace(sb, 32, &startblock)))
+                               return errorcode;
+
+                       while ((bh = asfs_breadcheck(sb, adminspaceblock, ASFS_ADMINSPACECONTAINER_ID))) {
+                               struct fsAdminSpaceContainer *asc2 = (void *) bh->b_data;
+                               struct fsAdminSpace *as2 = asc2->adminspace;
+                               int adminspaces2 = (sb->s_blocksize - sizeof(struct fsAdminSpaceContainer)) / sizeof(struct fsAdminSpace);
+
+                               while (adminspaces2-- > 0 && as2->space != 0)
+                                       as2++;
+
+                               if (adminspaces2 >= 0) {        /* Found a unused AdminSpace in this AdminSpaceContainer! */
+                                       as2->space = cpu_to_be32(startblock);
+                                       as2->bits = 0;
+                                       asfs_bstore(sb, bh);
+                                       asfs_brelse(bh);
+                                       break;
+                               }
+
+                               if (asc2->next == 0) {
+                                       /* Oh-oh... we marked our new adminspace area in use, but we couldn't
+                                          find space to store a fsAdminSpace structure in the existing
+                                          fsAdminSpaceContainer blocks.  This means we need to create and
+                                          link a new fsAdminSpaceContainer as the first block in our newly
+                                          marked adminspace. */
+
+                                       asc2->next = cpu_to_be32(startblock);
+                                       asfs_bstore(sb, bh);
+                                       asfs_brelse(bh);
+
+                                       /* Now preparing new AdminSpaceContainer */
+
+                                       if ((bh = asfs_getzeroblk(sb, startblock)) == NULL)
+                                               return -EIO;
+
+                                       asc2 = (void *) bh->b_data;
+                                       asc2->bheader.id = cpu_to_be32(ASFS_ADMINSPACECONTAINER_ID);
+                                       asc2->bheader.ownblock = cpu_to_be32(startblock);
+                                       asc2->previous = cpu_to_be32(adminspaceblock);
+                                       asc2->adminspace[0].space = cpu_to_be32(startblock);
+                                       asc2->adminspace[0].bits = cpu_to_be32(0x80000000);
+                                       asc2->bits = 32;
+
+                                       asfs_bstore(sb, bh);
+                                       asfs_brelse(bh);
+
+                                       adminspaceblock = startblock;
+                                       break;  /* Breaks through to outer loop! */
+                               }
+                               adminspaceblock = be32_to_cpu(asc2->next);
+                               asfs_brelse(bh);
+                       }
+               }
+       }
+       return errorcode;
+}
+
+int asfs_freeadminspace(struct super_block *sb, u32 block)
+{
+       struct buffer_head *bh;
+       u32 adminspaceblock = ASFS_SB(sb)->adminspacecontainer;
+
+       asfs_debug("freeadminspace: Entry -- freeing block %d\n", block);
+
+       while ((bh = asfs_breadcheck(sb, adminspaceblock, ASFS_ADMINSPACECONTAINER_ID))) {
+               struct fsAdminSpaceContainer *asc = (void *) bh->b_data;
+               struct fsAdminSpace *as = asc->adminspace;
+               int adminspaces = (sb->s_blocksize - sizeof(struct fsAdminSpaceContainer)) / sizeof(struct fsAdminSpace);
+
+               while (adminspaces-- > 0) {
+                       if (block >= be32_to_cpu(as->space) && block < be32_to_cpu(as->space) + 32) {
+                               s16 bitoffset = block - be32_to_cpu(as->space);
+                               asfs_debug("freeadminspace: Block to be freed is located in AdminSpaceContainer block at %d\n", adminspaceblock);
+                               as->bits &= cpu_to_be32(~(1 << (31 - bitoffset)));
+                               asfs_bstore(sb, bh);
+                               asfs_brelse(bh);
+                               return 0;
+                       }
+                       as++;
+               }
+
+               if ((adminspaceblock = be32_to_cpu(asc->next)) == 0)
+                       break;
+
+               asfs_brelse(bh);
+       }
+
+       if (bh != NULL) {
+               asfs_brelse(bh);
+               printk("ASFS: Unable to free an administration block. The block cannot be found.");
+               return -ENOENT;
+       }
+
+       return -EIO;
+}
+
+#endif