Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 795 insertions, 0 deletions

diff --git a/fs/jffs/jffs_fm.c b/fs/jffs/jffs_fm.c
new file mode 100644
index 000000000000..0cab8da49d3c
--- /dev/null
+++ b/fs/jffs/jffs_fm.c
@@ -0,0 +1,795 @@
+/*
+ * JFFS -- Journaling Flash File System, Linux implementation.
+ *
+ * Copyright (C) 1999, 2000  Axis Communications AB.
+ *
+ * Created by Finn Hakansson <finn@axis.com>.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * $Id: jffs_fm.c,v 1.27 2001/09/20 12:29:47 dwmw2 Exp $
+ *
+ * Ported to Linux 2.3.x and MTD:
+ * Copyright (C) 2000  Alexander Larsson (alex@cendio.se), Cendio Systems AB
+ *
+ */
+#include <linux/slab.h>
+#include <linux/blkdev.h>
+#include <linux/jffs.h>
+#include "jffs_fm.h"
+
+#if defined(JFFS_MARK_OBSOLETE) && JFFS_MARK_OBSOLETE
+static int jffs_mark_obsolete(struct jffs_fmcontrol *fmc, __u32 fm_offset);
+#endif
+
+static struct jffs_fm *jffs_alloc_fm(void);
+static void jffs_free_fm(struct jffs_fm *n);
+
+extern kmem_cache_t     *fm_cache;
+extern kmem_cache_t     *node_cache;
+
+/* This function creates a new shiny flash memory control structure.  */
+struct jffs_fmcontrol *
+jffs_build_begin(struct jffs_control *c, int unit)
+{
+        struct jffs_fmcontrol *fmc;
+        struct mtd_info *mtd;
+        
+        D3(printk("jffs_build_begin()\n"));
+        fmc = (struct jffs_fmcontrol *)kmalloc(sizeof(struct jffs_fmcontrol),
+                                               GFP_KERNEL);
+        if (!fmc) {
+                D(printk("jffs_build_begin(): Allocation of "
+                         "struct jffs_fmcontrol failed!\n"));
+                return (struct jffs_fmcontrol *)0;
+        }
+        DJM(no_jffs_fmcontrol++);
+
+        mtd = get_mtd_device(NULL, unit);
+
+        if (!mtd) {
+                kfree(fmc);
+                DJM(no_jffs_fmcontrol--);
+                return NULL;
+        }
+        
+        /* Retrieve the size of the flash memory.  */
+        fmc->flash_size = mtd->size;
+        D3(printk("  fmc->flash_size = %d bytes\n", fmc->flash_size));
+
+        fmc->used_size = 0;
+        fmc->dirty_size = 0;
+        fmc->free_size = mtd->size;
+        fmc->sector_size = mtd->erasesize;
+        fmc->max_chunk_size = fmc->sector_size >> 1;
+        /* min_free_size:
+           1 sector, obviously.
+           + 1 x max_chunk_size, for when a nodes overlaps the end of a sector
+           + 1 x max_chunk_size again, which ought to be enough to handle 
+                   the case where a rename causes a name to grow, and GC has
+                   to write out larger nodes than the ones it's obsoleting.
+                   We should fix it so it doesn't have to write the name
+                   _every_ time. Later.
+           + another 2 sectors because people keep getting GC stuck and
+                   we don't know why. This scares me - I want formal proof
+                   of correctness of whatever number we put here. dwmw2.
+        */
+        fmc->min_free_size = fmc->sector_size << 2;
+        fmc->mtd = mtd;
+        fmc->c = c;
+        fmc->head = NULL;
+        fmc->tail = NULL;
+        fmc->head_extra = NULL;
+        fmc->tail_extra = NULL;
+        init_MUTEX(&fmc->biglock);
+        return fmc;
+}
+
+
+/* When the flash memory scan has completed, this function should be called
+   before use of the control structure.  */
+void
+jffs_build_end(struct jffs_fmcontrol *fmc)
+{
+        D3(printk("jffs_build_end()\n"));
+
+        if (!fmc->head) {
+                fmc->head = fmc->head_extra;
+                fmc->tail = fmc->tail_extra;
+        }
+        else if (fmc->head_extra) {
+                fmc->tail_extra->next = fmc->head;
+                fmc->head->prev = fmc->tail_extra;
+                fmc->head = fmc->head_extra;
+        }
+        fmc->head_extra = NULL; /* These two instructions should be omitted.  */
+        fmc->tail_extra = NULL;
+        D3(jffs_print_fmcontrol(fmc));
+}
+
+
+/* Call this function when the file system is unmounted.  This function
+   frees all memory used by this module.  */
+void
+jffs_cleanup_fmcontrol(struct jffs_fmcontrol *fmc)
+{
+        if (fmc) {
+                struct jffs_fm *next = fmc->head;
+                while (next) {
+                        struct jffs_fm *cur = next;
+                        next = next->next;
+                        jffs_free_fm(cur);
+                }
+                put_mtd_device(fmc->mtd);
+                kfree(fmc);
+                DJM(no_jffs_fmcontrol--);
+        }
+}
+
+
+/* This function returns the size of the first chunk of free space on the
+   flash memory.  This function will return something nonzero if the flash
+   memory contains any free space.  */
+__u32
+jffs_free_size1(struct jffs_fmcontrol *fmc)
+{
+        __u32 head;
+        __u32 tail;
+        __u32 end = fmc->flash_size;
+
+        if (!fmc->head) {
+                /* There is nothing on the flash.  */
+                return fmc->flash_size;
+        }
+
+        /* Compute the beginning and ending of the contents of the flash.  */
+        head = fmc->head->offset;
+        tail = fmc->tail->offset + fmc->tail->size;
+        if (tail == end) {
+                tail = 0;
+        }
+        ASSERT(else if (tail > end) {
+                printk(KERN_WARNING "jffs_free_size1(): tail > end\n");
+                tail = 0;
+        });
+
+        if (head <= tail) {
+                return end - tail;
+        }
+        else {
+                return head - tail;
+        }
+}
+
+/* This function will return something nonzero in case there are two free
+   areas on the flash.  Like this:
+
+     +----------------+------------------+----------------+
+     |     FREE 1     |   USED / DIRTY   |     FREE 2     |
+     +----------------+------------------+----------------+
+       fmc->head -----^
+       fmc->tail ------------------------^
+
+   The value returned, will be the size of the first empty area on the
+   flash, in this case marked "FREE 1".  */
+__u32
+jffs_free_size2(struct jffs_fmcontrol *fmc)
+{
+        if (fmc->head) {
+                __u32 head = fmc->head->offset;
+                __u32 tail = fmc->tail->offset + fmc->tail->size;
+                if (tail == fmc->flash_size) {
+                        tail = 0;
+                }
+
+                if (tail >= head) {
+                        return head;
+                }
+        }
+        return 0;
+}
+
+
+/* Allocate a chunk of flash memory.  If there is enough space on the
+   device, a reference to the associated node is stored in the jffs_fm
+   struct.  */
+int
+jffs_fmalloc(struct jffs_fmcontrol *fmc, __u32 size, struct jffs_node *node,
+             struct jffs_fm **result)
+{
+        struct jffs_fm *fm;
+        __u32 free_chunk_size1;
+        __u32 free_chunk_size2;
+
+        D2(printk("jffs_fmalloc(): fmc = 0x%p, size = %d, "
+                  "node = 0x%p\n", fmc, size, node));
+
+        *result = NULL;
+
+        if (!(fm = jffs_alloc_fm())) {
+                D(printk("jffs_fmalloc(): kmalloc() failed! (fm)\n"));
+                return -ENOMEM;
+        }
+
+        free_chunk_size1 = jffs_free_size1(fmc);
+        free_chunk_size2 = jffs_free_size2(fmc);
+        if (free_chunk_size1 + free_chunk_size2 != fmc->free_size) {
+                printk(KERN_WARNING "Free size accounting screwed\n");
+                printk(KERN_WARNING "free_chunk_size1 == 0x%x, free_chunk_size2 == 0x%x, fmc->free_size == 0x%x\n", free_chunk_size1, free_chunk_size2, fmc->free_size);
+        }
+
+        D3(printk("jffs_fmalloc(): free_chunk_size1 = %u, "
+                  "free_chunk_size2 = %u\n",
+                  free_chunk_size1, free_chunk_size2));
+
+        if (size <= free_chunk_size1) {
+                if (!(fm->nodes = (struct jffs_node_ref *)
+                                  kmalloc(sizeof(struct jffs_node_ref),
+                                          GFP_KERNEL))) {
+                        D(printk("jffs_fmalloc(): kmalloc() failed! "
+                                 "(node_ref)\n"));
+                        jffs_free_fm(fm);
+                        return -ENOMEM;
+                }
+                DJM(no_jffs_node_ref++);
+                fm->nodes->node = node;
+                fm->nodes->next = NULL;
+                if (fmc->tail) {
+                        fm->offset = fmc->tail->offset + fmc->tail->size;
+                        if (fm->offset == fmc->flash_size) {
+                                fm->offset = 0;
+                        }
+                        ASSERT(else if (fm->offset > fmc->flash_size) {
+                                printk(KERN_WARNING "jffs_fmalloc(): "
+                                       "offset > flash_end\n");
+                                fm->offset = 0;
+                        });
+                }
+                else {
+                        /* There don't have to be files in the file
+                           system yet.  */
+                        fm->offset = 0;
+                }
+                fm->size = size;
+                fmc->free_size -= size;
+                fmc->used_size += size;
+        }
+        else if (size > free_chunk_size2) {
+                printk(KERN_WARNING "JFFS: Tried to allocate a too "
+                       "large flash memory chunk. (size = %u)\n", size);
+                jffs_free_fm(fm);
+                return -ENOSPC;
+        }
+        else {
+                fm->offset = fmc->tail->offset + fmc->tail->size;
+                fm->size = free_chunk_size1;
+                fm->nodes = NULL;
+                fmc->free_size -= fm->size;
+                fmc->dirty_size += fm->size; /* Changed by simonk. This seemingly fixes a 
+                                                bug that caused infinite garbage collection.
+                                                It previously set fmc->dirty_size to size (which is the
+                                                size of the requested chunk).
+                                             */
+        }
+
+        fm->next = NULL;
+        if (!fmc->head) {
+                fm->prev = NULL;
+                fmc->head = fm;
+                fmc->tail = fm;
+        }
+        else {
+                fm->prev = fmc->tail;
+                fmc->tail->next = fm;
+                fmc->tail = fm;
+        }
+
+        D3(jffs_print_fmcontrol(fmc));
+        D3(jffs_print_fm(fm));
+        *result = fm;
+        return 0;
+}
+
+
+/* The on-flash space is not needed anymore by the passed node.  Remove
+   the reference to the node from the node list.  If the data chunk in
+   the flash memory isn't used by any more nodes anymore (fm->nodes == 0),
+   then mark that chunk as dirty.  */
+int
+jffs_fmfree(struct jffs_fmcontrol *fmc, struct jffs_fm *fm, struct jffs_node *node)
+{
+        struct jffs_node_ref *ref;
+        struct jffs_node_ref *prev;
+        ASSERT(int del = 0);
+
+        D2(printk("jffs_fmfree(): node->ino = %u, node->version = %u\n",
+                 node->ino, node->version));
+
+        ASSERT(if (!fmc || !fm || !fm->nodes) {
+                printk(KERN_ERR "jffs_fmfree(): fmc: 0x%p, fm: 0x%p, "
+                       "fm->nodes: 0x%p\n",
+                       fmc, fm, (fm ? fm->nodes : NULL));
+                return -1;
+        });
+
+        /* Find the reference to the node that is going to be removed
+           and remove it.  */
+        for (ref = fm->nodes, prev = NULL; ref; ref = ref->next) {
+                if (ref->node == node) {
+                        if (prev) {
+                                prev->next = ref->next;
+                        }
+                        else {
+                                fm->nodes = ref->next;
+                        }
+                        kfree(ref);
+                        DJM(no_jffs_node_ref--);
+                        ASSERT(del = 1);
+                        break;
+                }
+                prev = ref;
+        }
+
+        /* If the data chunk in the flash memory isn't used anymore
+           just mark it as obsolete.  */
+        if (!fm->nodes) {
+                /* No node uses this chunk so let's remove it.  */
+                fmc->used_size -= fm->size;
+                fmc->dirty_size += fm->size;
+#if defined(JFFS_MARK_OBSOLETE) && JFFS_MARK_OBSOLETE
+                if (jffs_mark_obsolete(fmc, fm->offset) < 0) {
+                        D1(printk("jffs_fmfree(): Failed to mark an on-flash "
+                                  "node obsolete!\n"));
+                        return -1;
+                }
+#endif
+        }
+
+        ASSERT(if (!del) {
+                printk(KERN_WARNING "***jffs_fmfree(): "
+                       "Didn't delete any node reference!\n");
+        });
+
+        return 0;
+}
+
+
+/* This allocation function is used during the initialization of
+   the file system.  */
+struct jffs_fm *
+jffs_fmalloced(struct jffs_fmcontrol *fmc, __u32 offset, __u32 size,
+               struct jffs_node *node)
+{
+        struct jffs_fm *fm;
+
+        D3(printk("jffs_fmalloced()\n"));
+
+        if (!(fm = jffs_alloc_fm())) {
+                D(printk("jffs_fmalloced(0x%p, %u, %u, 0x%p): failed!\n",
+                         fmc, offset, size, node));
+                return NULL;
+        }
+        fm->offset = offset;
+        fm->size = size;
+        fm->prev = NULL;
+        fm->next = NULL;
+        fm->nodes = NULL;
+        if (node) {
+                /* `node' exists and it should be associated with the
+                    jffs_fm structure `fm'.  */
+                if (!(fm->nodes = (struct jffs_node_ref *)
+                                  kmalloc(sizeof(struct jffs_node_ref),
+                                          GFP_KERNEL))) {
+                        D(printk("jffs_fmalloced(): !fm->nodes\n"));
+                        jffs_free_fm(fm);
+                        return NULL;
+                }
+                DJM(no_jffs_node_ref++);
+                fm->nodes->node = node;
+                fm->nodes->next = NULL;
+                fmc->used_size += size;
+                fmc->free_size -= size;
+        }
+        else {
+                /* If there is no node, then this is just a chunk of dirt.  */
+                fmc->dirty_size += size;
+                fmc->free_size -= size;
+        }
+
+        if (fmc->head_extra) {
+                fm->prev = fmc->tail_extra;
+                fmc->tail_extra->next = fm;
+                fmc->tail_extra = fm;
+        }
+        else if (!fmc->head) {
+                fmc->head = fm;
+                fmc->tail = fm;
+        }
+        else if (fmc->tail->offset + fmc->tail->size < offset) {
+                fmc->head_extra = fm;
+                fmc->tail_extra = fm;
+        }
+        else {
+                fm->prev = fmc->tail;
+                fmc->tail->next = fm;
+                fmc->tail = fm;
+        }
+        D3(jffs_print_fmcontrol(fmc));
+        D3(jffs_print_fm(fm));
+        return fm;
+}
+
+
+/* Add a new node to an already existing jffs_fm struct.  */
+int
+jffs_add_node(struct jffs_node *node)
+{
+        struct jffs_node_ref *ref;
+
+        D3(printk("jffs_add_node(): ino = %u\n", node->ino));
+
+        ref = (struct jffs_node_ref *)kmalloc(sizeof(struct jffs_node_ref),
+                                              GFP_KERNEL);
+        if (!ref)
+                return -ENOMEM;
+
+        DJM(no_jffs_node_ref++);
+        ref->node = node;
+        ref->next = node->fm->nodes;
+        node->fm->nodes = ref;
+        return 0;
+}
+
+
+/* Free a part of some allocated space.  */
+void
+jffs_fmfree_partly(struct jffs_fmcontrol *fmc, struct jffs_fm *fm, __u32 size)
+{
+        D1(printk("***jffs_fmfree_partly(): fm = 0x%p, fm->nodes = 0x%p, "
+                  "fm->nodes->node->ino = %u, size = %u\n",
+                  fm, (fm ? fm->nodes : 0),
+                  (!fm ? 0 : (!fm->nodes ? 0 : fm->nodes->node->ino)), size));
+
+        if (fm->nodes) {
+                kfree(fm->nodes);
+                DJM(no_jffs_node_ref--);
+                fm->nodes = NULL;
+        }
+        fmc->used_size -= fm->size;
+        if (fm == fmc->tail) {
+                fm->size -= size;
+                fmc->free_size += size;
+        }
+        fmc->dirty_size += fm->size;
+}
+
+
+/* Find the jffs_fm struct that contains the end of the data chunk that
+   begins at the logical beginning of the flash memory and spans `size'
+   bytes.  If we want to erase a sector of the flash memory, we use this
+   function to find where the sector limit cuts a chunk of data.  */
+struct jffs_fm *
+jffs_cut_node(struct jffs_fmcontrol *fmc, __u32 size)
+{
+        struct jffs_fm *fm;
+        __u32 pos = 0;
+
+        if (size == 0) {
+                return NULL;
+        }
+
+        ASSERT(if (!fmc) {
+                printk(KERN_ERR "jffs_cut_node(): fmc == NULL\n");
+                return NULL;
+        });
+
+        fm = fmc->head;
+
+        while (fm) {
+                pos += fm->size;
+                if (pos < size) {
+                        fm = fm->next;
+                }
+                else if (pos > size) {
+                        break;
+                }
+                else {
+                        fm = NULL;
+                        break;
+                }
+        }
+
+        return fm;
+}
+
+
+/* Move the head of the fmc structures and delete the obsolete parts.  */
+void
+jffs_sync_erase(struct jffs_fmcontrol *fmc, int erased_size)
+{
+        struct jffs_fm *fm;
+        struct jffs_fm *del;
+
+        ASSERT(if (!fmc) {
+                printk(KERN_ERR "jffs_sync_erase(): fmc == NULL\n");
+                return;
+        });
+
+        fmc->dirty_size -= erased_size;
+        fmc->free_size += erased_size;
+
+        for (fm = fmc->head; fm && (erased_size > 0);) {
+                if (erased_size >= fm->size) {
+                        erased_size -= fm->size;
+                        del = fm;
+                        fm = fm->next;
+                        fm->prev = NULL;
+                        fmc->head = fm;
+                        jffs_free_fm(del);
+                }
+                else {
+                        fm->size -= erased_size;
+                        fm->offset += erased_size;
+                        break;
+                }
+        }
+}
+
+
+/* Return the oldest used node in the flash memory.  */
+struct jffs_node *
+jffs_get_oldest_node(struct jffs_fmcontrol *fmc)
+{
+        struct jffs_fm *fm;
+        struct jffs_node_ref *nref;
+        struct jffs_node *node = NULL;
+
+        ASSERT(if (!fmc) {
+                printk(KERN_ERR "jffs_get_oldest_node(): fmc == NULL\n");
+                return NULL;
+        });
+
+        for (fm = fmc->head; fm && !fm->nodes; fm = fm->next);
+
+        if (!fm) {
+                return NULL;
+        }
+
+        /* The oldest node is the last one in the reference list.  This list
+           shouldn't be too long; just one or perhaps two elements.  */
+        for (nref = fm->nodes; nref; nref = nref->next) {
+                node = nref->node;
+        }
+
+        D2(printk("jffs_get_oldest_node(): ino = %u, version = %u\n",
+                  (node ? node->ino : 0), (node ? node->version : 0)));
+
+        return node;
+}
+
+
+#if defined(JFFS_MARK_OBSOLETE) && JFFS_MARK_OBSOLETE
+
+/* Mark an on-flash node as obsolete.
+
+   Note that this is just an optimization that isn't necessary for the
+   filesystem to work.  */
+
+static int
+jffs_mark_obsolete(struct jffs_fmcontrol *fmc, __u32 fm_offset)
+{
+        /* The `accurate_pos' holds the position of the accurate byte
+           in the jffs_raw_inode structure that we are going to mark
+           as obsolete.  */
+        __u32 accurate_pos = fm_offset + JFFS_RAW_INODE_ACCURATE_OFFSET;
+        unsigned char zero = 0x00;
+        size_t len;
+
+        D3(printk("jffs_mark_obsolete(): accurate_pos = %u\n", accurate_pos));
+        ASSERT(if (!fmc) {
+                printk(KERN_ERR "jffs_mark_obsolete(): fmc == NULL\n");
+                return -1;
+        });
+
+        /* Write 0x00 to the raw inode's accurate member.  Don't care
+           about the return value.  */
+        MTD_WRITE(fmc->mtd, accurate_pos, 1, &len, &zero);
+        return 0;
+}
+
+#endif /* JFFS_MARK_OBSOLETE  */
+
+/* check if it's possible to erase the wanted range, and if not, return
+ * the range that IS erasable, or a negative error code.
+ */
+static long
+jffs_flash_erasable_size(struct mtd_info *mtd, __u32 offset, __u32 size)
+{
+         u_long ssize;
+
+        /* assume that sector size for a partition is constant even
+         * if it spans more than one chip (you usually put the same
+         * type of chips in a system)
+         */
+
+        ssize = mtd->erasesize;
+
+        if (offset % ssize) {
+                printk(KERN_WARNING "jffs_flash_erasable_size() given non-aligned offset %x (erasesize %lx)\n", offset, ssize);
+                /* The offset is not sector size aligned.  */
+                return -1;
+        }
+        else if (offset > mtd->size) {
+                printk(KERN_WARNING "jffs_flash_erasable_size given offset off the end of device (%x > %x)\n", offset, mtd->size);
+                return -2;
+        }
+        else if (offset + size > mtd->size) {
+                printk(KERN_WARNING "jffs_flash_erasable_size() given length which runs off the end of device (ofs %x + len %x = %x, > %x)\n", offset,size, offset+size, mtd->size);
+                return -3;
+        }
+
+        return (size / ssize) * ssize;
+}
+
+
+/* How much dirty flash memory is possible to erase at the moment?  */
+long
+jffs_erasable_size(struct jffs_fmcontrol *fmc)
+{
+        struct jffs_fm *fm;
+        __u32 size = 0;
+        long ret;
+
+        ASSERT(if (!fmc) {
+                printk(KERN_ERR "jffs_erasable_size(): fmc = NULL\n");
+                return -1;
+        });
+
+        if (!fmc->head) {
+                /* The flash memory is totally empty. No nodes. No dirt.
+                   Just return.  */
+                return 0;
+        }
+
+        /* Calculate how much space that is dirty.  */
+        for (fm = fmc->head; fm && !fm->nodes; fm = fm->next) {
+                if (size && fm->offset == 0) {
+                        /* We have reached the beginning of the flash.  */
+                        break;
+                }
+                size += fm->size;
+        }
+
+        /* Someone's signature contained this:
+           There's a fine line between fishing and just standing on
+           the shore like an idiot...  */
+        ret = jffs_flash_erasable_size(fmc->mtd, fmc->head->offset, size);
+
+        ASSERT(if (ret < 0) {
+                printk("jffs_erasable_size: flash_erasable_size() "
+                       "returned something less than zero (%ld).\n", ret);
+                printk("jffs_erasable_size: offset = 0x%08x\n",
+                       fmc->head->offset);
+        });
+
+        /* If there is dirt on the flash (which is the reason to why
+           this function was called in the first place) but no space is
+           possible to erase right now, the initial part of the list of
+           jffs_fm structs, that hold place for dirty space, could perhaps
+           be shortened.  The list's initial "dirty" elements are merged
+           into just one large dirty jffs_fm struct.  This operation must
+           only be performed if nothing is possible to erase.  Otherwise,
+           jffs_clear_end_of_node() won't work as expected.  */
+        if (ret == 0) {
+                struct jffs_fm *head = fmc->head;
+                struct jffs_fm *del;
+                /* While there are two dirty nodes beside each other.*/
+                while (head->nodes == 0
+                       && head->next
+                       && head->next->nodes == 0) {
+                        del = head->next;
+                        head->size += del->size;
+                        head->next = del->next;
+                        if (del->next) {
+                                del->next->prev = head;
+                        }
+                        jffs_free_fm(del);
+                }
+        }
+
+        return (ret >= 0 ? ret : 0);
+}
+
+static struct jffs_fm *jffs_alloc_fm(void)
+{
+        struct jffs_fm *fm;
+
+        fm = kmem_cache_alloc(fm_cache,GFP_KERNEL);
+        DJM(if (fm) no_jffs_fm++;);
+        
+        return fm;
+}
+
+static void jffs_free_fm(struct jffs_fm *n)
+{
+        kmem_cache_free(fm_cache,n);
+        DJM(no_jffs_fm--);
+}
+
+
+
+struct jffs_node *jffs_alloc_node(void)
+{
+        struct jffs_node *n;
+
+        n = (struct jffs_node *)kmem_cache_alloc(node_cache,GFP_KERNEL);
+        if(n != NULL)
+                no_jffs_node++;
+        return n;
+}
+
+void jffs_free_node(struct jffs_node *n)
+{
+        kmem_cache_free(node_cache,n);
+        no_jffs_node--;
+}
+
+
+int jffs_get_node_inuse(void)
+{
+        return no_jffs_node;
+}
+
+void
+jffs_print_fmcontrol(struct jffs_fmcontrol *fmc)
+{
+        D(printk("struct jffs_fmcontrol: 0x%p\n", fmc));
+        D(printk("{\n"));
+        D(printk("        %u, /* flash_size  */\n", fmc->flash_size));
+        D(printk("        %u, /* used_size  */\n", fmc->used_size));
+        D(printk("        %u, /* dirty_size  */\n", fmc->dirty_size));
+        D(printk("        %u, /* free_size  */\n", fmc->free_size));
+        D(printk("        %u, /* sector_size  */\n", fmc->sector_size));
+        D(printk("        %u, /* min_free_size  */\n", fmc->min_free_size));
+        D(printk("        %u, /* max_chunk_size  */\n", fmc->max_chunk_size));
+        D(printk("        0x%p, /* mtd  */\n", fmc->mtd));
+        D(printk("        0x%p, /* head  */    "
+                 "(head->offset = 0x%08x)\n",
+                 fmc->head, (fmc->head ? fmc->head->offset : 0)));
+        D(printk("        0x%p, /* tail  */    "
+                 "(tail->offset + tail->size = 0x%08x)\n",
+                 fmc->tail,
+                 (fmc->tail ? fmc->tail->offset + fmc->tail->size : 0)));
+        D(printk("        0x%p, /* head_extra  */\n", fmc->head_extra));
+        D(printk("        0x%p, /* tail_extra  */\n", fmc->tail_extra));
+        D(printk("}\n"));
+}
+
+void
+jffs_print_fm(struct jffs_fm *fm)
+{
+        D(printk("struct jffs_fm: 0x%p\n", fm));
+        D(printk("{\n"));
+        D(printk("       0x%08x, /* offset  */\n", fm->offset));
+        D(printk("       %u, /* size  */\n", fm->size));
+        D(printk("       0x%p, /* prev  */\n", fm->prev));
+        D(printk("       0x%p, /* next  */\n", fm->next));
+        D(printk("       0x%p, /* nodes  */\n", fm->nodes));
+        D(printk("}\n"));
+}
+
+#if 0
+void
+jffs_print_node_ref(struct jffs_node_ref *ref)
+{
+        D(printk("struct jffs_node_ref: 0x%p\n", ref));
+        D(printk("{\n"));
+        D(printk("       0x%p, /* node  */\n", ref->node));
+        D(printk("       0x%p, /* next  */\n", ref->next));
+        D(printk("}\n"));
+}
+#endif  /*  0  */
+