Linux-2.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!
diff --git a/fs/jffs/Makefile b/fs/jffs/Makefile
new file mode 100644
index 0000000..9c1c0bb
--- /dev/null
+++ b/fs/jffs/Makefile
@@ -0,0 +1,11 @@
+#
+# Makefile for the linux Journalling Flash FileSystem (JFFS) routines.
+#
+# $Id: Makefile,v 1.11 2001/09/25 20:59:41 dwmw2 Exp $
+#
+
+obj-$(CONFIG_JFFS_FS) += jffs.o
+
+jffs-y := jffs_fm.o intrep.o inode-v23.o
+jffs-$(CONFIG_JFFS_PROC_FS) += jffs_proc.o
+jffs-objs := $(jffs-y)
diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
new file mode 100644
index 0000000..bfbeb4c
--- /dev/null
+++ b/fs/jffs/inode-v23.c
@@ -0,0 +1,1847 @@
+/*
+ * JFFS -- Journalling 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: inode-v23.c,v 1.70 2001/10/02 09:16:02 dwmw2 Exp $
+ *
+ * Ported to Linux 2.3.x and MTD:
+ * Copyright (C) 2000 Alexander Larsson (alex@cendio.se), Cendio Systems AB
+ *
+ * Copyright 2000, 2001 Red Hat, Inc.
+ */
+
+/* inode.c -- Contains the code that is called from the VFS. */
+
+/* TODO-ALEX:
+ * uid and gid are just 16 bit.
+ * jffs_file_write reads from user-space pointers without xx_from_user
+ * maybe other stuff do to.
+ */
+
+#include <linux/time.h>
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/jffs.h>
+#include <linux/fs.h>
+#include <linux/smp_lock.h>
+#include <linux/ioctl.h>
+#include <linux/stat.h>
+#include <linux/blkdev.h>
+#include <linux/quotaops.h>
+#include <linux/highmem.h>
+#include <linux/vfs.h>
+#include <asm/semaphore.h>
+#include <asm/byteorder.h>
+#include <asm/uaccess.h>
+
+#include "jffs_fm.h"
+#include "intrep.h"
+#ifdef CONFIG_JFFS_PROC_FS
+#include "jffs_proc.h"
+#endif
+
+static int jffs_remove(struct inode *dir, struct dentry *dentry, int type);
+
+static struct super_operations jffs_ops;
+static struct file_operations jffs_file_operations;
+static struct inode_operations jffs_file_inode_operations;
+static struct file_operations jffs_dir_operations;
+static struct inode_operations jffs_dir_inode_operations;
+static struct address_space_operations jffs_address_operations;
+
+kmem_cache_t *node_cache = NULL;
+kmem_cache_t *fm_cache = NULL;
+
+/* Called by the VFS at mount time to initialize the whole file system. */
+static int jffs_fill_super(struct super_block *sb, void *data, int silent)
+{
+ struct inode *root_inode;
+ struct jffs_control *c;
+
+ sb->s_flags |= MS_NODIRATIME;
+
+ D1(printk(KERN_NOTICE "JFFS: Trying to mount device %s.\n",
+ sb->s_id));
+
+ if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
+ printk(KERN_WARNING "JFFS: Trying to mount a "
+ "non-mtd device.\n");
+ return -EINVAL;
+ }
+
+ sb->s_blocksize = PAGE_CACHE_SIZE;
+ sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+ sb->s_fs_info = (void *) 0;
+ sb->s_maxbytes = 0xFFFFFFFF;
+
+ /* Build the file system. */
+ if (jffs_build_fs(sb) < 0) {
+ goto jffs_sb_err1;
+ }
+
+ /*
+ * set up enough so that we can read an inode
+ */
+ sb->s_magic = JFFS_MAGIC_SB_BITMASK;
+ sb->s_op = &jffs_ops;
+
+ root_inode = iget(sb, JFFS_MIN_INO);
+ if (!root_inode)
+ goto jffs_sb_err2;
+
+ /* Get the root directory of this file system. */
+ if (!(sb->s_root = d_alloc_root(root_inode))) {
+ goto jffs_sb_err3;
+ }
+
+ c = (struct jffs_control *) sb->s_fs_info;
+
+#ifdef CONFIG_JFFS_PROC_FS
+ /* Set up the jffs proc file system. */
+ if (jffs_register_jffs_proc_dir(MINOR(sb->s_dev), c) < 0) {
+ printk(KERN_WARNING "JFFS: Failed to initialize the JFFS "
+ "proc file system for device %s.\n",
+ sb->s_id);
+ }
+#endif
+
+ /* Set the Garbage Collection thresholds */
+
+ /* GC if free space goes below 5% of the total size */
+ c->gc_minfree_threshold = c->fmc->flash_size / 20;
+
+ if (c->gc_minfree_threshold < c->fmc->sector_size)
+ c->gc_minfree_threshold = c->fmc->sector_size;
+
+ /* GC if dirty space exceeds 33% of the total size. */
+ c->gc_maxdirty_threshold = c->fmc->flash_size / 3;
+
+ if (c->gc_maxdirty_threshold < c->fmc->sector_size)
+ c->gc_maxdirty_threshold = c->fmc->sector_size;
+
+
+ c->thread_pid = kernel_thread (jffs_garbage_collect_thread,
+ (void *) c,
+ CLONE_KERNEL);
+ D1(printk(KERN_NOTICE "JFFS: GC thread pid=%d.\n", (int) c->thread_pid));
+
+ D1(printk(KERN_NOTICE "JFFS: Successfully mounted device %s.\n",
+ sb->s_id));
+ return 0;
+
+jffs_sb_err3:
+ iput(root_inode);
+jffs_sb_err2:
+ jffs_cleanup_control((struct jffs_control *)sb->s_fs_info);
+jffs_sb_err1:
+ printk(KERN_WARNING "JFFS: Failed to mount device %s.\n",
+ sb->s_id);
+ return -EINVAL;
+}
+
+
+/* This function is called when the file system is umounted. */
+static void
+jffs_put_super(struct super_block *sb)
+{
+ struct jffs_control *c = (struct jffs_control *) sb->s_fs_info;
+
+ D2(printk("jffs_put_super()\n"));
+
+#ifdef CONFIG_JFFS_PROC_FS
+ jffs_unregister_jffs_proc_dir(c);
+#endif
+
+ if (c->gc_task) {
+ D1(printk (KERN_NOTICE "jffs_put_super(): Telling gc thread to die.\n"));
+ send_sig(SIGKILL, c->gc_task, 1);
+ }
+ wait_for_completion(&c->gc_thread_comp);
+
+ D1(printk (KERN_NOTICE "jffs_put_super(): Successfully waited on thread.\n"));
+
+ jffs_cleanup_control((struct jffs_control *)sb->s_fs_info);
+ D1(printk(KERN_NOTICE "JFFS: Successfully unmounted device %s.\n",
+ sb->s_id));
+}
+
+
+/* This function is called when user commands like chmod, chgrp and
+ chown are executed. System calls like trunc() results in a call
+ to this function. */
+static int
+jffs_setattr(struct dentry *dentry, struct iattr *iattr)
+{
+ struct inode *inode = dentry->d_inode;
+ struct jffs_raw_inode raw_inode;
+ struct jffs_control *c;
+ struct jffs_fmcontrol *fmc;
+ struct jffs_file *f;
+ struct jffs_node *new_node;
+ int update_all;
+ int res = 0;
+ int recoverable = 0;
+
+ lock_kernel();
+
+ if ((res = inode_change_ok(inode, iattr)))
+ goto out;
+
+ c = (struct jffs_control *)inode->i_sb->s_fs_info;
+ fmc = c->fmc;
+
+ D3(printk (KERN_NOTICE "notify_change(): down biglock\n"));
+ down(&fmc->biglock);
+
+ f = jffs_find_file(c, inode->i_ino);
+
+ ASSERT(if (!f) {
+ printk("jffs_setattr(): Invalid inode number: %lu\n",
+ inode->i_ino);
+ D3(printk (KERN_NOTICE "notify_change(): up biglock\n"));
+ up(&fmc->biglock);
+ res = -EINVAL;
+ goto out;
+ });
+
+ D1(printk("***jffs_setattr(): file: \"%s\", ino: %u\n",
+ f->name, f->ino));
+
+ update_all = iattr->ia_valid & ATTR_FORCE;
+
+ if ( (update_all || iattr->ia_valid & ATTR_SIZE)
+ && (iattr->ia_size + 128 < f->size) ) {
+ /* We're shrinking the file by more than 128 bytes.
+ We'll be able to GC and recover this space, so
+ allow it to go into the reserved space. */
+ recoverable = 1;
+ }
+
+ if (!(new_node = jffs_alloc_node())) {
+ D(printk("jffs_setattr(): Allocation failed!\n"));
+ D3(printk (KERN_NOTICE "notify_change(): up biglock\n"));
+ up(&fmc->biglock);
+ res = -ENOMEM;
+ goto out;
+ }
+
+ new_node->data_offset = 0;
+ new_node->removed_size = 0;
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = f->ino;
+ raw_inode.pino = f->pino;
+ raw_inode.mode = f->mode;
+ raw_inode.uid = f->uid;
+ raw_inode.gid = f->gid;
+ raw_inode.atime = f->atime;
+ raw_inode.mtime = f->mtime;
+ raw_inode.ctime = f->ctime;
+ raw_inode.dsize = 0;
+ raw_inode.offset = 0;
+ raw_inode.rsize = 0;
+ raw_inode.dsize = 0;
+ raw_inode.nsize = f->nsize;
+ raw_inode.nlink = f->nlink;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = 0;
+
+ if (update_all || iattr->ia_valid & ATTR_MODE) {
+ raw_inode.mode = iattr->ia_mode;
+ inode->i_mode = iattr->ia_mode;
+ }
+ if (update_all || iattr->ia_valid & ATTR_UID) {
+ raw_inode.uid = iattr->ia_uid;
+ inode->i_uid = iattr->ia_uid;
+ }
+ if (update_all || iattr->ia_valid & ATTR_GID) {
+ raw_inode.gid = iattr->ia_gid;
+ inode->i_gid = iattr->ia_gid;
+ }
+ if (update_all || iattr->ia_valid & ATTR_SIZE) {
+ int len;
+ D1(printk("jffs_notify_change(): Changing size "
+ "to %lu bytes!\n", (long)iattr->ia_size));
+ raw_inode.offset = iattr->ia_size;
+
+ /* Calculate how many bytes need to be removed from
+ the end. */
+ if (f->size < iattr->ia_size) {
+ len = 0;
+ }
+ else {
+ len = f->size - iattr->ia_size;
+ }
+
+ raw_inode.rsize = len;
+
+ /* The updated node will be a removal node, with
+ base at the new size and size of the nbr of bytes
+ to be removed. */
+ new_node->data_offset = iattr->ia_size;
+ new_node->removed_size = len;
+ inode->i_size = iattr->ia_size;
+ inode->i_blocks = (inode->i_size + 511) >> 9;
+
+ if (len) {
+ invalidate_inode_pages(inode->i_mapping);
+ }
+ inode->i_ctime = CURRENT_TIME_SEC;
+ inode->i_mtime = inode->i_ctime;
+ }
+ if (update_all || iattr->ia_valid & ATTR_ATIME) {
+ raw_inode.atime = iattr->ia_atime.tv_sec;
+ inode->i_atime = iattr->ia_atime;
+ }
+ if (update_all || iattr->ia_valid & ATTR_MTIME) {
+ raw_inode.mtime = iattr->ia_mtime.tv_sec;
+ inode->i_mtime = iattr->ia_mtime;
+ }
+ if (update_all || iattr->ia_valid & ATTR_CTIME) {
+ raw_inode.ctime = iattr->ia_ctime.tv_sec;
+ inode->i_ctime = iattr->ia_ctime;
+ }
+
+ /* Write this node to the flash. */
+ if ((res = jffs_write_node(c, new_node, &raw_inode, f->name, NULL, recoverable, f)) < 0) {
+ D(printk("jffs_notify_change(): The write failed!\n"));
+ jffs_free_node(new_node);
+ D3(printk (KERN_NOTICE "n_c(): up biglock\n"));
+ up(&c->fmc->biglock);
+ goto out;
+ }
+
+ jffs_insert_node(c, f, &raw_inode, NULL, new_node);
+
+ mark_inode_dirty(inode);
+ D3(printk (KERN_NOTICE "n_c(): up biglock\n"));
+ up(&c->fmc->biglock);
+out:
+ unlock_kernel();
+ return res;
+} /* jffs_notify_change() */
+
+
+static struct inode *
+jffs_new_inode(const struct inode * dir, struct jffs_raw_inode *raw_inode,
+ int * err)
+{
+ struct super_block * sb;
+ struct inode * inode;
+ struct jffs_control *c;
+ struct jffs_file *f;
+
+ sb = dir->i_sb;
+ inode = new_inode(sb);
+ if (!inode) {
+ *err = -ENOMEM;
+ return NULL;
+ }
+
+ c = (struct jffs_control *)sb->s_fs_info;
+
+ inode->i_ino = raw_inode->ino;
+ inode->i_mode = raw_inode->mode;
+ inode->i_nlink = raw_inode->nlink;
+ inode->i_uid = raw_inode->uid;
+ inode->i_gid = raw_inode->gid;
+ inode->i_size = raw_inode->dsize;
+ inode->i_atime.tv_sec = raw_inode->atime;
+ inode->i_mtime.tv_sec = raw_inode->mtime;
+ inode->i_ctime.tv_sec = raw_inode->ctime;
+ inode->i_ctime.tv_nsec = 0;
+ inode->i_mtime.tv_nsec = 0;
+ inode->i_atime.tv_nsec = 0;
+ inode->i_blksize = PAGE_SIZE;
+ inode->i_blocks = (inode->i_size + 511) >> 9;
+
+ f = jffs_find_file(c, raw_inode->ino);
+
+ inode->u.generic_ip = (void *)f;
+ insert_inode_hash(inode);
+
+ return inode;
+}
+
+/* Get statistics of the file system. */
+static int
+jffs_statfs(struct super_block *sb, struct kstatfs *buf)
+{
+ struct jffs_control *c = (struct jffs_control *) sb->s_fs_info;
+ struct jffs_fmcontrol *fmc;
+
+ lock_kernel();
+
+ fmc = c->fmc;
+
+ D2(printk("jffs_statfs()\n"));
+
+ buf->f_type = JFFS_MAGIC_SB_BITMASK;
+ buf->f_bsize = PAGE_CACHE_SIZE;
+ buf->f_blocks = (fmc->flash_size / PAGE_CACHE_SIZE)
+ - (fmc->min_free_size / PAGE_CACHE_SIZE);
+ buf->f_bfree = (jffs_free_size1(fmc) + jffs_free_size2(fmc) +
+ fmc->dirty_size - fmc->min_free_size)
+ >> PAGE_CACHE_SHIFT;
+ buf->f_bavail = buf->f_bfree;
+
+ /* Find out how many files there are in the filesystem. */
+ buf->f_files = jffs_foreach_file(c, jffs_file_count);
+ buf->f_ffree = buf->f_bfree;
+ /* buf->f_fsid = 0; */
+ buf->f_namelen = JFFS_MAX_NAME_LEN;
+
+ unlock_kernel();
+
+ return 0;
+}
+
+
+/* Rename a file. */
+static int
+jffs_rename(struct inode *old_dir, struct dentry *old_dentry,
+ struct inode *new_dir, struct dentry *new_dentry)
+{
+ struct jffs_raw_inode raw_inode;
+ struct jffs_control *c;
+ struct jffs_file *old_dir_f;
+ struct jffs_file *new_dir_f;
+ struct jffs_file *del_f;
+ struct jffs_file *f;
+ struct jffs_node *node;
+ struct inode *inode;
+ int result = 0;
+ __u32 rename_data = 0;
+
+ D2(printk("***jffs_rename()\n"));
+
+ D(printk("jffs_rename(): old_dir: 0x%p, old name: 0x%p, "
+ "new_dir: 0x%p, new name: 0x%p\n",
+ old_dir, old_dentry->d_name.name,
+ new_dir, new_dentry->d_name.name));
+
+ lock_kernel();
+ c = (struct jffs_control *)old_dir->i_sb->s_fs_info;
+ ASSERT(if (!c) {
+ printk(KERN_ERR "jffs_rename(): The old_dir inode "
+ "didn't have a reference to a jffs_file struct\n");
+ unlock_kernel();
+ return -EIO;
+ });
+
+ result = -ENOTDIR;
+ if (!(old_dir_f = (struct jffs_file *)old_dir->u.generic_ip)) {
+ D(printk("jffs_rename(): Old dir invalid.\n"));
+ goto jffs_rename_end;
+ }
+
+ /* Try to find the file to move. */
+ result = -ENOENT;
+ if (!(f = jffs_find_child(old_dir_f, old_dentry->d_name.name,
+ old_dentry->d_name.len))) {
+ goto jffs_rename_end;
+ }
+
+ /* Find the new directory. */
+ result = -ENOTDIR;
+ if (!(new_dir_f = (struct jffs_file *)new_dir->u.generic_ip)) {
+ D(printk("jffs_rename(): New dir invalid.\n"));
+ goto jffs_rename_end;
+ }
+ D3(printk (KERN_NOTICE "rename(): down biglock\n"));
+ down(&c->fmc->biglock);
+ /* Create a node and initialize as much as needed. */
+ result = -ENOMEM;
+ if (!(node = jffs_alloc_node())) {
+ D(printk("jffs_rename(): Allocation failed: node == 0\n"));
+ goto jffs_rename_end;
+ }
+ node->data_offset = 0;
+ node->removed_size = 0;
+
+ /* Initialize the raw inode. */
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = f->ino;
+ raw_inode.pino = new_dir_f->ino;
+/* raw_inode.version = f->highest_version + 1; */
+ raw_inode.mode = f->mode;
+ raw_inode.uid = current->fsuid;
+ raw_inode.gid = current->fsgid;
+#if 0
+ raw_inode.uid = f->uid;
+ raw_inode.gid = f->gid;
+#endif
+ raw_inode.atime = get_seconds();
+ raw_inode.mtime = raw_inode.atime;
+ raw_inode.ctime = f->ctime;
+ raw_inode.offset = 0;
+ raw_inode.dsize = 0;
+ raw_inode.rsize = 0;
+ raw_inode.nsize = new_dentry->d_name.len;
+ raw_inode.nlink = f->nlink;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = 0;
+
+ /* See if there already exists a file with the same name as
+ new_name. */
+ if ((del_f = jffs_find_child(new_dir_f, new_dentry->d_name.name,
+ new_dentry->d_name.len))) {
+ raw_inode.rename = 1;
+ raw_inode.dsize = sizeof(__u32);
+ rename_data = del_f->ino;
+ }
+
+ /* Write the new node to the flash memory. */
+ if ((result = jffs_write_node(c, node, &raw_inode,
+ new_dentry->d_name.name,
+ (unsigned char*)&rename_data, 0, f)) < 0) {
+ D(printk("jffs_rename(): Failed to write node to flash.\n"));
+ jffs_free_node(node);
+ goto jffs_rename_end;
+ }
+ raw_inode.dsize = 0;
+
+ if (raw_inode.rename) {
+ /* The file with the same name must be deleted. */
+ //FIXME deadlock down(&c->fmc->gclock);
+ if ((result = jffs_remove(new_dir, new_dentry,
+ del_f->mode)) < 0) {
+ /* This is really bad. */
+ printk(KERN_ERR "JFFS: An error occurred in "
+ "rename().\n");
+ }
+ // up(&c->fmc->gclock);
+ }
+
+ if (old_dir_f != new_dir_f) {
+ /* Remove the file from its old position in the
+ filesystem tree. */
+ jffs_unlink_file_from_tree(f);
+ }
+
+ /* Insert the new node into the file system. */
+ if ((result = jffs_insert_node(c, f, &raw_inode,
+ new_dentry->d_name.name, node)) < 0) {
+ D(printk(KERN_ERR "jffs_rename(): jffs_insert_node() "
+ "failed!\n"));
+ }
+
+ if (old_dir_f != new_dir_f) {
+ /* Insert the file to its new position in the
+ file system. */
+ jffs_insert_file_into_tree(f);
+ }
+
+ /* This is a kind of update of the inode we're about to make
+ here. This is what they do in ext2fs. Kind of. */
+ if ((inode = iget(new_dir->i_sb, f->ino))) {
+ inode->i_ctime = CURRENT_TIME_SEC;
+ mark_inode_dirty(inode);
+ iput(inode);
+ }
+
+jffs_rename_end:
+ D3(printk (KERN_NOTICE "rename(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return result;
+} /* jffs_rename() */
+
+
+/* Read the contents of a directory. Used by programs like `ls'
+ for instance. */
+static int
+jffs_readdir(struct file *filp, void *dirent, filldir_t filldir)
+{
+ struct jffs_file *f;
+ struct dentry *dentry = filp->f_dentry;
+ struct inode *inode = dentry->d_inode;
+ struct jffs_control *c = (struct jffs_control *)inode->i_sb->s_fs_info;
+ int j;
+ int ddino;
+ lock_kernel();
+ D3(printk (KERN_NOTICE "readdir(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ D2(printk("jffs_readdir(): inode: 0x%p, filp: 0x%p\n", inode, filp));
+ if (filp->f_pos == 0) {
+ D3(printk("jffs_readdir(): \".\" %lu\n", inode->i_ino));
+ if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino, DT_DIR) < 0) {
+ D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return 0;
+ }
+ filp->f_pos = 1;
+ }
+ if (filp->f_pos == 1) {
+ if (inode->i_ino == JFFS_MIN_INO) {
+ ddino = JFFS_MIN_INO;
+ }
+ else {
+ ddino = ((struct jffs_file *)
+ inode->u.generic_ip)->pino;
+ }
+ D3(printk("jffs_readdir(): \"..\" %u\n", ddino));
+ if (filldir(dirent, "..", 2, filp->f_pos, ddino, DT_DIR) < 0) {
+ D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return 0;
+ }
+ filp->f_pos++;
+ }
+ f = ((struct jffs_file *)inode->u.generic_ip)->children;
+
+ j = 2;
+ while(f && (f->deleted || j++ < filp->f_pos )) {
+ f = f->sibling_next;
+ }
+
+ while (f) {
+ D3(printk("jffs_readdir(): \"%s\" ino: %u\n",
+ (f->name ? f->name : ""), f->ino));
+ if (filldir(dirent, f->name, f->nsize,
+ filp->f_pos , f->ino, DT_UNKNOWN) < 0) {
+ D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return 0;
+ }
+ filp->f_pos++;
+ do {
+ f = f->sibling_next;
+ } while(f && f->deleted);
+ }
+ D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return filp->f_pos;
+} /* jffs_readdir() */
+
+
+/* Find a file in a directory. If the file exists, return its
+ corresponding dentry. */
+static struct dentry *
+jffs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+{
+ struct jffs_file *d;
+ struct jffs_file *f;
+ struct jffs_control *c = (struct jffs_control *)dir->i_sb->s_fs_info;
+ int len;
+ int r = 0;
+ const char *name;
+ struct inode *inode = NULL;
+
+ len = dentry->d_name.len;
+ name = dentry->d_name.name;
+
+ lock_kernel();
+
+ D3({
+ char *s = (char *)kmalloc(len + 1, GFP_KERNEL);
+ memcpy(s, name, len);
+ s[len] = '\0';
+ printk("jffs_lookup(): dir: 0x%p, name: \"%s\"\n", dir, s);
+ kfree(s);
+ });
+
+ D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ r = -ENAMETOOLONG;
+ if (len > JFFS_MAX_NAME_LEN) {
+ goto jffs_lookup_end;
+ }
+
+ r = -EACCES;
+ if (!(d = (struct jffs_file *)dir->u.generic_ip)) {
+ D(printk("jffs_lookup(): No such inode! (%lu)\n",
+ dir->i_ino));
+ goto jffs_lookup_end;
+ }
+
+ /* Get the corresponding inode to the file. */
+
+ /* iget calls jffs_read_inode, so we need to drop the biglock
+ before calling iget. Unfortunately, the GC has a tendency
+ to sneak in here, because iget sometimes calls schedule ().
+ */
+
+ if ((len == 1) && (name[0] == '.')) {
+ D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
+ up(&c->fmc->biglock);
+ if (!(inode = iget(dir->i_sb, d->ino))) {
+ D(printk("jffs_lookup(): . iget() ==> NULL\n"));
+ goto jffs_lookup_end_no_biglock;
+ }
+ D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
+ down(&c->fmc->biglock);
+ } else if ((len == 2) && (name[0] == '.') && (name[1] == '.')) {
+ D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
+ up(&c->fmc->biglock);
+ if (!(inode = iget(dir->i_sb, d->pino))) {
+ D(printk("jffs_lookup(): .. iget() ==> NULL\n"));
+ goto jffs_lookup_end_no_biglock;
+ }
+ D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
+ down(&c->fmc->biglock);
+ } else if ((f = jffs_find_child(d, name, len))) {
+ D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
+ up(&c->fmc->biglock);
+ if (!(inode = iget(dir->i_sb, f->ino))) {
+ D(printk("jffs_lookup(): iget() ==> NULL\n"));
+ goto jffs_lookup_end_no_biglock;
+ }
+ D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
+ down(&c->fmc->biglock);
+ } else {
+ D3(printk("jffs_lookup(): Couldn't find the file. "
+ "f = 0x%p, name = \"%s\", d = 0x%p, d->ino = %u\n",
+ f, name, d, d->ino));
+ inode = NULL;
+ }
+
+ d_add(dentry, inode);
+ D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return NULL;
+
+jffs_lookup_end:
+ D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
+ up(&c->fmc->biglock);
+
+jffs_lookup_end_no_biglock:
+ unlock_kernel();
+ return ERR_PTR(r);
+} /* jffs_lookup() */
+
+
+/* Try to read a page of data from a file. */
+static int
+jffs_do_readpage_nolock(struct file *file, struct page *page)
+{
+ void *buf;
+ unsigned long read_len;
+ int result;
+ struct inode *inode = (struct inode*)page->mapping->host;
+ struct jffs_file *f = (struct jffs_file *)inode->u.generic_ip;
+ struct jffs_control *c = (struct jffs_control *)inode->i_sb->s_fs_info;
+ int r;
+ loff_t offset;
+
+ D2(printk("***jffs_readpage(): file = \"%s\", page->index = %lu\n",
+ (f->name ? f->name : ""), (long)page->index));
+
+ get_page(page);
+ /* Don't SetPageLocked(page), should be locked already */
+ ClearPageUptodate(page);
+ ClearPageError(page);
+
+ D3(printk (KERN_NOTICE "readpage(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ read_len = 0;
+ result = 0;
+ offset = page->index << PAGE_CACHE_SHIFT;
+
+ kmap(page);
+ buf = page_address(page);
+ if (offset < inode->i_size) {
+ read_len = min_t(long, inode->i_size - offset, PAGE_SIZE);
+ r = jffs_read_data(f, buf, offset, read_len);
+ if (r != read_len) {
+ result = -EIO;
+ D(
+ printk("***jffs_readpage(): Read error! "
+ "Wanted to read %lu bytes but only "
+ "read %d bytes.\n", read_len, r);
+ );
+ }
+
+ }
+
+ /* This handles the case of partial or no read in above */
+ if(read_len < PAGE_SIZE)
+ memset(buf + read_len, 0, PAGE_SIZE - read_len);
+ flush_dcache_page(page);
+ kunmap(page);
+
+ D3(printk (KERN_NOTICE "readpage(): up biglock\n"));
+ up(&c->fmc->biglock);
+
+ if (result) {
+ SetPageError(page);
+ }else {
+ SetPageUptodate(page);
+ }
+
+ page_cache_release(page);
+
+ D3(printk("jffs_readpage(): Leaving...\n"));
+
+ return result;
+} /* jffs_do_readpage_nolock() */
+
+static int jffs_readpage(struct file *file, struct page *page)
+{
+ int ret = jffs_do_readpage_nolock(file, page);
+ unlock_page(page);
+ return ret;
+}
+
+/* Create a new directory. */
+static int
+jffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+{
+ struct jffs_raw_inode raw_inode;
+ struct jffs_control *c;
+ struct jffs_node *node;
+ struct jffs_file *dir_f;
+ struct inode *inode;
+ int dir_mode;
+ int result = 0;
+ int err;
+
+ D1({
+ int len = dentry->d_name.len;
+ char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
+ memcpy(_name, dentry->d_name.name, len);
+ _name[len] = '\0';
+ printk("***jffs_mkdir(): dir = 0x%p, name = \"%s\", "
+ "len = %d, mode = 0x%08x\n", dir, _name, len, mode);
+ kfree(_name);
+ });
+
+ lock_kernel();
+ dir_f = (struct jffs_file *)dir->u.generic_ip;
+
+ ASSERT(if (!dir_f) {
+ printk(KERN_ERR "jffs_mkdir(): No reference to a "
+ "jffs_file struct in inode.\n");
+ unlock_kernel();
+ return -EIO;
+ });
+
+ c = dir_f->c;
+ D3(printk (KERN_NOTICE "mkdir(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ dir_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX)
+ & ~current->fs->umask);
+ if (dir->i_mode & S_ISGID) {
+ dir_mode |= S_ISGID;
+ }
+
+ /* Create a node and initialize it as much as needed. */
+ if (!(node = jffs_alloc_node())) {
+ D(printk("jffs_mkdir(): Allocation failed: node == 0\n"));
+ result = -ENOMEM;
+ goto jffs_mkdir_end;
+ }
+ node->data_offset = 0;
+ node->removed_size = 0;
+
+ /* Initialize the raw inode. */
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = c->next_ino++;
+ raw_inode.pino = dir_f->ino;
+ raw_inode.version = 1;
+ raw_inode.mode = dir_mode;
+ raw_inode.uid = current->fsuid;
+ raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
+ /* raw_inode.gid = current->fsgid; */
+ raw_inode.atime = get_seconds();
+ raw_inode.mtime = raw_inode.atime;
+ raw_inode.ctime = raw_inode.atime;
+ raw_inode.offset = 0;
+ raw_inode.dsize = 0;
+ raw_inode.rsize = 0;
+ raw_inode.nsize = dentry->d_name.len;
+ raw_inode.nlink = 1;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = 0;
+
+ /* Write the new node to the flash. */
+ if ((result = jffs_write_node(c, node, &raw_inode,
+ dentry->d_name.name, NULL, 0, NULL)) < 0) {
+ D(printk("jffs_mkdir(): jffs_write_node() failed.\n"));
+ jffs_free_node(node);
+ goto jffs_mkdir_end;
+ }
+
+ /* Insert the new node into the file system. */
+ if ((result = jffs_insert_node(c, NULL, &raw_inode, dentry->d_name.name,
+ node)) < 0) {
+ goto jffs_mkdir_end;
+ }
+
+ inode = jffs_new_inode(dir, &raw_inode, &err);
+ if (inode == NULL) {
+ result = err;
+ goto jffs_mkdir_end;
+ }
+
+ inode->i_op = &jffs_dir_inode_operations;
+ inode->i_fop = &jffs_dir_operations;
+
+ mark_inode_dirty(dir);
+ d_instantiate(dentry, inode);
+
+ result = 0;
+jffs_mkdir_end:
+ D3(printk (KERN_NOTICE "mkdir(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return result;
+} /* jffs_mkdir() */
+
+
+/* Remove a directory. */
+static int
+jffs_rmdir(struct inode *dir, struct dentry *dentry)
+{
+ struct jffs_control *c = (struct jffs_control *)dir->i_sb->s_fs_info;
+ int ret;
+ D3(printk("***jffs_rmdir()\n"));
+ D3(printk (KERN_NOTICE "rmdir(): down biglock\n"));
+ lock_kernel();
+ down(&c->fmc->biglock);
+ ret = jffs_remove(dir, dentry, S_IFDIR);
+ D3(printk (KERN_NOTICE "rmdir(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return ret;
+}
+
+
+/* Remove any kind of file except for directories. */
+static int
+jffs_unlink(struct inode *dir, struct dentry *dentry)
+{
+ struct jffs_control *c = (struct jffs_control *)dir->i_sb->s_fs_info;
+ int ret;
+
+ lock_kernel();
+ D3(printk("***jffs_unlink()\n"));
+ D3(printk (KERN_NOTICE "unlink(): down biglock\n"));
+ down(&c->fmc->biglock);
+ ret = jffs_remove(dir, dentry, 0);
+ D3(printk (KERN_NOTICE "unlink(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return ret;
+}
+
+
+/* Remove a JFFS entry, i.e. plain files, directories, etc. Here we
+ shouldn't test for free space on the device. */
+static int
+jffs_remove(struct inode *dir, struct dentry *dentry, int type)
+{
+ struct jffs_raw_inode raw_inode;
+ struct jffs_control *c;
+ struct jffs_file *dir_f; /* The file-to-remove's parent. */
+ struct jffs_file *del_f; /* The file to remove. */
+ struct jffs_node *del_node;
+ struct inode *inode = NULL;
+ int result = 0;
+
+ D1({
+ int len = dentry->d_name.len;
+ const char *name = dentry->d_name.name;
+ char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
+ memcpy(_name, name, len);
+ _name[len] = '\0';
+ printk("***jffs_remove(): file = \"%s\", ino = %ld\n", _name, dentry->d_inode->i_ino);
+ kfree(_name);
+ });
+
+ dir_f = (struct jffs_file *) dir->u.generic_ip;
+ c = dir_f->c;
+
+ result = -ENOENT;
+ if (!(del_f = jffs_find_child(dir_f, dentry->d_name.name,
+ dentry->d_name.len))) {
+ D(printk("jffs_remove(): jffs_find_child() failed.\n"));
+ goto jffs_remove_end;
+ }
+
+ if (S_ISDIR(type)) {
+ struct jffs_file *child = del_f->children;
+ while(child) {
+ if( !child->deleted ) {
+ result = -ENOTEMPTY;
+ goto jffs_remove_end;
+ }
+ child = child->sibling_next;
+ }
+ }
+ else if (S_ISDIR(del_f->mode)) {
+ D(printk("jffs_remove(): node is a directory "
+ "but it shouldn't be.\n"));
+ result = -EPERM;
+ goto jffs_remove_end;
+ }
+
+ inode = dentry->d_inode;
+
+ result = -EIO;
+ if (del_f->ino != inode->i_ino)
+ goto jffs_remove_end;
+
+ if (!inode->i_nlink) {
+ printk("Deleting nonexistent file inode: %lu, nlink: %d\n",
+ inode->i_ino, inode->i_nlink);
+ inode->i_nlink=1;
+ }
+
+ /* Create a node for the deletion. */
+ result = -ENOMEM;
+ if (!(del_node = jffs_alloc_node())) {
+ D(printk("jffs_remove(): Allocation failed!\n"));
+ goto jffs_remove_end;
+ }
+ del_node->data_offset = 0;
+ del_node->removed_size = 0;
+
+ /* Initialize the raw inode. */
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = del_f->ino;
+ raw_inode.pino = del_f->pino;
+/* raw_inode.version = del_f->highest_version + 1; */
+ raw_inode.mode = del_f->mode;
+ raw_inode.uid = current->fsuid;
+ raw_inode.gid = current->fsgid;
+ raw_inode.atime = get_seconds();
+ raw_inode.mtime = del_f->mtime;
+ raw_inode.ctime = raw_inode.atime;
+ raw_inode.offset = 0;
+ raw_inode.dsize = 0;
+ raw_inode.rsize = 0;
+ raw_inode.nsize = 0;
+ raw_inode.nlink = del_f->nlink;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = 1;
+
+ /* Write the new node to the flash memory. */
+ if (jffs_write_node(c, del_node, &raw_inode, NULL, NULL, 1, del_f) < 0) {
+ jffs_free_node(del_node);
+ result = -EIO;
+ goto jffs_remove_end;
+ }
+
+ /* Update the file. This operation will make the file disappear
+ from the in-memory file system structures. */
+ jffs_insert_node(c, del_f, &raw_inode, NULL, del_node);
+
+ dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
+ mark_inode_dirty(dir);
+ inode->i_nlink--;
+ inode->i_ctime = dir->i_ctime;
+ mark_inode_dirty(inode);
+
+ d_delete(dentry); /* This also frees the inode */
+
+ result = 0;
+jffs_remove_end:
+ return result;
+} /* jffs_remove() */
+
+
+static int
+jffs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
+{
+ struct jffs_raw_inode raw_inode;
+ struct jffs_file *dir_f;
+ struct jffs_node *node = NULL;
+ struct jffs_control *c;
+ struct inode *inode;
+ int result = 0;
+ u16 data = old_encode_dev(rdev);
+ int err;
+
+ D1(printk("***jffs_mknod()\n"));
+
+ if (!old_valid_dev(rdev))
+ return -EINVAL;
+ lock_kernel();
+ dir_f = (struct jffs_file *)dir->u.generic_ip;
+ c = dir_f->c;
+
+ D3(printk (KERN_NOTICE "mknod(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ /* Create and initialize a new node. */
+ if (!(node = jffs_alloc_node())) {
+ D(printk("jffs_mknod(): Allocation failed!\n"));
+ result = -ENOMEM;
+ goto jffs_mknod_err;
+ }
+ node->data_offset = 0;
+ node->removed_size = 0;
+
+ /* Initialize the raw inode. */
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = c->next_ino++;
+ raw_inode.pino = dir_f->ino;
+ raw_inode.version = 1;
+ raw_inode.mode = mode;
+ raw_inode.uid = current->fsuid;
+ raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
+ /* raw_inode.gid = current->fsgid; */
+ raw_inode.atime = get_seconds();
+ raw_inode.mtime = raw_inode.atime;
+ raw_inode.ctime = raw_inode.atime;
+ raw_inode.offset = 0;
+ raw_inode.dsize = 2;
+ raw_inode.rsize = 0;
+ raw_inode.nsize = dentry->d_name.len;
+ raw_inode.nlink = 1;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = 0;
+
+ /* Write the new node to the flash. */
+ if ((err = jffs_write_node(c, node, &raw_inode, dentry->d_name.name,
+ (unsigned char *)&data, 0, NULL)) < 0) {
+ D(printk("jffs_mknod(): jffs_write_node() failed.\n"));
+ result = err;
+ goto jffs_mknod_err;
+ }
+
+ /* Insert the new node into the file system. */
+ if ((err = jffs_insert_node(c, NULL, &raw_inode, dentry->d_name.name,
+ node)) < 0) {
+ result = err;
+ goto jffs_mknod_end;
+ }
+
+ inode = jffs_new_inode(dir, &raw_inode, &err);
+ if (inode == NULL) {
+ result = err;
+ goto jffs_mknod_end;
+ }
+
+ init_special_inode(inode, mode, rdev);
+
+ d_instantiate(dentry, inode);
+
+ goto jffs_mknod_end;
+
+jffs_mknod_err:
+ if (node) {
+ jffs_free_node(node);
+ }
+
+jffs_mknod_end:
+ D3(printk (KERN_NOTICE "mknod(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return result;
+} /* jffs_mknod() */
+
+
+static int
+jffs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
+{
+ struct jffs_raw_inode raw_inode;
+ struct jffs_control *c;
+ struct jffs_file *dir_f;
+ struct jffs_node *node;
+ struct inode *inode;
+
+ int symname_len = strlen(symname);
+ int err;
+
+ lock_kernel();
+ D1({
+ int len = dentry->d_name.len;
+ char *_name = (char *)kmalloc(len + 1, GFP_KERNEL);
+ char *_symname = (char *)kmalloc(symname_len + 1, GFP_KERNEL);
+ memcpy(_name, dentry->d_name.name, len);
+ _name[len] = '\0';
+ memcpy(_symname, symname, symname_len);
+ _symname[symname_len] = '\0';
+ printk("***jffs_symlink(): dir = 0x%p, "
+ "dentry->dname.name = \"%s\", "
+ "symname = \"%s\"\n", dir, _name, _symname);
+ kfree(_name);
+ kfree(_symname);
+ });
+
+ dir_f = (struct jffs_file *)dir->u.generic_ip;
+ ASSERT(if (!dir_f) {
+ printk(KERN_ERR "jffs_symlink(): No reference to a "
+ "jffs_file struct in inode.\n");
+ unlock_kernel();
+ return -EIO;
+ });
+
+ c = dir_f->c;
+
+ /* Create a node and initialize it as much as needed. */
+ if (!(node = jffs_alloc_node())) {
+ D(printk("jffs_symlink(): Allocation failed: node = NULL\n"));
+ unlock_kernel();
+ return -ENOMEM;
+ }
+ D3(printk (KERN_NOTICE "symlink(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ node->data_offset = 0;
+ node->removed_size = 0;
+
+ /* Initialize the raw inode. */
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = c->next_ino++;
+ raw_inode.pino = dir_f->ino;
+ raw_inode.version = 1;
+ raw_inode.mode = S_IFLNK | S_IRWXUGO;
+ raw_inode.uid = current->fsuid;
+ raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
+ raw_inode.atime = get_seconds();
+ raw_inode.mtime = raw_inode.atime;
+ raw_inode.ctime = raw_inode.atime;
+ raw_inode.offset = 0;
+ raw_inode.dsize = symname_len;
+ raw_inode.rsize = 0;
+ raw_inode.nsize = dentry->d_name.len;
+ raw_inode.nlink = 1;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = 0;
+
+ /* Write the new node to the flash. */
+ if ((err = jffs_write_node(c, node, &raw_inode, dentry->d_name.name,
+ (const unsigned char *)symname, 0, NULL)) < 0) {
+ D(printk("jffs_symlink(): jffs_write_node() failed.\n"));
+ jffs_free_node(node);
+ goto jffs_symlink_end;
+ }
+
+ /* Insert the new node into the file system. */
+ if ((err = jffs_insert_node(c, NULL, &raw_inode, dentry->d_name.name,
+ node)) < 0) {
+ goto jffs_symlink_end;
+ }
+
+ inode = jffs_new_inode(dir, &raw_inode, &err);
+ if (inode == NULL) {
+ goto jffs_symlink_end;
+ }
+ err = 0;
+ inode->i_op = &page_symlink_inode_operations;
+ inode->i_mapping->a_ops = &jffs_address_operations;
+
+ d_instantiate(dentry, inode);
+ jffs_symlink_end:
+ D3(printk (KERN_NOTICE "symlink(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return err;
+} /* jffs_symlink() */
+
+
+/* Create an inode inside a JFFS directory (dir) and return it.
+ *
+ * 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
+jffs_create(struct inode *dir, struct dentry *dentry, int mode,
+ struct nameidata *nd)
+{
+ struct jffs_raw_inode raw_inode;
+ struct jffs_control *c;
+ struct jffs_node *node;
+ struct jffs_file *dir_f; /* JFFS representation of the directory. */
+ struct inode *inode;
+ int err;
+
+ lock_kernel();
+ D1({
+ int len = dentry->d_name.len;
+ char *s = (char *)kmalloc(len + 1, GFP_KERNEL);
+ memcpy(s, dentry->d_name.name, len);
+ s[len] = '\0';
+ printk("jffs_create(): dir: 0x%p, name: \"%s\"\n", dir, s);
+ kfree(s);
+ });
+
+ dir_f = (struct jffs_file *)dir->u.generic_ip;
+ ASSERT(if (!dir_f) {
+ printk(KERN_ERR "jffs_create(): No reference to a "
+ "jffs_file struct in inode.\n");
+ unlock_kernel();
+ return -EIO;
+ });
+
+ c = dir_f->c;
+
+ /* Create a node and initialize as much as needed. */
+ if (!(node = jffs_alloc_node())) {
+ D(printk("jffs_create(): Allocation failed: node == 0\n"));
+ unlock_kernel();
+ return -ENOMEM;
+ }
+ D3(printk (KERN_NOTICE "create(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ node->data_offset = 0;
+ node->removed_size = 0;
+
+ /* Initialize the raw inode. */
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = c->next_ino++;
+ raw_inode.pino = dir_f->ino;
+ raw_inode.version = 1;
+ raw_inode.mode = mode;
+ raw_inode.uid = current->fsuid;
+ raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
+ raw_inode.atime = get_seconds();
+ raw_inode.mtime = raw_inode.atime;
+ raw_inode.ctime = raw_inode.atime;
+ raw_inode.offset = 0;
+ raw_inode.dsize = 0;
+ raw_inode.rsize = 0;
+ raw_inode.nsize = dentry->d_name.len;
+ raw_inode.nlink = 1;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = 0;
+
+ /* Write the new node to the flash. */
+ if ((err = jffs_write_node(c, node, &raw_inode,
+ dentry->d_name.name, NULL, 0, NULL)) < 0) {
+ D(printk("jffs_create(): jffs_write_node() failed.\n"));
+ jffs_free_node(node);
+ goto jffs_create_end;
+ }
+
+ /* Insert the new node into the file system. */
+ if ((err = jffs_insert_node(c, NULL, &raw_inode, dentry->d_name.name,
+ node)) < 0) {
+ goto jffs_create_end;
+ }
+
+ /* Initialize an inode. */
+ inode = jffs_new_inode(dir, &raw_inode, &err);
+ if (inode == NULL) {
+ goto jffs_create_end;
+ }
+ err = 0;
+ inode->i_op = &jffs_file_inode_operations;
+ inode->i_fop = &jffs_file_operations;
+ inode->i_mapping->a_ops = &jffs_address_operations;
+ inode->i_mapping->nrpages = 0;
+
+ d_instantiate(dentry, inode);
+ jffs_create_end:
+ D3(printk (KERN_NOTICE "create(): up biglock\n"));
+ up(&c->fmc->biglock);
+ unlock_kernel();
+ return err;
+} /* jffs_create() */
+
+
+/* Write, append or rewrite data to an existing file. */
+static ssize_t
+jffs_file_write(struct file *filp, const char *buf, size_t count,
+ loff_t *ppos)
+{
+ struct jffs_raw_inode raw_inode;
+ struct jffs_control *c;
+ struct jffs_file *f;
+ struct jffs_node *node;
+ struct dentry *dentry = filp->f_dentry;
+ struct inode *inode = dentry->d_inode;
+ int recoverable = 0;
+ size_t written = 0;
+ __u32 thiscount = count;
+ loff_t pos = *ppos;
+ int err;
+
+ inode = filp->f_dentry->d_inode;
+
+ D2(printk("***jffs_file_write(): inode: 0x%p (ino: %lu), "
+ "filp: 0x%p, buf: 0x%p, count: %d\n",
+ inode, inode->i_ino, filp, buf, count));
+
+#if 0
+ if (inode->i_sb->s_flags & MS_RDONLY) {
+ D(printk("jffs_file_write(): MS_RDONLY\n"));
+ err = -EROFS;
+ goto out_isem;
+ }
+#endif
+ err = -EINVAL;
+
+ if (!S_ISREG(inode->i_mode)) {
+ D(printk("jffs_file_write(): inode->i_mode == 0x%08x\n",
+ inode->i_mode));
+ goto out_isem;
+ }
+
+ if (!(f = (struct jffs_file *)inode->u.generic_ip)) {
+ D(printk("jffs_file_write(): inode->u.generic_ip = 0x%p\n",
+ inode->u.generic_ip));
+ goto out_isem;
+ }
+
+ c = f->c;
+
+ /*
+ * This will never trigger with sane page sizes. leave it in
+ * anyway, since I'm thinking about how to merge larger writes
+ * (the current idea is to poke a thread that does the actual
+ * I/O and starts by doing a down(&inode->i_sem). then we
+ * would need to get the page cache pages and have a list of
+ * I/O requests and do write-merging here.
+ * -- prumpf
+ */
+ thiscount = min(c->fmc->max_chunk_size - sizeof(struct jffs_raw_inode), count);
+
+ D3(printk (KERN_NOTICE "file_write(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ /* Urgh. POSIX says we can do short writes if we feel like it.
+ * In practice, we can't. Nothing will cope. So we loop until
+ * we're done.
+ *
+ * <_Anarchy_> posix and reality are not interconnected on this issue
+ */
+ while (count) {
+ /* Things are going to be written so we could allocate and
+ initialize the necessary data structures now. */
+ if (!(node = jffs_alloc_node())) {
+ D(printk("jffs_file_write(): node == 0\n"));
+ err = -ENOMEM;
+ goto out;
+ }
+
+ node->data_offset = pos;
+ node->removed_size = 0;
+
+ /* Initialize the raw inode. */
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = f->ino;
+ raw_inode.pino = f->pino;
+
+ raw_inode.mode = f->mode;
+
+ raw_inode.uid = f->uid;
+ raw_inode.gid = f->gid;
+ raw_inode.atime = get_seconds();
+ raw_inode.mtime = raw_inode.atime;
+ raw_inode.ctime = f->ctime;
+ raw_inode.offset = pos;
+ raw_inode.dsize = thiscount;
+ raw_inode.rsize = 0;
+ raw_inode.nsize = f->nsize;
+ raw_inode.nlink = f->nlink;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = 0;
+
+ if (pos < f->size) {
+ node->removed_size = raw_inode.rsize = min(thiscount, (__u32)(f->size - pos));
+
+ /* If this node is going entirely over the top of old data,
+ we can allow it to go into the reserved space, because
+ we know that GC can reclaim the space later.
+ */
+ if (pos + thiscount < f->size) {
+ /* If all the data we're overwriting are _real_,
+ not just holes, then:
+ recoverable = 1;
+ */
+ }
+ }
+
+ /* Write the new node to the flash. */
+ /* NOTE: We would be quite happy if jffs_write_node() wrote a
+ smaller node than we were expecting. There's no need for it
+ to waste the space at the end of the flash just because it's
+ a little smaller than what we asked for. But that's a whole
+ new can of worms which I'm not going to open this week.
+ -- dwmw2.
+ */
+ if ((err = jffs_write_node(c, node, &raw_inode, f->name,
+ (const unsigned char *)buf,
+ recoverable, f)) < 0) {
+ D(printk("jffs_file_write(): jffs_write_node() failed.\n"));
+ jffs_free_node(node);
+ goto out;
+ }
+
+ written += err;
+ buf += err;
+ count -= err;
+ pos += err;
+
+ /* Insert the new node into the file system. */
+ if ((err = jffs_insert_node(c, f, &raw_inode, NULL, node)) < 0) {
+ goto out;
+ }
+
+ D3(printk("jffs_file_write(): new f_pos %ld.\n", (long)pos));
+
+ thiscount = min(c->fmc->max_chunk_size - sizeof(struct jffs_raw_inode), count);
+ }
+ out:
+ D3(printk (KERN_NOTICE "file_write(): up biglock\n"));
+ up(&c->fmc->biglock);
+
+ /* Fix things in the real inode. */
+ if (pos > inode->i_size) {
+ inode->i_size = pos;
+ inode->i_blocks = (inode->i_size + 511) >> 9;
+ }
+ inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+ mark_inode_dirty(inode);
+ invalidate_inode_pages(inode->i_mapping);
+
+ out_isem:
+ return err;
+} /* jffs_file_write() */
+
+static int
+jffs_prepare_write(struct file *filp, struct page *page,
+ unsigned from, unsigned to)
+{
+ /* FIXME: we should detect some error conditions here */
+
+ /* Bugger that. We should make sure the page is uptodate */
+ if (!PageUptodate(page) && (from || to < PAGE_CACHE_SIZE))
+ return jffs_do_readpage_nolock(filp, page);
+
+ return 0;
+} /* jffs_prepare_write() */
+
+static int
+jffs_commit_write(struct file *filp, struct page *page,
+ unsigned from, unsigned to)
+{
+ void *addr = page_address(page) + from;
+ /* XXX: PAGE_CACHE_SHIFT or PAGE_SHIFT */
+ loff_t pos = (page->index<<PAGE_CACHE_SHIFT) + from;
+
+ return jffs_file_write(filp, addr, to-from, &pos);
+} /* jffs_commit_write() */
+
+/* This is our ioctl() routine. */
+static int
+jffs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
+ unsigned long arg)
+{
+ struct jffs_control *c;
+ int ret = 0;
+
+ D2(printk("***jffs_ioctl(): cmd = 0x%08x, arg = 0x%08lx\n",
+ cmd, arg));
+
+ if (!(c = (struct jffs_control *)inode->i_sb->s_fs_info)) {
+ printk(KERN_ERR "JFFS: Bad inode in ioctl() call. "
+ "(cmd = 0x%08x)\n", cmd);
+ return -EIO;
+ }
+ D3(printk (KERN_NOTICE "ioctl(): down biglock\n"));
+ down(&c->fmc->biglock);
+
+ switch (cmd) {
+ case JFFS_PRINT_HASH:
+ jffs_print_hash_table(c);
+ break;
+ case JFFS_PRINT_TREE:
+ jffs_print_tree(c->root, 0);
+ break;
+ case JFFS_GET_STATUS:
+ {
+ struct jffs_flash_status fst;
+ struct jffs_fmcontrol *fmc = c->fmc;
+ printk("Flash status -- ");
+ if (!access_ok(VERIFY_WRITE,
+ (struct jffs_flash_status __user *)arg,
+ sizeof(struct jffs_flash_status))) {
+ D(printk("jffs_ioctl(): Bad arg in "
+ "JFFS_GET_STATUS ioctl!\n"));
+ ret = -EFAULT;
+ break;
+ }
+ fst.size = fmc->flash_size;
+ fst.used = fmc->used_size;
+ fst.dirty = fmc->dirty_size;
+ fst.begin = fmc->head->offset;
+ fst.end = fmc->tail->offset + fmc->tail->size;
+ printk("size: %d, used: %d, dirty: %d, "
+ "begin: %d, end: %d\n",
+ fst.size, fst.used, fst.dirty,
+ fst.begin, fst.end);
+ if (copy_to_user((struct jffs_flash_status __user *)arg,
+ &fst,
+ sizeof(struct jffs_flash_status))) {
+ ret = -EFAULT;
+ }
+ }
+ break;
+ default:
+ ret = -ENOTTY;
+ }
+ D3(printk (KERN_NOTICE "ioctl(): up biglock\n"));
+ up(&c->fmc->biglock);
+ return ret;
+} /* jffs_ioctl() */
+
+
+static struct address_space_operations jffs_address_operations = {
+ .readpage = jffs_readpage,
+ .prepare_write = jffs_prepare_write,
+ .commit_write = jffs_commit_write,
+};
+
+static int jffs_fsync(struct file *f, struct dentry *d, int datasync)
+{
+ /* We currently have O_SYNC operations at all times.
+ Do nothing.
+ */
+ return 0;
+}
+
+
+extern int generic_file_open(struct inode *, struct file *) __attribute__((weak));
+extern loff_t generic_file_llseek(struct file *, loff_t, int) __attribute__((weak));
+
+static struct file_operations jffs_file_operations =
+{
+ .open = generic_file_open,
+ .llseek = generic_file_llseek,
+ .read = generic_file_read,
+ .write = generic_file_write,
+ .ioctl = jffs_ioctl,
+ .mmap = generic_file_readonly_mmap,
+ .fsync = jffs_fsync,
+ .sendfile = generic_file_sendfile,
+};
+
+
+static struct inode_operations jffs_file_inode_operations =
+{
+ .lookup = jffs_lookup, /* lookup */
+ .setattr = jffs_setattr,
+};
+
+
+static struct file_operations jffs_dir_operations =
+{
+ .readdir = jffs_readdir,
+};
+
+
+static struct inode_operations jffs_dir_inode_operations =
+{
+ .create = jffs_create,
+ .lookup = jffs_lookup,
+ .unlink = jffs_unlink,
+ .symlink = jffs_symlink,
+ .mkdir = jffs_mkdir,
+ .rmdir = jffs_rmdir,
+ .mknod = jffs_mknod,
+ .rename = jffs_rename,
+ .setattr = jffs_setattr,
+};
+
+
+/* Initialize an inode for the VFS. */
+static void
+jffs_read_inode(struct inode *inode)
+{
+ struct jffs_file *f;
+ struct jffs_control *c;
+
+ D3(printk("jffs_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
+
+ if (!inode->i_sb) {
+ D(printk("jffs_read_inode(): !inode->i_sb ==> "
+ "No super block!\n"));
+ return;
+ }
+ c = (struct jffs_control *)inode->i_sb->s_fs_info;
+ D3(printk (KERN_NOTICE "read_inode(): down biglock\n"));
+ down(&c->fmc->biglock);
+ if (!(f = jffs_find_file(c, inode->i_ino))) {
+ D(printk("jffs_read_inode(): No such inode (%lu).\n",
+ inode->i_ino));
+ D3(printk (KERN_NOTICE "read_inode(): up biglock\n"));
+ up(&c->fmc->biglock);
+ return;
+ }
+ inode->u.generic_ip = (void *)f;
+ inode->i_mode = f->mode;
+ inode->i_nlink = f->nlink;
+ inode->i_uid = f->uid;
+ inode->i_gid = f->gid;
+ inode->i_size = f->size;
+ inode->i_atime.tv_sec = f->atime;
+ inode->i_mtime.tv_sec = f->mtime;
+ inode->i_ctime.tv_sec = f->ctime;
+ inode->i_atime.tv_nsec =
+ inode->i_mtime.tv_nsec =
+ inode->i_ctime.tv_nsec = 0;
+
+ inode->i_blksize = PAGE_SIZE;
+ inode->i_blocks = (inode->i_size + 511) >> 9;
+ if (S_ISREG(inode->i_mode)) {
+ inode->i_op = &jffs_file_inode_operations;
+ inode->i_fop = &jffs_file_operations;
+ inode->i_mapping->a_ops = &jffs_address_operations;
+ }
+ else if (S_ISDIR(inode->i_mode)) {
+ inode->i_op = &jffs_dir_inode_operations;
+ inode->i_fop = &jffs_dir_operations;
+ }
+ else if (S_ISLNK(inode->i_mode)) {
+ inode->i_op = &page_symlink_inode_operations;
+ inode->i_mapping->a_ops = &jffs_address_operations;
+ }
+ else {
+ /* If the node is a device of some sort, then the number of
+ the device should be read from the flash memory and then
+ added to the inode's i_rdev member. */
+ u16 val;
+ jffs_read_data(f, (char *)&val, 0, 2);
+ init_special_inode(inode, inode->i_mode,
+ old_decode_dev(val));
+ }
+
+ D3(printk (KERN_NOTICE "read_inode(): up biglock\n"));
+ up(&c->fmc->biglock);
+}
+
+
+static void
+jffs_delete_inode(struct inode *inode)
+{
+ struct jffs_file *f;
+ struct jffs_control *c;
+ D3(printk("jffs_delete_inode(): inode->i_ino == %lu\n",
+ inode->i_ino));
+
+ lock_kernel();
+ inode->i_size = 0;
+ inode->i_blocks = 0;
+ inode->u.generic_ip = NULL;
+ clear_inode(inode);
+ if (inode->i_nlink == 0) {
+ c = (struct jffs_control *) inode->i_sb->s_fs_info;
+ f = (struct jffs_file *) jffs_find_file (c, inode->i_ino);
+ jffs_possibly_delete_file(f);
+ }
+
+ unlock_kernel();
+}
+
+
+static void
+jffs_write_super(struct super_block *sb)
+{
+ struct jffs_control *c = (struct jffs_control *)sb->s_fs_info;
+ lock_kernel();
+ jffs_garbage_collect_trigger(c);
+ unlock_kernel();
+}
+
+static int jffs_remount(struct super_block *sb, int *flags, char *data)
+{
+ *flags |= MS_NODIRATIME;
+ return 0;
+}
+
+static struct super_operations jffs_ops =
+{
+ .read_inode = jffs_read_inode,
+ .delete_inode = jffs_delete_inode,
+ .put_super = jffs_put_super,
+ .write_super = jffs_write_super,
+ .statfs = jffs_statfs,
+ .remount_fs = jffs_remount,
+};
+
+static struct super_block *jffs_get_sb(struct file_system_type *fs_type,
+ int flags, const char *dev_name, void *data)
+{
+ return get_sb_bdev(fs_type, flags, dev_name, data, jffs_fill_super);
+}
+
+static struct file_system_type jffs_fs_type = {
+ .owner = THIS_MODULE,
+ .name = "jffs",
+ .get_sb = jffs_get_sb,
+ .kill_sb = kill_block_super,
+ .fs_flags = FS_REQUIRES_DEV,
+};
+
+static int __init
+init_jffs_fs(void)
+{
+ printk(KERN_INFO "JFFS version " JFFS_VERSION_STRING
+ ", (C) 1999, 2000 Axis Communications AB\n");
+
+#ifdef CONFIG_JFFS_PROC_FS
+ jffs_proc_root = proc_mkdir("jffs", proc_root_fs);
+ if (!jffs_proc_root) {
+ printk(KERN_WARNING "cannot create /proc/jffs entry\n");
+ }
+#endif
+ fm_cache = kmem_cache_create("jffs_fm", sizeof(struct jffs_fm),
+ 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
+ NULL, NULL);
+ if (!fm_cache) {
+ return -ENOMEM;
+ }
+
+ node_cache = kmem_cache_create("jffs_node",sizeof(struct jffs_node),
+ 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
+ NULL, NULL);
+ if (!node_cache) {
+ kmem_cache_destroy(fm_cache);
+ return -ENOMEM;
+ }
+
+ return register_filesystem(&jffs_fs_type);
+}
+
+static void __exit
+exit_jffs_fs(void)
+{
+ unregister_filesystem(&jffs_fs_type);
+ kmem_cache_destroy(fm_cache);
+ kmem_cache_destroy(node_cache);
+}
+
+module_init(init_jffs_fs)
+module_exit(exit_jffs_fs)
+
+MODULE_DESCRIPTION("The Journalling Flash File System");
+MODULE_AUTHOR("Axis Communications AB.");
+MODULE_LICENSE("GPL");
diff --git a/fs/jffs/intrep.c b/fs/jffs/intrep.c
new file mode 100644
index 0000000..8cc6893
--- /dev/null
+++ b/fs/jffs/intrep.c
@@ -0,0 +1,3457 @@
+/*
+ * JFFS -- Journaling Flash File System, Linux implementation.
+ *
+ * Copyright (C) 1999, 2000 Axis Communications, Inc.
+ *
+ * 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: intrep.c,v 1.102 2001/09/23 23:28:36 dwmw2 Exp $
+ *
+ * Ported to Linux 2.3.x and MTD:
+ * Copyright (C) 2000 Alexander Larsson (alex@cendio.se), Cendio Systems AB
+ *
+ */
+
+/* This file contains the code for the internal structure of the
+ Journaling Flash File System, JFFS. */
+
+/*
+ * Todo list:
+ *
+ * memcpy_to_flash() and memcpy_from_flash() functions.
+ *
+ * Implementation of hard links.
+ *
+ * Organize the source code in a better way. Against the VFS we could
+ * have jffs_ext.c, and against the block device jffs_int.c.
+ * A better file-internal organization too.
+ *
+ * A better checksum algorithm.
+ *
+ * Consider endianness stuff. ntohl() etc.
+ *
+ * Are we handling the atime, mtime, ctime members of the inode right?
+ *
+ * Remove some duplicated code. Take a look at jffs_write_node() and
+ * jffs_rewrite_data() for instance.
+ *
+ * Implement more meaning of the nlink member in various data structures.
+ * nlink could be used in conjunction with hard links for instance.
+ *
+ * Better memory management. Allocate data structures in larger chunks
+ * if possible.
+ *
+ * If too much meta data is stored, a garbage collect should be issued.
+ * We have experienced problems with too much meta data with for instance
+ * log files.
+ *
+ * Improve the calls to jffs_ioctl(). We would like to retrieve more
+ * information to be able to debug (or to supervise) JFFS during run-time.
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/jffs.h>
+#include <linux/fs.h>
+#include <linux/stat.h>
+#include <linux/pagemap.h>
+#include <asm/semaphore.h>
+#include <asm/byteorder.h>
+#include <linux/smp_lock.h>
+#include <linux/time.h>
+#include <linux/ctype.h>
+
+#include "intrep.h"
+#include "jffs_fm.h"
+
+long no_jffs_node = 0;
+static long no_jffs_file = 0;
+#if defined(JFFS_MEMORY_DEBUG) && JFFS_MEMORY_DEBUG
+long no_jffs_control = 0;
+long no_jffs_raw_inode = 0;
+long no_jffs_node_ref = 0;
+long no_jffs_fm = 0;
+long no_jffs_fmcontrol = 0;
+long no_hash = 0;
+long no_name = 0;
+#endif
+
+static int jffs_scan_flash(struct jffs_control *c);
+static int jffs_update_file(struct jffs_file *f, struct jffs_node *node);
+static int jffs_build_file(struct jffs_file *f);
+static int jffs_free_file(struct jffs_file *f);
+static int jffs_free_node_list(struct jffs_file *f);
+static int jffs_garbage_collect_now(struct jffs_control *c);
+static int jffs_insert_file_into_hash(struct jffs_file *f);
+static int jffs_remove_redundant_nodes(struct jffs_file *f);
+
+/* Is there enough space on the flash? */
+static inline int JFFS_ENOUGH_SPACE(struct jffs_control *c, __u32 space)
+{
+ struct jffs_fmcontrol *fmc = c->fmc;
+
+ while (1) {
+ if ((fmc->flash_size - (fmc->used_size + fmc->dirty_size))
+ >= fmc->min_free_size + space) {
+ return 1;
+ }
+ if (fmc->dirty_size < fmc->sector_size)
+ return 0;
+
+ if (jffs_garbage_collect_now(c)) {
+ D1(printk("JFFS_ENOUGH_SPACE: jffs_garbage_collect_now() failed.\n"));
+ return 0;
+ }
+ }
+}
+
+#if CONFIG_JFFS_FS_VERBOSE > 0
+static __u8
+flash_read_u8(struct mtd_info *mtd, loff_t from)
+{
+ size_t retlen;
+ __u8 ret;
+ int res;
+
+ res = MTD_READ(mtd, from, 1, &retlen, &ret);
+ if (retlen != 1) {
+ printk("Didn't read a byte in flash_read_u8(). Returned %d\n", res);
+ return 0;
+ }
+
+ return ret;
+}
+
+static void
+jffs_hexdump(struct mtd_info *mtd, loff_t pos, int size)
+{
+ char line[16];
+ int j = 0;
+
+ while (size > 0) {
+ int i;
+
+ printk("%ld:", (long) pos);
+ for (j = 0; j < 16; j++) {
+ line[j] = flash_read_u8(mtd, pos++);
+ }
+ for (i = 0; i < j; i++) {
+ if (!(i & 1)) {
+ printk(" %.2x", line[i] & 0xff);
+ }
+ else {
+ printk("%.2x", line[i] & 0xff);
+ }
+ }
+
+ /* Print empty space */
+ for (; i < 16; i++) {
+ if (!(i & 1)) {
+ printk(" ");
+ }
+ else {
+ printk(" ");
+ }
+ }
+ printk(" ");
+
+ for (i = 0; i < j; i++) {
+ if (isgraph(line[i])) {
+ printk("%c", line[i]);
+ }
+ else {
+ printk(".");
+ }
+ }
+ printk("\n");
+ size -= 16;
+ }
+}
+
+#endif
+
+#define flash_safe_acquire(arg)
+#define flash_safe_release(arg)
+
+
+static int
+flash_safe_read(struct mtd_info *mtd, loff_t from,
+ u_char *buf, size_t count)
+{
+ size_t retlen;
+ int res;
+
+ D3(printk(KERN_NOTICE "flash_safe_read(%p, %08x, %p, %08x)\n",
+ mtd, (unsigned int) from, buf, count));
+
+ res = MTD_READ(mtd, from, count, &retlen, buf);
+ if (retlen != count) {
+ panic("Didn't read all bytes in flash_safe_read(). Returned %d\n", res);
+ }
+ return res?res:retlen;
+}
+
+
+static __u32
+flash_read_u32(struct mtd_info *mtd, loff_t from)
+{
+ size_t retlen;
+ __u32 ret;
+ int res;
+
+ res = MTD_READ(mtd, from, 4, &retlen, (unsigned char *)&ret);
+ if (retlen != 4) {
+ printk("Didn't read all bytes in flash_read_u32(). Returned %d\n", res);
+ return 0;
+ }
+
+ return ret;
+}
+
+
+static int
+flash_safe_write(struct mtd_info *mtd, loff_t to,
+ const u_char *buf, size_t count)
+{
+ size_t retlen;
+ int res;
+
+ D3(printk(KERN_NOTICE "flash_safe_write(%p, %08x, %p, %08x)\n",
+ mtd, (unsigned int) to, buf, count));
+
+ res = MTD_WRITE(mtd, to, count, &retlen, buf);
+ if (retlen != count) {
+ printk("Didn't write all bytes in flash_safe_write(). Returned %d\n", res);
+ }
+ return res?res:retlen;
+}
+
+
+static int
+flash_safe_writev(struct mtd_info *mtd, const struct kvec *vecs,
+ unsigned long iovec_cnt, loff_t to)
+{
+ size_t retlen, retlen_a;
+ int i;
+ int res;
+
+ D3(printk(KERN_NOTICE "flash_safe_writev(%p, %08x, %p)\n",
+ mtd, (unsigned int) to, vecs));
+
+ if (mtd->writev) {
+ res = MTD_WRITEV(mtd, vecs, iovec_cnt, to, &retlen);
+ return res ? res : retlen;
+ }
+ /* Not implemented writev. Repeatedly use write - on the not so
+ unreasonable assumption that the mtd driver doesn't care how
+ many write cycles we use. */
+ res=0;
+ retlen=0;
+
+ for (i=0; !res && i<iovec_cnt; i++) {
+ res = MTD_WRITE(mtd, to, vecs[i].iov_len, &retlen_a, vecs[i].iov_base);
+ if (retlen_a != vecs[i].iov_len) {
+ printk("Didn't write all bytes in flash_safe_writev(). Returned %d\n", res);
+ if (i != iovec_cnt-1)
+ return -EIO;
+ }
+ /* If res is non-zero, retlen_a is undefined, but we don't
+ care because in that case it's not going to be
+ returned anyway.
+ */
+ to += retlen_a;
+ retlen += retlen_a;
+ }
+ return res?res:retlen;
+}
+
+
+static int
+flash_memset(struct mtd_info *mtd, loff_t to,
+ const u_char c, size_t size)
+{
+ static unsigned char pattern[64];
+ int i;
+
+ /* fill up pattern */
+
+ for(i = 0; i < 64; i++)
+ pattern[i] = c;
+
+ /* write as many 64-byte chunks as we can */
+
+ while (size >= 64) {
+ flash_safe_write(mtd, to, pattern, 64);
+ size -= 64;
+ to += 64;
+ }
+
+ /* and the rest */
+
+ if(size)
+ flash_safe_write(mtd, to, pattern, size);
+
+ return size;
+}
+
+
+static void
+intrep_erase_callback(struct erase_info *done)
+{
+ wait_queue_head_t *wait_q;
+
+ wait_q = (wait_queue_head_t *)done->priv;
+
+ wake_up(wait_q);
+}
+
+
+static int
+flash_erase_region(struct mtd_info *mtd, loff_t start,
+ size_t size)
+{
+ struct erase_info *erase;
+ DECLARE_WAITQUEUE(wait, current);
+ wait_queue_head_t wait_q;
+
+ erase = kmalloc(sizeof(struct erase_info), GFP_KERNEL);
+ if (!erase)
+ return -ENOMEM;
+
+ init_waitqueue_head(&wait_q);
+
+ erase->mtd = mtd;
+ erase->callback = intrep_erase_callback;
+ erase->addr = start;
+ erase->len = size;
+ erase->priv = (u_long)&wait_q;
+
+ /* FIXME: Use TASK_INTERRUPTIBLE and deal with being interrupted */
+ set_current_state(TASK_UNINTERRUPTIBLE);
+ add_wait_queue(&wait_q, &wait);
+
+ if (MTD_ERASE(mtd, erase) < 0) {
+ set_current_state(TASK_RUNNING);
+ remove_wait_queue(&wait_q, &wait);
+ kfree(erase);
+
+ printk(KERN_WARNING "flash: erase of region [0x%lx, 0x%lx] "
+ "totally failed\n", (long)start, (long)start + size);
+
+ return -1;
+ }
+
+ schedule(); /* Wait for flash to finish. */
+ remove_wait_queue(&wait_q, &wait);
+
+ kfree(erase);
+
+ return 0;
+}
+
+/* This routine calculates checksums in JFFS. */
+static __u32
+jffs_checksum(const void *data, int size)
+{
+ __u32 sum = 0;
+ __u8 *ptr = (__u8 *)data;
+ while (size-- > 0) {
+ sum += *ptr++;
+ }
+ D3(printk(", result: 0x%08x\n", sum));
+ return sum;
+}
+
+
+static int
+jffs_checksum_flash(struct mtd_info *mtd, loff_t start, int size, __u32 *result)
+{
+ __u32 sum = 0;
+ loff_t ptr = start;
+ __u8 *read_buf;
+ int i, length;
+
+ /* Allocate read buffer */
+ read_buf = (__u8 *) kmalloc (sizeof(__u8) * 4096, GFP_KERNEL);
+ if (!read_buf) {
+ printk(KERN_NOTICE "kmalloc failed in jffs_checksum_flash()\n");
+ return -ENOMEM;
+ }
+ /* Loop until checksum done */
+ while (size) {
+ /* Get amount of data to read */
+ if (size < 4096)
+ length = size;
+ else
+ length = 4096;
+
+ /* Perform flash read */
+ D3(printk(KERN_NOTICE "jffs_checksum_flash\n"));
+ flash_safe_read(mtd, ptr, &read_buf[0], length);
+
+ /* Compute checksum */
+ for (i=0; i < length ; i++)
+ sum += read_buf[i];
+
+ /* Update pointer and size */
+ size -= length;
+ ptr += length;
+ }
+
+ /* Free read buffer */
+ kfree (read_buf);
+
+ /* Return result */
+ D3(printk("checksum result: 0x%08x\n", sum));
+ *result = sum;
+ return 0;
+}
+
+static __inline__ void jffs_fm_write_lock(struct jffs_fmcontrol *fmc)
+{
+ // down(&fmc->wlock);
+}
+
+static __inline__ void jffs_fm_write_unlock(struct jffs_fmcontrol *fmc)
+{
+ // up(&fmc->wlock);
+}
+
+
+/* Create and initialize a new struct jffs_file. */
+static struct jffs_file *
+jffs_create_file(struct jffs_control *c,
+ const struct jffs_raw_inode *raw_inode)
+{
+ struct jffs_file *f;
+
+ if (!(f = (struct jffs_file *)kmalloc(sizeof(struct jffs_file),
+ GFP_KERNEL))) {
+ D(printk("jffs_create_file(): Failed!\n"));
+ return NULL;
+ }
+ no_jffs_file++;
+ memset(f, 0, sizeof(struct jffs_file));
+ f->ino = raw_inode->ino;
+ f->pino = raw_inode->pino;
+ f->nlink = raw_inode->nlink;
+ f->deleted = raw_inode->deleted;
+ f->c = c;
+
+ return f;
+}
+
+
+/* Build a control block for the file system. */
+static struct jffs_control *
+jffs_create_control(struct super_block *sb)
+{
+ struct jffs_control *c;
+ register int s = sizeof(struct jffs_control);
+ int i;
+ D(char *t = 0);
+
+ D2(printk("jffs_create_control()\n"));
+
+ if (!(c = (struct jffs_control *)kmalloc(s, GFP_KERNEL))) {
+ goto fail_control;
+ }
+ DJM(no_jffs_control++);
+ c->root = NULL;
+ c->gc_task = NULL;
+ c->hash_len = JFFS_HASH_SIZE;
+ s = sizeof(struct list_head) * c->hash_len;
+ if (!(c->hash = (struct list_head *)kmalloc(s, GFP_KERNEL))) {
+ goto fail_hash;
+ }
+ DJM(no_hash++);
+ for (i = 0; i < c->hash_len; i++)
+ INIT_LIST_HEAD(&c->hash[i]);
+ if (!(c->fmc = jffs_build_begin(c, MINOR(sb->s_dev)))) {
+ goto fail_fminit;
+ }
+ c->next_ino = JFFS_MIN_INO + 1;
+ c->delete_list = (struct jffs_delete_list *) 0;
+ return c;
+
+fail_fminit:
+ D(t = "c->fmc");
+fail_hash:
+ kfree(c);
+ DJM(no_jffs_control--);
+ D(t = t ? t : "c->hash");
+fail_control:
+ D(t = t ? t : "control");
+ D(printk("jffs_create_control(): Allocation failed: (%s)\n", t));
+ return (struct jffs_control *)0;
+}
+
+
+/* Clean up all data structures associated with the file system. */
+void
+jffs_cleanup_control(struct jffs_control *c)
+{
+ D2(printk("jffs_cleanup_control()\n"));
+
+ if (!c) {
+ D(printk("jffs_cleanup_control(): c == NULL !!!\n"));
+ return;
+ }
+
+ while (c->delete_list) {
+ struct jffs_delete_list *delete_list_element;
+ delete_list_element = c->delete_list;
+ c->delete_list = c->delete_list->next;
+ kfree(delete_list_element);
+ }
+
+ /* Free all files and nodes. */
+ if (c->hash) {
+ jffs_foreach_file(c, jffs_free_node_list);
+ jffs_foreach_file(c, jffs_free_file);
+ kfree(c->hash);
+ DJM(no_hash--);
+ }
+ jffs_cleanup_fmcontrol(c->fmc);
+ kfree(c);
+ DJM(no_jffs_control--);
+ D3(printk("jffs_cleanup_control(): Leaving...\n"));
+}
+
+
+/* This function adds a virtual root node to the in-RAM representation.
+ Called by jffs_build_fs(). */
+static int
+jffs_add_virtual_root(struct jffs_control *c)
+{
+ struct jffs_file *root;
+ struct jffs_node *node;
+
+ D2(printk("jffs_add_virtual_root(): "
+ "Creating a virtual root directory.\n"));
+
+ if (!(root = (struct jffs_file *)kmalloc(sizeof(struct jffs_file),
+ GFP_KERNEL))) {
+ return -ENOMEM;
+ }
+ no_jffs_file++;
+ if (!(node = jffs_alloc_node())) {
+ kfree(root);
+ no_jffs_file--;
+ return -ENOMEM;
+ }
+ DJM(no_jffs_node++);
+ memset(node, 0, sizeof(struct jffs_node));
+ node->ino = JFFS_MIN_INO;
+ memset(root, 0, sizeof(struct jffs_file));
+ root->ino = JFFS_MIN_INO;
+ root->mode = S_IFDIR | S_IRWXU | S_IRGRP
+ | S_IXGRP | S_IROTH | S_IXOTH;
+ root->atime = root->mtime = root->ctime = get_seconds();
+ root->nlink = 1;
+ root->c = c;
+ root->version_head = root->version_tail = node;
+ jffs_insert_file_into_hash(root);
+ return 0;
+}
+
+
+/* This is where the file system is built and initialized. */
+int
+jffs_build_fs(struct super_block *sb)
+{
+ struct jffs_control *c;
+ int err = 0;
+
+ D2(printk("jffs_build_fs()\n"));
+
+ if (!(c = jffs_create_control(sb))) {
+ return -ENOMEM;
+ }
+ c->building_fs = 1;
+ c->sb = sb;
+ if ((err = jffs_scan_flash(c)) < 0) {
+ if(err == -EAGAIN){
+ /* scan_flash() wants us to try once more. A flipping
+ bits sector was detect in the middle of the scan flash.
+ Clean up old allocated memory before going in.
+ */
+ D1(printk("jffs_build_fs: Cleaning up all control structures,"
+ " reallocating them and trying mount again.\n"));
+ jffs_cleanup_control(c);
+ if (!(c = jffs_create_control(sb))) {
+ return -ENOMEM;
+ }
+ c->building_fs = 1;
+ c->sb = sb;
+
+ if ((err = jffs_scan_flash(c)) < 0) {
+ goto jffs_build_fs_fail;
+ }
+ }else{
+ goto jffs_build_fs_fail;
+ }
+ }
+
+ /* Add a virtual root node if no one exists. */
+ if (!jffs_find_file(c, JFFS_MIN_INO)) {
+ if ((err = jffs_add_virtual_root(c)) < 0) {
+ goto jffs_build_fs_fail;
+ }
+ }
+
+ while (c->delete_list) {
+ struct jffs_file *f;
+ struct jffs_delete_list *delete_list_element;
+
+ if ((f = jffs_find_file(c, c->delete_list->ino))) {
+ f->deleted = 1;
+ }
+ delete_list_element = c->delete_list;
+ c->delete_list = c->delete_list->next;
+ kfree(delete_list_element);
+ }
+
+ /* Remove deleted nodes. */
+ if ((err = jffs_foreach_file(c, jffs_possibly_delete_file)) < 0) {
+ printk(KERN_ERR "JFFS: Failed to remove deleted nodes.\n");
+ goto jffs_build_fs_fail;
+ }
+ /* Remove redundant nodes. (We are not interested in the
+ return value in this case.) */
+ jffs_foreach_file(c, jffs_remove_redundant_nodes);
+ /* Try to build a tree from all the nodes. */
+ if ((err = jffs_foreach_file(c, jffs_insert_file_into_tree)) < 0) {
+ printk("JFFS: Failed to build tree.\n");
+ goto jffs_build_fs_fail;
+ }
+ /* Compute the sizes of all files in the filesystem. Adjust if
+ necessary. */
+ if ((err = jffs_foreach_file(c, jffs_build_file)) < 0) {
+ printk("JFFS: Failed to build file system.\n");
+ goto jffs_build_fs_fail;
+ }
+ sb->s_fs_info = (void *)c;
+ c->building_fs = 0;
+
+ D1(jffs_print_hash_table(c));
+ D1(jffs_print_tree(c->root, 0));
+
+ return 0;
+
+jffs_build_fs_fail:
+ jffs_cleanup_control(c);
+ return err;
+} /* jffs_build_fs() */
+
+
+/*
+ This checks for sectors that were being erased in their previous
+ lifetimes and for some reason or the other (power fail etc.),
+ the erase cycles never completed.
+ As the flash array would have reverted back to read status,
+ these sectors are detected by the symptom of the "flipping bits",
+ i.e. bits being read back differently from the same location in
+ flash if read multiple times.
+ The only solution to this is to re-erase the entire
+ sector.
+ Unfortunately detecting "flipping bits" is not a simple exercise
+ as a bit may be read back at 1 or 0 depending on the alignment
+ of the stars in the universe.
+ The level of confidence is in direct proportion to the number of
+ scans done. By power fail testing I (Vipin) have been able to
+ proove that reading twice is not enough.
+ Maybe 4 times? Change NUM_REREADS to a higher number if you want
+ a (even) higher degree of confidence in your mount process.
+ A higher number would of course slow down your mount.
+*/
+static int check_partly_erased_sectors(struct jffs_fmcontrol *fmc){
+
+#define NUM_REREADS 4 /* see note above */
+#define READ_AHEAD_BYTES 4096 /* must be a multiple of 4,
+ usually set to kernel page size */
+
+ __u8 *read_buf1;
+ __u8 *read_buf2;
+
+ int err = 0;
+ int retlen;
+ int i;
+ int cnt;
+ __u32 offset;
+ loff_t pos = 0;
+ loff_t end = fmc->flash_size;
+
+
+ /* Allocate read buffers */
+ read_buf1 = (__u8 *) kmalloc (sizeof(__u8) * READ_AHEAD_BYTES, GFP_KERNEL);
+ if (!read_buf1)
+ return -ENOMEM;
+
+ read_buf2 = (__u8 *) kmalloc (sizeof(__u8) * READ_AHEAD_BYTES, GFP_KERNEL);
+ if (!read_buf2) {
+ kfree(read_buf1);
+ return -ENOMEM;
+ }
+
+ CHECK_NEXT:
+ while(pos < end){
+
+ D1(printk("check_partly_erased_sector():checking sector which contains"
+ " offset 0x%x for flipping bits..\n", (__u32)pos));
+
+ retlen = flash_safe_read(fmc->mtd, pos,
+ &read_buf1[0], READ_AHEAD_BYTES);
+ retlen &= ~3;
+
+ for(cnt = 0; cnt < NUM_REREADS; cnt++){
+ (void)flash_safe_read(fmc->mtd, pos,
+ &read_buf2[0], READ_AHEAD_BYTES);
+
+ for (i=0 ; i < retlen ; i+=4) {
+ /* buffers MUST match, double word for word! */
+ if(*((__u32 *) &read_buf1[i]) !=
+ *((__u32 *) &read_buf2[i])
+ ){
+ /* flipping bits detected, time to erase sector */
+ /* This will help us log some statistics etc. */
+ D1(printk("Flipping bits detected in re-read round:%i of %i\n",
+ cnt, NUM_REREADS));
+ D1(printk("check_partly_erased_sectors:flipping bits detected"
+ " @offset:0x%x(0x%x!=0x%x)\n",
+ (__u32)pos+i, *((__u32 *) &read_buf1[i]),
+ *((__u32 *) &read_buf2[i])));
+
+ /* calculate start of present sector */
+ offset = (((__u32)pos+i)/(__u32)fmc->sector_size) * (__u32)fmc->sector_size;
+
+ D1(printk("check_partly_erased_sector():erasing sector starting 0x%x.\n",
+ offset));
+
+ if (flash_erase_region(fmc->mtd,
+ offset, fmc->sector_size) < 0) {
+ printk(KERN_ERR "JFFS: Erase of flash failed. "
+ "offset = %u, erase_size = %d\n",
+ offset , fmc->sector_size);
+
+ err = -EIO;
+ goto returnBack;
+
+ }else{
+ D1(printk("JFFS: Erase of flash sector @0x%x successful.\n",
+ offset));
+ /* skip ahead to the next sector */
+ pos = (((__u32)pos+i)/(__u32)fmc->sector_size) * (__u32)fmc->sector_size;
+ pos += fmc->sector_size;
+ goto CHECK_NEXT;
+ }
+ }
+ }
+ }
+ pos += READ_AHEAD_BYTES;
+ }
+
+ returnBack:
+ kfree(read_buf1);
+ kfree(read_buf2);
+
+ D2(printk("check_partly_erased_sector():Done checking all sectors till offset 0x%x for flipping bits.\n",
+ (__u32)pos));
+
+ return err;
+
+}/* end check_partly_erased_sectors() */
+
+
+
+/* Scan the whole flash memory in order to find all nodes in the
+ file systems. */
+static int
+jffs_scan_flash(struct jffs_control *c)
+{
+ char name[JFFS_MAX_NAME_LEN + 2];
+ struct jffs_raw_inode raw_inode;
+ struct jffs_node *node = NULL;
+ struct jffs_fmcontrol *fmc = c->fmc;
+ __u32 checksum;
+ __u8 tmp_accurate;
+ __u16 tmp_chksum;
+ __u32 deleted_file;
+ loff_t pos = 0;
+ loff_t start;
+ loff_t test_start;
+ loff_t end = fmc->flash_size;
+ __u8 *read_buf;
+ int i, len, retlen;
+ __u32 offset;
+
+ __u32 free_chunk_size1;
+ __u32 free_chunk_size2;
+
+
+#define NUMFREEALLOWED 2 /* 2 chunks of at least erase size space allowed */
+ int num_free_space = 0; /* Flag err if more than TWO
+ free blocks found. This is NOT allowed
+ by the current jffs design.
+ */
+ int num_free_spc_not_accp = 0; /* For debugging purposed keep count
+ of how much free space was rejected and
+ marked dirty
+ */
+
+ D1(printk("jffs_scan_flash(): start pos = 0x%lx, end = 0x%lx\n",
+ (long)pos, (long)end));
+
+ flash_safe_acquire(fmc->mtd);
+
+ /*
+ check and make sure that any sector does not suffer
+ from the "partly erased, bit flipping syndrome" (TM Vipin :)
+ If so, offending sectors will be erased.
+ */
+ if(check_partly_erased_sectors(fmc) < 0){
+
+ flash_safe_release(fmc->mtd);
+ return -EIO; /* bad, bad, bad error. Cannot continue.*/
+ }
+
+ /* Allocate read buffer */
+ read_buf = (__u8 *) kmalloc (sizeof(__u8) * 4096, GFP_KERNEL);
+ if (!read_buf) {
+ flash_safe_release(fmc->mtd);
+ return -ENOMEM;
+ }
+
+ /* Start the scan. */
+ while (pos < end) {
+ deleted_file = 0;
+
+ /* Remember the position from where we started this scan. */
+ start = pos;
+
+ switch (flash_read_u32(fmc->mtd, pos)) {
+ case JFFS_EMPTY_BITMASK:
+ /* We have found 0xffffffff at this position. We have to
+ scan the rest of the flash till the end or till
+ something else than 0xffffffff is found.
+ Keep going till we do not find JFFS_EMPTY_BITMASK
+ anymore */
+
+ D1(printk("jffs_scan_flash(): 0xffffffff at pos 0x%lx.\n",
+ (long)pos));
+
+ while(pos < end){
+
+ len = end - pos < 4096 ? end - pos : 4096;
+
+ retlen = flash_safe_read(fmc->mtd, pos,
+ &read_buf[0], len);
+
+ retlen &= ~3;
+
+ for (i=0 ; i < retlen ; i+=4, pos += 4) {
+ if(*((__u32 *) &read_buf[i]) !=
+ JFFS_EMPTY_BITMASK)
+ break;
+ }
+ if (i == retlen)
+ continue;
+ else
+ break;
+ }
+
+ D1(printk("jffs_scan_flash():0xffffffff ended at pos 0x%lx.\n",
+ (long)pos));
+
+ /* If some free space ends in the middle of a sector,
+ treat it as dirty rather than clean.
+ This is to handle the case where one thread
+ allocated space for a node, but didn't get to
+ actually _write_ it before power was lost, leaving
+ a gap in the log. Shifting all node writes into
+ a single kernel thread will fix the original problem.
+ */
+ if ((__u32) pos % fmc->sector_size) {
+ /* If there was free space in previous
+ sectors, don't mark that dirty too -
+ only from the beginning of this sector
+ (or from start)
+ */
+
+ test_start = pos & ~(fmc->sector_size-1); /* end of last sector */
+
+ if (start < test_start) {
+
+ /* free space started in the previous sector! */
+
+ if((num_free_space < NUMFREEALLOWED) &&
+ ((unsigned int)(test_start - start) >= fmc->sector_size)){
+
+ /*
+ Count it in if we are still under NUMFREEALLOWED *and* it is
+ at least 1 erase sector in length. This will keep us from
+ picking any little ole' space as "free".
+ */
+
+ D1(printk("Reducing end of free space to 0x%x from 0x%x\n",
+ (unsigned int)test_start, (unsigned int)pos));
+
+ D1(printk("Free space accepted: Starting 0x%x for 0x%x bytes\n",
+ (unsigned int) start,
+ (unsigned int)(test_start - start)));
+
+ /* below, space from "start" to "pos" will be marked dirty. */
+ start = test_start;
+
+ /* Being in here means that we have found at least an entire
+ erase sector size of free space ending on a sector boundary.
+ Keep track of free spaces accepted.
+ */
+ num_free_space++;
+ }else{
+ num_free_spc_not_accp++;
+ D1(printk("Free space (#%i) found but *Not* accepted: Starting"
+ " 0x%x for 0x%x bytes\n",
+ num_free_spc_not_accp, (unsigned int)start,
+ (unsigned int)((unsigned int)(pos & ~(fmc->sector_size-1)) - (unsigned int)start)));
+
+ }
+
+ }
+ if((((__u32)(pos - start)) != 0)){
+
+ D1(printk("Dirty space: Starting 0x%x for 0x%x bytes\n",
+ (unsigned int) start, (unsigned int) (pos - start)));
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start), NULL);
+ }else{
+ /* "Flipping bits" detected. This means that our scan for them
+ did not catch this offset. See check_partly_erased_sectors() for
+ more info.
+ */
+
+ D1(printk("jffs_scan_flash():wants to allocate dirty flash "
+ "space for 0 bytes.\n"));
+ D1(printk("jffs_scan_flash(): Flipping bits! We will free "
+ "all allocated memory, erase this sector and remount\n"));
+
+ /* calculate start of present sector */
+ offset = (((__u32)pos)/(__u32)fmc->sector_size) * (__u32)fmc->sector_size;
+
+ D1(printk("jffs_scan_flash():erasing sector starting 0x%x.\n",
+ offset));
+
+ if (flash_erase_region(fmc->mtd,
+ offset, fmc->sector_size) < 0) {
+ printk(KERN_ERR "JFFS: Erase of flash failed. "
+ "offset = %u, erase_size = %d\n",
+ offset , fmc->sector_size);
+
+ flash_safe_release(fmc->mtd);
+ kfree (read_buf);
+ return -1; /* bad, bad, bad! */
+
+ }
+ flash_safe_release(fmc->mtd);
+ kfree (read_buf);
+
+ return -EAGAIN; /* erased offending sector. Try mount one more time please. */
+ }
+ }else{
+ /* Being in here means that we have found free space that ends on an erase sector
+ boundary.
+ Count it in if we are still under NUMFREEALLOWED *and* it is at least 1 erase
+ sector in length. This will keep us from picking any little ole' space as "free".
+ */
+ if((num_free_space < NUMFREEALLOWED) &&
+ ((unsigned int)(pos - start) >= fmc->sector_size)){
+ /* We really don't do anything to mark space as free, except *not*
+ mark it dirty and just advance the "pos" location pointer.
+ It will automatically be picked up as free space.
+ */
+ num_free_space++;
+ D1(printk("Free space accepted: Starting 0x%x for 0x%x bytes\n",
+ (unsigned int) start, (unsigned int) (pos - start)));
+ }else{
+ num_free_spc_not_accp++;
+ D1(printk("Free space (#%i) found but *Not* accepted: Starting "
+ "0x%x for 0x%x bytes\n", num_free_spc_not_accp,
+ (unsigned int) start,
+ (unsigned int) (pos - start)));
+
+ /* Mark this space as dirty. We already have our free space. */
+ D1(printk("Dirty space: Starting 0x%x for 0x%x bytes\n",
+ (unsigned int) start, (unsigned int) (pos - start)));
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start), NULL);
+ }
+
+ }
+ if(num_free_space > NUMFREEALLOWED){
+ printk(KERN_WARNING "jffs_scan_flash(): Found free space "
+ "number %i. Only %i free space is allowed.\n",
+ num_free_space, NUMFREEALLOWED);
+ }
+ continue;
+
+ case JFFS_DIRTY_BITMASK:
+ /* We have found 0x00000000 at this position. Scan as far
+ as possible to find out how much is dirty. */
+ D1(printk("jffs_scan_flash(): 0x00000000 at pos 0x%lx.\n",
+ (long)pos));
+ for (; pos < end
+ && JFFS_DIRTY_BITMASK == flash_read_u32(fmc->mtd, pos);
+ pos += 4);
+ D1(printk("jffs_scan_flash(): 0x00 ended at "
+ "pos 0x%lx.\n", (long)pos));
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start), NULL);
+ continue;
+
+ case JFFS_MAGIC_BITMASK:
+ /* We have probably found a new raw inode. */
+ break;
+
+ default:
+ bad_inode:
+ /* We're f*cked. This is not solved yet. We have
+ to scan for the magic pattern. */
+ D1(printk("*************** Dirty flash memory or "
+ "bad inode: "
+ "hexdump(pos = 0x%lx, len = 128):\n",
+ (long)pos));
+ D1(jffs_hexdump(fmc->mtd, pos, 128));
+
+ for (pos += 4; pos < end; pos += 4) {
+ switch (flash_read_u32(fmc->mtd, pos)) {
+ case JFFS_MAGIC_BITMASK:
+ case JFFS_EMPTY_BITMASK:
+ /* handle these in the main switch() loop */
+ goto cont_scan;
+
+ default:
+ break;
+ }
+ }
+
+ cont_scan:
+ /* First, mark as dirty the region
+ which really does contain crap. */
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start),
+ NULL);
+
+ continue;
+ }/* switch */
+
+ /* We have found the beginning of an inode. Create a
+ node for it unless there already is one available. */
+ if (!node) {
+ if (!(node = jffs_alloc_node())) {
+ /* Free read buffer */
+ kfree (read_buf);
+
+ /* Release the flash device */
+ flash_safe_release(fmc->mtd);
+
+ return -ENOMEM;
+ }
+ DJM(no_jffs_node++);
+ }
+
+ /* Read the next raw inode. */
+
+ flash_safe_read(fmc->mtd, pos, (u_char *) &raw_inode,
+ sizeof(struct jffs_raw_inode));
+
+ /* When we compute the checksum for the inode, we never
+ count the 'accurate' or the 'checksum' fields. */
+ tmp_accurate = raw_inode.accurate;
+ tmp_chksum = raw_inode.chksum;
+ raw_inode.accurate = 0;
+ raw_inode.chksum = 0;
+ checksum = jffs_checksum(&raw_inode,
+ sizeof(struct jffs_raw_inode));
+ raw_inode.accurate = tmp_accurate;
+ raw_inode.chksum = tmp_chksum;
+
+ D3(printk("*** We have found this raw inode at pos 0x%lx "
+ "on the flash:\n", (long)pos));
+ D3(jffs_print_raw_inode(&raw_inode));
+
+ if (checksum != raw_inode.chksum) {
+ D1(printk("jffs_scan_flash(): Bad checksum: "
+ "checksum = %u, "
+ "raw_inode.chksum = %u\n",
+ checksum, raw_inode.chksum));
+ pos += sizeof(struct jffs_raw_inode);
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start), NULL);
+ /* Reuse this unused struct jffs_node. */
+ continue;
+ }
+
+ /* Check the raw inode read so far. Start with the
+ maximum length of the filename. */
+ if (raw_inode.nsize > JFFS_MAX_NAME_LEN) {
+ printk(KERN_WARNING "jffs_scan_flash: Found a "
+ "JFFS node with name too large\n");
+ goto bad_inode;
+ }
+
+ if (raw_inode.rename && raw_inode.dsize != sizeof(__u32)) {
+ printk(KERN_WARNING "jffs_scan_flash: Found a "
+ "rename node with dsize %u.\n",
+ raw_inode.dsize);
+ jffs_print_raw_inode(&raw_inode);
+ goto bad_inode;
+ }
+
+ /* The node's data segment should not exceed a
+ certain length. */
+ if (raw_inode.dsize > fmc->max_chunk_size) {
+ printk(KERN_WARNING "jffs_scan_flash: Found a "
+ "JFFS node with dsize (0x%x) > max_chunk_size (0x%x)\n",
+ raw_inode.dsize, fmc->max_chunk_size);
+ goto bad_inode;
+ }
+
+ pos += sizeof(struct jffs_raw_inode);
+
+ /* This shouldn't be necessary because a node that
+ violates the flash boundaries shouldn't be written
+ in the first place. */
+ if (pos >= end) {
+ goto check_node;
+ }
+
+ /* Read the name. */
+ *name = 0;
+ if (raw_inode.nsize) {
+ flash_safe_read(fmc->mtd, pos, name, raw_inode.nsize);
+ name[raw_inode.nsize] = '\0';
+ pos += raw_inode.nsize
+ + JFFS_GET_PAD_BYTES(raw_inode.nsize);
+ D3(printk("name == \"%s\"\n", name));
+ checksum = jffs_checksum(name, raw_inode.nsize);
+ if (checksum != raw_inode.nchksum) {
+ D1(printk("jffs_scan_flash(): Bad checksum: "
+ "checksum = %u, "
+ "raw_inode.nchksum = %u\n",
+ checksum, raw_inode.nchksum));
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start), NULL);
+ /* Reuse this unused struct jffs_node. */
+ continue;
+ }
+ if (pos >= end) {
+ goto check_node;
+ }
+ }
+
+ /* Read the data, if it exists, in order to be sure it
+ matches the checksum. */
+ if (raw_inode.dsize) {
+ if (raw_inode.rename) {
+ deleted_file = flash_read_u32(fmc->mtd, pos);
+ }
+ if (jffs_checksum_flash(fmc->mtd, pos, raw_inode.dsize, &checksum)) {
+ printk("jffs_checksum_flash() failed to calculate a checksum\n");
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start), NULL);
+ /* Reuse this unused struct jffs_node. */
+ continue;
+ }
+ pos += raw_inode.dsize
+ + JFFS_GET_PAD_BYTES(raw_inode.dsize);
+
+ if (checksum != raw_inode.dchksum) {
+ D1(printk("jffs_scan_flash(): Bad checksum: "
+ "checksum = %u, "
+ "raw_inode.dchksum = %u\n",
+ checksum, raw_inode.dchksum));
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start), NULL);
+ /* Reuse this unused struct jffs_node. */
+ continue;
+ }
+ }
+
+ check_node:
+
+ /* Remember the highest inode number in the whole file
+ system. This information will be used when assigning
+ new files new inode numbers. */
+ if (c->next_ino <= raw_inode.ino) {
+ c->next_ino = raw_inode.ino + 1;
+ }
+
+ if (raw_inode.accurate) {
+ int err;
+ node->data_offset = raw_inode.offset;
+ node->data_size = raw_inode.dsize;
+ node->removed_size = raw_inode.rsize;
+ /* Compute the offset to the actual data in the
+ on-flash node. */
+ node->fm_offset
+ = sizeof(struct jffs_raw_inode)
+ + raw_inode.nsize
+ + JFFS_GET_PAD_BYTES(raw_inode.nsize);
+ node->fm = jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start),
+ node);
+ if (!node->fm) {
+ D(printk("jffs_scan_flash(): !node->fm\n"));
+ jffs_free_node(node);
+ DJM(no_jffs_node--);
+
+ /* Free read buffer */
+ kfree (read_buf);
+
+ /* Release the flash device */
+ flash_safe_release(fmc->mtd);
+
+ return -ENOMEM;
+ }
+ if ((err = jffs_insert_node(c, NULL, &raw_inode,
+ name, node)) < 0) {
+ printk("JFFS: Failed to handle raw inode. "
+ "(err = %d)\n", err);
+ break;
+ }
+ if (raw_inode.rename) {
+ struct jffs_delete_list *dl
+ = (struct jffs_delete_list *)
+ kmalloc(sizeof(struct jffs_delete_list),
+ GFP_KERNEL);
+ if (!dl) {
+ D(printk("jffs_scan_flash: !dl\n"));
+ jffs_free_node(node);
+ DJM(no_jffs_node--);
+
+ /* Release the flash device */
+ flash_safe_release(fmc->flash_part);
+
+ /* Free read buffer */
+ kfree (read_buf);
+
+ return -ENOMEM;
+ }
+ dl->ino = deleted_file;
+ dl->next = c->delete_list;
+ c->delete_list = dl;
+ node->data_size = 0;
+ }
+ D3(jffs_print_node(node));
+ node = NULL; /* Don't free the node! */
+ }
+ else {
+ jffs_fmalloced(fmc, (__u32) start,
+ (__u32) (pos - start), NULL);
+ D3(printk("jffs_scan_flash(): Just found an obsolete "
+ "raw_inode. Continuing the scan...\n"));
+ /* Reuse this unused struct jffs_node. */
+ }
+ }
+
+ if (node) {
+ jffs_free_node(node);
+ DJM(no_jffs_node--);
+ }
+ jffs_build_end(fmc);
+
+ /* Free read buffer */
+ kfree (read_buf);
+
+ if(!num_free_space){
+ printk(KERN_WARNING "jffs_scan_flash(): Did not find even a single "
+ "chunk of free space. This is BAD!\n");
+ }
+
+ /* Return happy */
+ D3(printk("jffs_scan_flash(): Leaving...\n"));
+ flash_safe_release(fmc->mtd);
+
+ /* This is to trap the "free size accounting screwed error. */
+ 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 "jffs_scan_falsh():Free size accounting screwed\n");
+ printk(KERN_WARNING "jfffs_scan_flash():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);
+
+ return -1; /* Do NOT mount f/s so that we can inspect what happened.
+ Mounting this screwed up f/s will screw us up anyway.
+ */
+ }
+
+ return 0; /* as far as we are concerned, we are happy! */
+} /* jffs_scan_flash() */
+
+
+/* Insert any kind of node into the file system. Take care of data
+ insertions and deletions. Also remove redundant information. The
+ memory allocated for the `name' is regarded as "given away" in the
+ caller's perspective. */
+int
+jffs_insert_node(struct jffs_control *c, struct jffs_file *f,
+ const struct jffs_raw_inode *raw_inode,
+ const char *name, struct jffs_node *node)
+{
+ int update_name = 0;
+ int insert_into_tree = 0;
+
+ D2(printk("jffs_insert_node(): ino = %u, version = %u, "
+ "name = \"%s\", deleted = %d\n",
+ raw_inode->ino, raw_inode->version,
+ ((name && *name) ? name : ""), raw_inode->deleted));
+
+ /* If there doesn't exist an associated jffs_file, then
+ create, initialize and insert one into the file system. */
+ if (!f && !(f = jffs_find_file(c, raw_inode->ino))) {
+ if (!(f = jffs_create_file(c, raw_inode))) {
+ return -ENOMEM;
+ }
+ jffs_insert_file_into_hash(f);
+ insert_into_tree = 1;
+ }
+ node->ino = raw_inode->ino;
+ node->version = raw_inode->version;
+ node->data_size = raw_inode->dsize;
+ node->fm_offset = sizeof(struct jffs_raw_inode) + raw_inode->nsize
+ + JFFS_GET_PAD_BYTES(raw_inode->nsize);
+ node->name_size = raw_inode->nsize;
+
+ /* Now insert the node at the correct position into the file's
+ version list. */
+ if (!f->version_head) {
+ /* This is the first node. */
+ f->version_head = node;
+ f->version_tail = node;
+ node->version_prev = NULL;
+ node->version_next = NULL;
+ f->highest_version = node->version;
+ update_name = 1;
+ f->mode = raw_inode->mode;
+ f->uid = raw_inode->uid;
+ f->gid = raw_inode->gid;
+ f->atime = raw_inode->atime;
+ f->mtime = raw_inode->mtime;
+ f->ctime = raw_inode->ctime;
+ }
+ else if ((f->highest_version < node->version)
+ || (node->version == 0)) {
+ /* Insert at the end of the list. I.e. this node is the
+ newest one so far. */
+ node->version_prev = f->version_tail;
+ node->version_next = NULL;
+ f->version_tail->version_next = node;
+ f->version_tail = node;
+ f->highest_version = node->version;
+ update_name = 1;
+ f->pino = raw_inode->pino;
+ f->mode = raw_inode->mode;
+ f->uid = raw_inode->uid;
+ f->gid = raw_inode->gid;
+ f->atime = raw_inode->atime;
+ f->mtime = raw_inode->mtime;
+ f->ctime = raw_inode->ctime;
+ }
+ else if (f->version_head->version > node->version) {
+ /* Insert at the bottom of the list. */
+ node->version_prev = NULL;
+ node->version_next = f->version_head;
+ f->version_head->version_prev = node;
+ f->version_head = node;
+ if (!f->name) {
+ update_name = 1;
+ }
+ }
+ else {
+ struct jffs_node *n;
+ int newer_name = 0;
+ /* Search for the insertion position starting from
+ the tail (newest node). */
+ for (n = f->version_tail; n; n = n->version_prev) {
+ if (n->version < node->version) {
+ node->version_prev = n;
+ node->version_next = n->version_next;
+ node->version_next->version_prev = node;
+ n->version_next = node;
+ if (!newer_name) {
+ update_name = 1;
+ }
+ break;
+ }
+ if (n->name_size) {
+ newer_name = 1;
+ }
+ }
+ }
+
+ /* Deletion is irreversible. If any 'deleted' node is ever
+ written, the file is deleted */
+ if (raw_inode->deleted)
+ f->deleted = raw_inode->deleted;
+
+ /* Perhaps update the name. */
+ if (raw_inode->nsize && update_name && name && *name && (name != f->name)) {
+ if (f->name) {
+ kfree(f->name);
+ DJM(no_name--);
+ }
+ if (!(f->name = (char *) kmalloc(raw_inode->nsize + 1,
+ GFP_KERNEL))) {
+ return -ENOMEM;
+ }
+ DJM(no_name++);
+ memcpy(f->name, name, raw_inode->nsize);
+ f->name[raw_inode->nsize] = '\0';
+ f->nsize = raw_inode->nsize;
+ D3(printk("jffs_insert_node(): Updated the name of "
+ "the file to \"%s\".\n", name));
+ }
+
+ if (!c->building_fs) {
+ D3(printk("jffs_insert_node(): ---------------------------"
+ "------------------------------------------- 1\n"));
+ if (insert_into_tree) {
+ jffs_insert_file_into_tree(f);
+ }
+ /* Once upon a time, we would call jffs_possibly_delete_file()
+ here. That causes an oops if someone's still got the file
+ open, so now we only do it in jffs_delete_inode()
+ -- dwmw2
+ */
+ if (node->data_size || node->removed_size) {
+ jffs_update_file(f, node);
+ }
+ jffs_remove_redundant_nodes(f);
+
+ jffs_garbage_collect_trigger(c);
+
+ D3(printk("jffs_insert_node(): ---------------------------"
+ "------------------------------------------- 2\n"));
+ }
+
+ return 0;
+} /* jffs_insert_node() */
+
+
+/* Unlink a jffs_node from the version list it is in. */
+static inline void
+jffs_unlink_node_from_version_list(struct jffs_file *f,
+ struct jffs_node *node)
+{
+ if (node->version_prev) {
+ node->version_prev->version_next = node->version_next;
+ } else {
+ f->version_head = node->version_next;
+ }
+ if (node->version_next) {
+ node->version_next->version_prev = node->version_prev;
+ } else {
+ f->version_tail = node->version_prev;
+ }
+}
+
+
+/* Unlink a jffs_node from the range list it is in. */
+static inline void
+jffs_unlink_node_from_range_list(struct jffs_file *f, struct jffs_node *node)
+{
+ if (node->range_prev) {
+ node->range_prev->range_next = node->range_next;
+ }
+ else {
+ f->range_head = node->range_next;
+ }
+ if (node->range_next) {
+ node->range_next->range_prev = node->range_prev;
+ }
+ else {
+ f->range_tail = node->range_prev;
+ }
+}
+
+
+/* Function used by jffs_remove_redundant_nodes() below. This function
+ classifies what kind of information a node adds to a file. */
+static inline __u8
+jffs_classify_node(struct jffs_node *node)
+{
+ __u8 mod_type = JFFS_MODIFY_INODE;
+
+ if (node->name_size) {
+ mod_type |= JFFS_MODIFY_NAME;
+ }
+ if (node->data_size || node->removed_size) {
+ mod_type |= JFFS_MODIFY_DATA;
+ }
+ return mod_type;
+}
+
+
+/* Remove redundant nodes from a file. Mark the on-flash memory
+ as dirty. */
+static int
+jffs_remove_redundant_nodes(struct jffs_file *f)
+{
+ struct jffs_node *newest_node;
+ struct jffs_node *cur;
+ struct jffs_node *prev;
+ __u8 newest_type;
+ __u8 mod_type;
+ __u8 node_with_name_later = 0;
+
+ if (!(newest_node = f->version_tail)) {
+ return 0;
+ }
+
+ /* What does the `newest_node' modify? */
+ newest_type = jffs_classify_node(newest_node);
+ node_with_name_later = newest_type & JFFS_MODIFY_NAME;
+
+ D3(printk("jffs_remove_redundant_nodes(): ino: %u, name: \"%s\", "
+ "newest_type: %u\n", f->ino, (f->name ? f->name : ""),
+ newest_type));
+
+ /* Traverse the file's nodes and determine which of them that are
+ superfluous. Yeah, this might look very complex at first
+ glance but it is actually very simple. */
+ for (cur = newest_node->version_prev; cur; cur = prev) {
+ prev = cur->version_prev;
+ mod_type = jffs_classify_node(cur);
+ if ((mod_type <= JFFS_MODIFY_INODE)
+ || ((newest_type & JFFS_MODIFY_NAME)
+ && (mod_type
+ <= (JFFS_MODIFY_INODE + JFFS_MODIFY_NAME)))
+ || (cur->data_size == 0 && cur->removed_size
+ && !cur->version_prev && node_with_name_later)) {
+ /* Yes, this node is redundant. Remove it. */
+ D2(printk("jffs_remove_redundant_nodes(): "
+ "Removing node: ino: %u, version: %u, "
+ "mod_type: %u\n", cur->ino, cur->version,
+ mod_type));
+ jffs_unlink_node_from_version_list(f, cur);
+ jffs_fmfree(f->c->fmc, cur->fm, cur);
+ jffs_free_node(cur);
+ DJM(no_jffs_node--);
+ }
+ else {
+ node_with_name_later |= (mod_type & JFFS_MODIFY_NAME);
+ }
+ }
+
+ return 0;
+}
+
+
+/* Insert a file into the hash table. */
+static int
+jffs_insert_file_into_hash(struct jffs_file *f)
+{
+ int i = f->ino % f->c->hash_len;
+
+ D3(printk("jffs_insert_file_into_hash(): f->ino: %u\n", f->ino));
+
+ list_add(&f->hash, &f->c->hash[i]);
+ return 0;
+}
+
+
+/* Insert a file into the file system tree. */
+int
+jffs_insert_file_into_tree(struct jffs_file *f)
+{
+ struct jffs_file *parent;
+
+ D3(printk("jffs_insert_file_into_tree(): name: \"%s\"\n",
+ (f->name ? f->name : "")));
+
+ if (!(parent = jffs_find_file(f->c, f->pino))) {
+ if (f->pino == 0) {
+ f->c->root = f;
+ f->parent = NULL;
+ f->sibling_prev = NULL;
+ f->sibling_next = NULL;
+ return 0;
+ }
+ else {
+ D1(printk("jffs_insert_file_into_tree(): Found "
+ "inode with no parent and pino == %u\n",
+ f->pino));
+ return -1;
+ }
+ }
+ f->parent = parent;
+ f->sibling_next = parent->children;
+ if (f->sibling_next) {
+ f->sibling_next->sibling_prev = f;
+ }
+ f->sibling_prev = NULL;
+ parent->children = f;
+ return 0;
+}
+
+
+/* Remove a file from the hash table. */
+static int
+jffs_unlink_file_from_hash(struct jffs_file *f)
+{
+ D3(printk("jffs_unlink_file_from_hash(): f: 0x%p, "
+ "ino %u\n", f, f->ino));
+
+ list_del(&f->hash);
+ return 0;
+}
+
+
+/* Just remove the file from the parent's children. Don't free
+ any memory. */
+int
+jffs_unlink_file_from_tree(struct jffs_file *f)
+{
+ D3(printk("jffs_unlink_file_from_tree(): ino: %d, pino: %d, name: "
+ "\"%s\"\n", f->ino, f->pino, (f->name ? f->name : "")));
+
+ if (f->sibling_prev) {
+ f->sibling_prev->sibling_next = f->sibling_next;
+ }
+ else if (f->parent) {
+ D3(printk("f->parent=%p\n", f->parent));
+ f->parent->children = f->sibling_next;
+ }
+ if (f->sibling_next) {
+ f->sibling_next->sibling_prev = f->sibling_prev;
+ }
+ return 0;
+}
+
+
+/* Find a file with its inode number. */
+struct jffs_file *
+jffs_find_file(struct jffs_control *c, __u32 ino)
+{
+ struct jffs_file *f;
+ int i = ino % c->hash_len;
+ struct list_head *tmp;
+
+ D3(printk("jffs_find_file(): ino: %u\n", ino));
+
+ for (tmp = c->hash[i].next; tmp != &c->hash[i]; tmp = tmp->next) {
+ f = list_entry(tmp, struct jffs_file, hash);
+ if (ino != f->ino)
+ continue;
+ D3(printk("jffs_find_file(): Found file with ino "
+ "%u. (name: \"%s\")\n",
+ ino, (f->name ? f->name : ""));
+ );
+ return f;
+ }
+ D3(printk("jffs_find_file(): Didn't find file "
+ "with ino %u.\n", ino);
+ );
+ return NULL;
+}
+
+
+/* Find a file in a directory. We are comparing the names. */
+struct jffs_file *
+jffs_find_child(struct jffs_file *dir, const char *name, int len)
+{
+ struct jffs_file *f;
+
+ D3(printk("jffs_find_child()\n"));
+
+ for (f = dir->children; f; f = f->sibling_next) {
+ if (!f->deleted && f->name
+ && !strncmp(f->name, name, len)
+ && f->name[len] == '\0') {
+ break;
+ }
+ }
+
+ D3(if (f) {
+ printk("jffs_find_child(): Found \"%s\".\n", f->name);
+ }
+ else {
+ char *copy = (char *) kmalloc(len + 1, GFP_KERNEL);
+ if (copy) {
+ memcpy(copy, name, len);
+ copy[len] = '\0';
+ }
+ printk("jffs_find_child(): Didn't find the file \"%s\".\n",
+ (copy ? copy : ""));
+ if (copy) {
+ kfree(copy);
+ }
+ });
+
+ return f;
+}
+
+
+/* Write a raw inode that takes up a certain amount of space in the flash
+ memory. At the end of the flash device, there is often space that is
+ impossible to use. At these times we want to mark this space as not
+ used. In the cases when the amount of space is greater or equal than
+ a struct jffs_raw_inode, we write a "dummy node" that takes up this
+ space. The space after the raw inode, if it exists, is left as it is.
+ Since this space after the raw inode contains JFFS_EMPTY_BITMASK bytes,
+ we can compute the checksum of it; we don't have to manipulate it any
+ further.
+
+ If the space left on the device is less than the size of a struct
+ jffs_raw_inode, this space is filled with JFFS_DIRTY_BITMASK bytes.
+ No raw inode is written this time. */
+static int
+jffs_write_dummy_node(struct jffs_control *c, struct jffs_fm *dirty_fm)
+{
+ struct jffs_fmcontrol *fmc = c->fmc;
+ int err;
+
+ D1(printk("jffs_write_dummy_node(): dirty_fm->offset = 0x%08x, "
+ "dirty_fm->size = %u\n",
+ dirty_fm->offset, dirty_fm->size));
+
+ if (dirty_fm->size >= sizeof(struct jffs_raw_inode)) {
+ struct jffs_raw_inode raw_inode;
+ memset(&raw_inode, 0, sizeof(struct jffs_raw_inode));
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.dsize = dirty_fm->size
+ - sizeof(struct jffs_raw_inode);
+ raw_inode.dchksum = raw_inode.dsize * 0xff;
+ raw_inode.chksum
+ = jffs_checksum(&raw_inode, sizeof(struct jffs_raw_inode));
+
+ if ((err = flash_safe_write(fmc->mtd,
+ dirty_fm->offset,
+ (u_char *)&raw_inode,
+ sizeof(struct jffs_raw_inode)))
+ < 0) {
+ printk(KERN_ERR "JFFS: jffs_write_dummy_node: "
+ "flash_safe_write failed!\n");
+ return err;
+ }
+ }
+ else {
+ flash_safe_acquire(fmc->mtd);
+ flash_memset(fmc->mtd, dirty_fm->offset, 0, dirty_fm->size);
+ flash_safe_release(fmc->mtd);
+ }
+
+ D3(printk("jffs_write_dummy_node(): Leaving...\n"));
+ return 0;
+}
+
+
+/* Write a raw inode, possibly its name and possibly some data. */
+int
+jffs_write_node(struct jffs_control *c, struct jffs_node *node,
+ struct jffs_raw_inode *raw_inode,
+ const char *name, const unsigned char *data,
+ int recoverable,
+ struct jffs_file *f)
+{
+ struct jffs_fmcontrol *fmc = c->fmc;
+ struct jffs_fm *fm;
+ struct kvec node_iovec[4];
+ unsigned long iovec_cnt;
+
+ __u32 pos;
+ int err;
+ __u32 slack = 0;
+
+ __u32 total_name_size = raw_inode->nsize
+ + JFFS_GET_PAD_BYTES(raw_inode->nsize);
+ __u32 total_data_size = raw_inode->dsize
+ + JFFS_GET_PAD_BYTES(raw_inode->dsize);
+ __u32 total_size = sizeof(struct jffs_raw_inode)
+ + total_name_size + total_data_size;
+
+ /* If this node isn't something that will eventually let
+ GC free even more space, then don't allow it unless
+ there's at least max_chunk_size space still available
+ */
+ if (!recoverable)
+ slack = fmc->max_chunk_size;
+
+
+ /* Fire the retrorockets and shoot the fruiton torpedoes, sir! */
+
+ ASSERT(if (!node) {
+ printk("jffs_write_node(): node == NULL\n");
+ return -EINVAL;
+ });
+ ASSERT(if (raw_inode && raw_inode->nsize && !name) {
+ printk("*** jffs_write_node(): nsize = %u but name == NULL\n",
+ raw_inode->nsize);
+ return -EINVAL;
+ });
+
+ D1(printk("jffs_write_node(): filename = \"%s\", ino = %u, "
+ "total_size = %u\n",
+ (name ? name : ""), raw_inode->ino,
+ total_size));
+
+ jffs_fm_write_lock(fmc);
+
+retry:
+ fm = NULL;
+ err = 0;
+ while (!fm) {
+
+ /* Deadlocks suck. */
+ while(fmc->free_size < fmc->min_free_size + total_size + slack) {
+ jffs_fm_write_unlock(fmc);
+ if (!JFFS_ENOUGH_SPACE(c, total_size + slack))
+ return -ENOSPC;
+ jffs_fm_write_lock(fmc);
+ }
+
+ /* First try to allocate some flash memory. */
+ err = jffs_fmalloc(fmc, total_size, node, &fm);
+
+ if (err == -ENOSPC) {
+ /* Just out of space. GC and try again */
+ if (fmc->dirty_size < fmc->sector_size) {
+ D(printk("jffs_write_node(): jffs_fmalloc(0x%p, %u) "
+ "failed, no dirty space to GC\n", fmc,
+ total_size));
+ return err;
+ }
+
+ D1(printk(KERN_INFO "jffs_write_node(): Calling jffs_garbage_collect_now()\n"));
+ jffs_fm_write_unlock(fmc);
+ if ((err = jffs_garbage_collect_now(c))) {
+ D(printk("jffs_write_node(): jffs_garbage_collect_now() failed\n"));
+ return err;
+ }
+ jffs_fm_write_lock(fmc);
+ continue;
+ }
+
+ if (err < 0) {
+ jffs_fm_write_unlock(fmc);
+
+ D(printk("jffs_write_node(): jffs_fmalloc(0x%p, %u) "
+ "failed!\n", fmc, total_size));
+ return err;
+ }
+
+ if (!fm->nodes) {
+ /* The jffs_fm struct that we got is not good enough.
+ Make that space dirty and try again */
+ if ((err = jffs_write_dummy_node(c, fm)) < 0) {
+ kfree(fm);
+ DJM(no_jffs_fm--);
+ jffs_fm_write_unlock(fmc);
+ D(printk("jffs_write_node(): "
+ "jffs_write_dummy_node(): Failed!\n"));
+ return err;
+ }
+ fm = NULL;
+ }
+ } /* while(!fm) */
+ node->fm = fm;
+
+ ASSERT(if (fm->nodes == 0) {
+ printk(KERN_ERR "jffs_write_node(): fm->nodes == 0\n");
+ });
+
+ pos = node->fm->offset;
+
+ /* Increment the version number here. We can't let the caller
+ set it beforehand, because we might have had to do GC on a node
+ of this file - and we'd end up reusing version numbers.
+ */
+ if (f) {
+ raw_inode->version = f->highest_version + 1;
+ D1(printk (KERN_NOTICE "jffs_write_node(): setting version of %s to %d\n", f->name, raw_inode->version));
+
+ /* if the file was deleted, set the deleted bit in the raw inode */
+ if (f->deleted)
+ raw_inode->deleted = 1;
+ }
+
+ /* Compute the checksum for the data and name chunks. */
+ raw_inode->dchksum = jffs_checksum(data, raw_inode->dsize);
+ raw_inode->nchksum = jffs_checksum(name, raw_inode->nsize);
+
+ /* The checksum is calculated without the chksum and accurate
+ fields so set them to zero first. */
+ raw_inode->accurate = 0;
+ raw_inode->chksum = 0;
+ raw_inode->chksum = jffs_checksum(raw_inode,
+ sizeof(struct jffs_raw_inode));
+ raw_inode->accurate = 0xff;
+
+ D3(printk("jffs_write_node(): About to write this raw inode to the "
+ "flash at pos 0x%lx:\n", (long)pos));
+ D3(jffs_print_raw_inode(raw_inode));
+
+ /* The actual raw JFFS node */
+ node_iovec[0].iov_base = (void *) raw_inode;
+ node_iovec[0].iov_len = (size_t) sizeof(struct jffs_raw_inode);
+ iovec_cnt = 1;
+
+ /* Get name and size if there is one */
+ if (raw_inode->nsize) {
+ node_iovec[iovec_cnt].iov_base = (void *) name;
+ node_iovec[iovec_cnt].iov_len = (size_t) raw_inode->nsize;
+ iovec_cnt++;
+
+ if (JFFS_GET_PAD_BYTES(raw_inode->nsize)) {
+ static char allff[3]={255,255,255};
+ /* Add some extra padding if necessary */
+ node_iovec[iovec_cnt].iov_base = allff;
+ node_iovec[iovec_cnt].iov_len =
+ JFFS_GET_PAD_BYTES(raw_inode->nsize);
+ iovec_cnt++;
+ }
+ }
+
+ /* Get data and size if there is any */
+ if (raw_inode->dsize) {
+ node_iovec[iovec_cnt].iov_base = (void *) data;
+ node_iovec[iovec_cnt].iov_len = (size_t) raw_inode->dsize;
+ iovec_cnt++;
+ /* No need to pad this because we're not actually putting
+ anything after it.
+ */
+ }
+
+ if ((err = flash_safe_writev(fmc->mtd, node_iovec, iovec_cnt,
+ pos)) < 0) {
+ jffs_fmfree_partly(fmc, fm, 0);
+ jffs_fm_write_unlock(fmc);
+ printk(KERN_ERR "JFFS: jffs_write_node: Failed to write, "
+ "requested %i, wrote %i\n", total_size, err);
+ goto retry;
+ }
+ if (raw_inode->deleted)
+ f->deleted = 1;
+
+ jffs_fm_write_unlock(fmc);
+ D3(printk("jffs_write_node(): Leaving...\n"));
+ return raw_inode->dsize;
+} /* jffs_write_node() */
+
+
+/* Read data from the node and write it to the buffer. 'node_offset'
+ is how much we have read from this particular node before and which
+ shouldn't be read again. 'max_size' is how much space there is in
+ the buffer. */
+static int
+jffs_get_node_data(struct jffs_file *f, struct jffs_node *node,
+ unsigned char *buf,__u32 node_offset, __u32 max_size)
+{
+ struct jffs_fmcontrol *fmc = f->c->fmc;
+ __u32 pos = node->fm->offset + node->fm_offset + node_offset;
+ __u32 avail = node->data_size - node_offset;
+ __u32 r;
+
+ D2(printk(" jffs_get_node_data(): file: \"%s\", ino: %u, "
+ "version: %u, node_offset: %u\n",
+ f->name, node->ino, node->version, node_offset));
+
+ r = min(avail, max_size);
+ D3(printk(KERN_NOTICE "jffs_get_node_data\n"));
+ flash_safe_read(fmc->mtd, pos, buf, r);
+
+ D3(printk(" jffs_get_node_data(): Read %u byte%s.\n",
+ r, (r == 1 ? "" : "s")));
+
+ return r;
+}
+
+
+/* Read data from the file's nodes. Write the data to the buffer
+ 'buf'. 'read_offset' tells how much data we should skip. */
+int
+jffs_read_data(struct jffs_file *f, unsigned char *buf, __u32 read_offset,
+ __u32 size)
+{
+ struct jffs_node *node;
+ __u32 read_data = 0; /* Total amount of read data. */
+ __u32 node_offset = 0;
+ __u32 pos = 0; /* Number of bytes traversed. */
+
+ D2(printk("jffs_read_data(): file = \"%s\", read_offset = %d, "
+ "size = %u\n",
+ (f->name ? f->name : ""), read_offset, size));
+
+ if (read_offset >= f->size) {
+ D(printk(" f->size: %d\n", f->size));
+ return 0;
+ }
+
+ /* First find the node to read data from. */
+ node = f->range_head;
+ while (pos <= read_offset) {
+ node_offset = read_offset - pos;
+ if (node_offset >= node->data_size) {
+ pos += node->data_size;
+ node = node->range_next;
+ }
+ else {
+ break;
+ }
+ }
+
+ /* "Cats are living proof that not everything in nature
+ has to be useful."
+ - Garrison Keilor ('97) */
+
+ /* Fill the buffer. */
+ while (node && (read_data < size)) {
+ int r;
+ if (!node->fm) {
+ /* This node does not refer to real data. */
+ r = min(size - read_data,
+ node->data_size - node_offset);
+ memset(&buf[read_data], 0, r);
+ }
+ else if ((r = jffs_get_node_data(f, node, &buf[read_data],
+ node_offset,
+ size - read_data)) < 0) {
+ return r;
+ }
+ read_data += r;
+ node_offset = 0;
+ node = node->range_next;
+ }
+ D3(printk(" jffs_read_data(): Read %u bytes.\n", read_data));
+ return read_data;
+}
+
+
+/* Used for traversing all nodes in the hash table. */
+int
+jffs_foreach_file(struct jffs_control *c, int (*func)(struct jffs_file *))
+{
+ int pos;
+ int r;
+ int result = 0;
+
+ for (pos = 0; pos < c->hash_len; pos++) {
+ struct list_head *p, *next;
+ for (p = c->hash[pos].next; p != &c->hash[pos]; p = next) {
+ /* We need a reference to the next file in the
+ list because `func' might remove the current
+ file `f'. */
+ next = p->next;
+ r = func(list_entry(p, struct jffs_file, hash));
+ if (r < 0)
+ return r;
+ result += r;
+ }
+ }
+
+ return result;
+}
+
+
+/* Free all nodes associated with a file. */
+static int
+jffs_free_node_list(struct jffs_file *f)
+{
+ struct jffs_node *node;
+ struct jffs_node *p;
+
+ D3(printk("jffs_free_node_list(): f #%u, \"%s\"\n",
+ f->ino, (f->name ? f->name : "")));
+ node = f->version_head;
+ while (node) {
+ p = node;
+ node = node->version_next;
+ jffs_free_node(p);
+ DJM(no_jffs_node--);
+ }
+ return 0;
+}
+
+
+/* Free a file and its name. */
+static int
+jffs_free_file(struct jffs_file *f)
+{
+ D3(printk("jffs_free_file: f #%u, \"%s\"\n",
+ f->ino, (f->name ? f->name : "")));
+
+ if (f->name) {
+ kfree(f->name);
+ DJM(no_name--);
+ }
+ kfree(f);
+ no_jffs_file--;
+ return 0;
+}
+
+static long
+jffs_get_file_count(void)
+{
+ return no_jffs_file;
+}
+
+/* See if a file is deleted. If so, mark that file's nodes as obsolete. */
+int
+jffs_possibly_delete_file(struct jffs_file *f)
+{
+ struct jffs_node *n;
+
+ D3(printk("jffs_possibly_delete_file(): ino: %u\n",
+ f->ino));
+
+ ASSERT(if (!f) {
+ printk(KERN_ERR "jffs_possibly_delete_file(): f == NULL\n");
+ return -1;
+ });
+
+ if (f->deleted) {
+ /* First try to remove all older versions. Commence with
+ the oldest node. */
+ for (n = f->version_head; n; n = n->version_next) {
+ if (!n->fm) {
+ continue;
+ }
+ if (jffs_fmfree(f->c->fmc, n->fm, n) < 0) {
+ break;
+ }
+ }
+ /* Unlink the file from the filesystem. */
+ if (!f->c->building_fs) {
+ jffs_unlink_file_from_tree(f);
+ }
+ jffs_unlink_file_from_hash(f);
+ jffs_free_node_list(f);
+ jffs_free_file(f);
+ }
+ return 0;
+}
+
+
+/* Used in conjunction with jffs_foreach_file() to count the number
+ of files in the file system. */
+int
+jffs_file_count(struct jffs_file *f)
+{
+ return 1;
+}
+
+
+/* Build up a file's range list from scratch by going through the
+ version list. */
+static int
+jffs_build_file(struct jffs_file *f)
+{
+ struct jffs_node *n;
+
+ D3(printk("jffs_build_file(): ino: %u, name: \"%s\"\n",
+ f->ino, (f->name ? f->name : "")));
+
+ for (n = f->version_head; n; n = n->version_next) {
+ jffs_update_file(f, n);
+ }
+ return 0;
+}
+
+
+/* Remove an amount of data from a file. If this amount of data is
+ zero, that could mean that a node should be split in two parts.
+ We remove or change the appropriate nodes in the lists.
+
+ Starting offset of area to be removed is node->data_offset,
+ and the length of the area is in node->removed_size. */
+static int
+jffs_delete_data(struct jffs_file *f, struct jffs_node *node)
+{
+ struct jffs_node *n;
+ __u32 offset = node->data_offset;
+ __u32 remove_size = node->removed_size;
+
+ D3(printk("jffs_delete_data(): offset = %u, remove_size = %u\n",
+ offset, remove_size));
+
+ if (remove_size == 0
+ && f->range_tail
+ && f->range_tail->data_offset + f->range_tail->data_size
+ == offset) {
+ /* A simple append; nothing to remove or no node to split. */
+ return 0;
+ }
+
+ /* Find the node where we should begin the removal. */
+ for (n = f->range_head; n; n = n->range_next) {
+ if (n->data_offset + n->data_size > offset) {
+ break;
+ }
+ }
+ if (!n) {
+ /* If there's no data in the file there's no data to
+ remove either. */
+ return 0;
+ }
+
+ if (n->data_offset > offset) {
+ /* XXX: Not implemented yet. */
+ printk(KERN_WARNING "JFFS: An unexpected situation "
+ "occurred in jffs_delete_data.\n");
+ }
+ else if (n->data_offset < offset) {
+ /* See if the node has to be split into two parts. */
+ if (n->data_offset + n->data_size > offset + remove_size) {
+ /* Do the split. */
+ struct jffs_node *new_node;
+ D3(printk("jffs_delete_data(): Split node with "
+ "version number %u.\n", n->version));
+
+ if (!(new_node = jffs_alloc_node())) {
+ D(printk("jffs_delete_data(): -ENOMEM\n"));
+ return -ENOMEM;
+ }
+ DJM(no_jffs_node++);
+
+ new_node->ino = n->ino;
+ new_node->version = n->version;
+ new_node->data_offset = offset;
+ new_node->data_size = n->data_size - (remove_size + (offset - n->data_offset));
+ new_node->fm_offset = n->fm_offset + (remove_size + (offset - n->data_offset));
+ new_node->name_size = n->name_size;
+ new_node->fm = n->fm;
+ new_node->version_prev = n;
+ new_node->version_next = n->version_next;
+ if (new_node->version_next) {
+ new_node->version_next->version_prev
+ = new_node;
+ }
+ else {
+ f->version_tail = new_node;
+ }
+ n->version_next = new_node;
+ new_node->range_prev = n;
+ new_node->range_next = n->range_next;
+ if (new_node->range_next) {
+ new_node->range_next->range_prev = new_node;
+ }
+ else {
+ f->range_tail = new_node;
+ }
+ /* A very interesting can of worms. */
+ n->range_next = new_node;
+ n->data_size = offset - n->data_offset;
+ if (new_node->fm)
+ jffs_add_node(new_node);
+ else {
+ D1(printk(KERN_WARNING "jffs_delete_data(): Splitting an empty node (file hold).\n!"));
+ D1(printk(KERN_WARNING "FIXME: Did dwmw2 do the right thing here?\n"));
+ }
+ n = new_node->range_next;
+ remove_size = 0;
+ }
+ else {
+ /* No. No need to split the node. Just remove
+ the end of the node. */
+ int r = min(n->data_offset + n->data_size
+ - offset, remove_size);
+ n->data_size -= r;
+ remove_size -= r;
+ n = n->range_next;
+ }
+ }
+
+ /* Remove as many nodes as necessary. */
+ while (n && remove_size) {
+ if (n->data_size <= remove_size) {
+ struct jffs_node *p = n;
+ remove_size -= n->data_size;
+ n = n->range_next;
+ D3(printk("jffs_delete_data(): Removing node: "
+ "ino: %u, version: %u%s\n",
+ p->ino, p->version,
+ (p->fm ? "" : " (virtual)")));
+ if (p->fm) {
+ jffs_fmfree(f->c->fmc, p->fm, p);
+ }
+ jffs_unlink_node_from_range_list(f, p);
+ jffs_unlink_node_from_version_list(f, p);
+ jffs_free_node(p);
+ DJM(no_jffs_node--);
+ }
+ else {
+ n->data_size -= remove_size;
+ n->fm_offset += remove_size;
+ n->data_offset -= (node->removed_size - remove_size);
+ n = n->range_next;
+ break;
+ }
+ }
+
+ /* Adjust the following nodes' information about offsets etc. */
+ while (n && node->removed_size) {
+ n->data_offset -= node->removed_size;
+ n = n->range_next;
+ }
+
+ if (node->removed_size > (f->size - node->data_offset)) {
+ /* It's possible that the removed_size is in fact
+ * greater than the amount of data we actually thought
+ * were present in the first place - some of the nodes
+ * which this node originally obsoleted may already have
+ * been deleted from the flash by subsequent garbage
+ * collection.
+ *
+ * If this is the case, don't let f->size go negative.
+ * Bad things would happen :)
+ */
+ f->size = node->data_offset;
+ } else {
+ f->size -= node->removed_size;
+ }
+ D3(printk("jffs_delete_data(): f->size = %d\n", f->size));
+ return 0;
+} /* jffs_delete_data() */
+
+
+/* Insert some data into a file. Prior to the call to this function,
+ jffs_delete_data should be called. */
+static int
+jffs_insert_data(struct jffs_file *f, struct jffs_node *node)
+{
+ D3(printk("jffs_insert_data(): node->data_offset = %u, "
+ "node->data_size = %u, f->size = %u\n",
+ node->data_offset, node->data_size, f->size));
+
+ /* Find the position where we should insert data. */
+ retry:
+ if (node->data_offset == f->size) {
+ /* A simple append. This is the most common operation. */
+ node->range_next = NULL;
+ node->range_prev = f->range_tail;
+ if (node->range_prev) {
+ node->range_prev->range_next = node;
+ }
+ f->range_tail = node;
+ f->size += node->data_size;
+ if (!f->range_head) {
+ f->range_head = node;
+ }
+ }
+ else if (node->data_offset < f->size) {
+ /* Trying to insert data into the middle of the file. This
+ means no problem because jffs_delete_data() has already
+ prepared the range list for us. */
+ struct jffs_node *n;
+
+ /* Find the correct place for the insertion and then insert
+ the node. */
+ for (n = f->range_head; n; n = n->range_next) {
+ D2(printk("Cool stuff's happening!\n"));
+
+ if (n->data_offset == node->data_offset) {
+ node->range_prev = n->range_prev;
+ if (node->range_prev) {
+ node->range_prev->range_next = node;
+ }
+ else {
+ f->range_head = node;
+ }
+ node->range_next = n;
+ n->range_prev = node;
+ break;
+ }
+ ASSERT(else if (n->data_offset + n->data_size >
+ node->data_offset) {
+ printk(KERN_ERR "jffs_insert_data(): "
+ "Couldn't find a place to insert "
+ "the data!\n");
+ return -1;
+ });
+ }
+
+ /* Adjust later nodes' offsets etc. */
+ n = node->range_next;
+ while (n) {
+ n->data_offset += node->data_size;
+ n = n->range_next;
+ }
+ f->size += node->data_size;
+ }
+ else if (node->data_offset > f->size) {
+ /* Okay. This is tricky. This means that we want to insert
+ data at a place that is beyond the limits of the file as
+ it is constructed right now. This is actually a common
+ event that for instance could occur during the mounting
+ of the file system if a large file have been truncated,
+ rewritten and then only partially garbage collected. */
+
+ struct jffs_node *n;
+
+ /* We need a place holder for the data that is missing in
+ front of this insertion. This "virtual node" will not
+ be associated with any space on the flash device. */
+ struct jffs_node *virtual_node;
+ if (!(virtual_node = jffs_alloc_node())) {
+ return -ENOMEM;
+ }
+
+ D(printk("jffs_insert_data: Inserting a virtual node.\n"));
+ D(printk(" node->data_offset = %u\n", node->data_offset));
+ D(printk(" f->size = %u\n", f->size));
+
+ virtual_node->ino = node->ino;
+ virtual_node->version = node->version;
+ virtual_node->removed_size = 0;
+ virtual_node->fm_offset = 0;
+ virtual_node->name_size = 0;
+ virtual_node->fm = NULL; /* This is a virtual data holder. */
+ virtual_node->version_prev = NULL;
+ virtual_node->version_next = NULL;
+ virtual_node->range_next = NULL;
+
+ /* Are there any data at all in the file yet? */
+ if (f->range_head) {
+ virtual_node->data_offset
+ = f->range_tail->data_offset
+ + f->range_tail->data_size;
+ virtual_node->data_size
+ = node->data_offset - virtual_node->data_offset;
+ virtual_node->range_prev = f->range_tail;
+ f->range_tail->range_next = virtual_node;
+ }
+ else {
+ virtual_node->data_offset = 0;
+ virtual_node->data_size = node->data_offset;
+ virtual_node->range_prev = NULL;
+ f->range_head = virtual_node;
+ }
+
+ f->range_tail = virtual_node;
+ f->size += virtual_node->data_size;
+
+ /* Insert this virtual node in the version list as well. */
+ for (n = f->version_head; n ; n = n->version_next) {
+ if (n->version == virtual_node->version) {
+ virtual_node->version_prev = n->version_prev;
+ n->version_prev = virtual_node;
+ if (virtual_node->version_prev) {
+ virtual_node->version_prev
+ ->version_next = virtual_node;
+ }
+ else {
+ f->version_head = virtual_node;
+ }
+ virtual_node->version_next = n;
+ break;
+ }
+ }
+
+ D(jffs_print_node(virtual_node));
+
+ /* Make a new try to insert the node. */
+ goto retry;
+ }
+
+ D3(printk("jffs_insert_data(): f->size = %d\n", f->size));
+ return 0;
+}
+
+
+/* A new node (with data) has been added to the file and now the range
+ list has to be modified. */
+static int
+jffs_update_file(struct jffs_file *f, struct jffs_node *node)
+{
+ int err;
+
+ D3(printk("jffs_update_file(): ino: %u, version: %u\n",
+ f->ino, node->version));
+
+ if (node->data_size == 0) {
+ if (node->removed_size == 0) {
+ /* data_offset == X */
+ /* data_size == 0 */
+ /* remove_size == 0 */
+ }
+ else {
+ /* data_offset == X */
+ /* data_size == 0 */
+ /* remove_size != 0 */
+ if ((err = jffs_delete_data(f, node)) < 0) {
+ return err;
+ }
+ }
+ }
+ else {
+ /* data_offset == X */
+ /* data_size != 0 */
+ /* remove_size == Y */
+ if ((err = jffs_delete_data(f, node)) < 0) {
+ return err;
+ }
+ if ((err = jffs_insert_data(f, node)) < 0) {
+ return err;
+ }
+ }
+ return 0;
+}
+
+/* Print the contents of a node. */
+void
+jffs_print_node(struct jffs_node *n)
+{
+ D(printk("jffs_node: 0x%p\n", n));
+ D(printk("{\n"));
+ D(printk(" 0x%08x, /* version */\n", n->version));
+ D(printk(" 0x%08x, /* data_offset */\n", n->data_offset));
+ D(printk(" 0x%08x, /* data_size */\n", n->data_size));
+ D(printk(" 0x%08x, /* removed_size */\n", n->removed_size));
+ D(printk(" 0x%08x, /* fm_offset */\n", n->fm_offset));
+ D(printk(" 0x%02x, /* name_size */\n", n->name_size));
+ D(printk(" 0x%p, /* fm, fm->offset: %u */\n",
+ n->fm, (n->fm ? n->fm->offset : 0)));
+ D(printk(" 0x%p, /* version_prev */\n", n->version_prev));
+ D(printk(" 0x%p, /* version_next */\n", n->version_next));
+ D(printk(" 0x%p, /* range_prev */\n", n->range_prev));
+ D(printk(" 0x%p, /* range_next */\n", n->range_next));
+ D(printk("}\n"));
+}
+
+
+/* Print the contents of a raw inode. */
+void
+jffs_print_raw_inode(struct jffs_raw_inode *raw_inode)
+{
+ D(printk("jffs_raw_inode: inode number: %u\n", raw_inode->ino));
+ D(printk("{\n"));
+ D(printk(" 0x%08x, /* magic */\n", raw_inode->magic));
+ D(printk(" 0x%08x, /* ino */\n", raw_inode->ino));
+ D(printk(" 0x%08x, /* pino */\n", raw_inode->pino));
+ D(printk(" 0x%08x, /* version */\n", raw_inode->version));
+ D(printk(" 0x%08x, /* mode */\n", raw_inode->mode));
+ D(printk(" 0x%04x, /* uid */\n", raw_inode->uid));
+ D(printk(" 0x%04x, /* gid */\n", raw_inode->gid));
+ D(printk(" 0x%08x, /* atime */\n", raw_inode->atime));
+ D(printk(" 0x%08x, /* mtime */\n", raw_inode->mtime));
+ D(printk(" 0x%08x, /* ctime */\n", raw_inode->ctime));
+ D(printk(" 0x%08x, /* offset */\n", raw_inode->offset));
+ D(printk(" 0x%08x, /* dsize */\n", raw_inode->dsize));
+ D(printk(" 0x%08x, /* rsize */\n", raw_inode->rsize));
+ D(printk(" 0x%02x, /* nsize */\n", raw_inode->nsize));
+ D(printk(" 0x%02x, /* nlink */\n", raw_inode->nlink));
+ D(printk(" 0x%02x, /* spare */\n",
+ raw_inode->spare));
+ D(printk(" %u, /* rename */\n",
+ raw_inode->rename));
+ D(printk(" %u, /* deleted */\n",
+ raw_inode->deleted));
+ D(printk(" 0x%02x, /* accurate */\n",
+ raw_inode->accurate));
+ D(printk(" 0x%08x, /* dchksum */\n", raw_inode->dchksum));
+ D(printk(" 0x%04x, /* nchksum */\n", raw_inode->nchksum));
+ D(printk(" 0x%04x, /* chksum */\n", raw_inode->chksum));
+ D(printk("}\n"));
+}
+
+
+/* Print the contents of a file. */
+#if 0
+int
+jffs_print_file(struct jffs_file *f)
+{
+ D(int i);
+ D(printk("jffs_file: 0x%p\n", f));
+ D(printk("{\n"));
+ D(printk(" 0x%08x, /* ino */\n", f->ino));
+ D(printk(" 0x%08x, /* pino */\n", f->pino));
+ D(printk(" 0x%08x, /* mode */\n", f->mode));
+ D(printk(" 0x%04x, /* uid */\n", f->uid));
+ D(printk(" 0x%04x, /* gid */\n", f->gid));
+ D(printk(" 0x%08x, /* atime */\n", f->atime));
+ D(printk(" 0x%08x, /* mtime */\n", f->mtime));
+ D(printk(" 0x%08x, /* ctime */\n", f->ctime));
+ D(printk(" 0x%02x, /* nsize */\n", f->nsize));
+ D(printk(" 0x%02x, /* nlink */\n", f->nlink));
+ D(printk(" 0x%02x, /* deleted */\n", f->deleted));
+ D(printk(" \"%s\", ", (f->name ? f->name : "")));
+ D(for (i = strlen(f->name ? f->name : ""); i < 8; ++i) {
+ printk(" ");
+ });
+ D(printk("/* name */\n"));
+ D(printk(" 0x%08x, /* size */\n", f->size));
+ D(printk(" 0x%08x, /* highest_version */\n",
+ f->highest_version));
+ D(printk(" 0x%p, /* c */\n", f->c));
+ D(printk(" 0x%p, /* parent */\n", f->parent));
+ D(printk(" 0x%p, /* children */\n", f->children));
+ D(printk(" 0x%p, /* sibling_prev */\n", f->sibling_prev));
+ D(printk(" 0x%p, /* sibling_next */\n", f->sibling_next));
+ D(printk(" 0x%p, /* hash_prev */\n", f->hash.prev));
+ D(printk(" 0x%p, /* hash_next */\n", f->hash.next));
+ D(printk(" 0x%p, /* range_head */\n", f->range_head));
+ D(printk(" 0x%p, /* range_tail */\n", f->range_tail));
+ D(printk(" 0x%p, /* version_head */\n", f->version_head));
+ D(printk(" 0x%p, /* version_tail */\n", f->version_tail));
+ D(printk("}\n"));
+ return 0;
+}
+#endif /* 0 */
+
+void
+jffs_print_hash_table(struct jffs_control *c)
+{
+ int i;
+
+ printk("JFFS: Dumping the file system's hash table...\n");
+ for (i = 0; i < c->hash_len; i++) {
+ struct list_head *p;
+ for (p = c->hash[i].next; p != &c->hash[i]; p = p->next) {
+ struct jffs_file *f=list_entry(p,struct jffs_file,hash);
+ printk("*** c->hash[%u]: \"%s\" "
+ "(ino: %u, pino: %u)\n",
+ i, (f->name ? f->name : ""),
+ f->ino, f->pino);
+ }
+ }
+}
+
+
+void
+jffs_print_tree(struct jffs_file *first_file, int indent)
+{
+ struct jffs_file *f;
+ char *space;
+ int dir;
+
+ if (!first_file) {
+ return;
+ }
+
+ if (!(space = (char *) kmalloc(indent + 1, GFP_KERNEL))) {
+ printk("jffs_print_tree(): Out of memory!\n");
+ return;
+ }
+
+ memset(space, ' ', indent);
+ space[indent] = '\0';
+
+ for (f = first_file; f; f = f->sibling_next) {
+ dir = S_ISDIR(f->mode);
+ printk("%s%s%s (ino: %u, highest_version: %u, size: %u)\n",
+ space, (f->name ? f->name : ""), (dir ? "/" : ""),
+ f->ino, f->highest_version, f->size);
+ if (dir) {
+ jffs_print_tree(f->children, indent + 2);
+ }
+ }
+
+ kfree(space);
+}
+
+
+#if defined(JFFS_MEMORY_DEBUG) && JFFS_MEMORY_DEBUG
+void
+jffs_print_memory_allocation_statistics(void)
+{
+ static long printout;
+ printk("________ Memory printout #%ld ________\n", ++printout);
+ printk("no_jffs_file = %ld\n", no_jffs_file);
+ printk("no_jffs_node = %ld\n", no_jffs_node);
+ printk("no_jffs_control = %ld\n", no_jffs_control);
+ printk("no_jffs_raw_inode = %ld\n", no_jffs_raw_inode);
+ printk("no_jffs_node_ref = %ld\n", no_jffs_node_ref);
+ printk("no_jffs_fm = %ld\n", no_jffs_fm);
+ printk("no_jffs_fmcontrol = %ld\n", no_jffs_fmcontrol);
+ printk("no_hash = %ld\n", no_hash);
+ printk("no_name = %ld\n", no_name);
+ printk("\n");
+}
+#endif
+
+
+/* Rewrite `size' bytes, and begin at `node'. */
+static int
+jffs_rewrite_data(struct jffs_file *f, struct jffs_node *node, __u32 size)
+{
+ struct jffs_control *c = f->c;
+ struct jffs_fmcontrol *fmc = c->fmc;
+ struct jffs_raw_inode raw_inode;
+ struct jffs_node *new_node;
+ struct jffs_fm *fm;
+ __u32 pos;
+ __u32 pos_dchksum;
+ __u32 total_name_size;
+ __u32 total_data_size;
+ __u32 total_size;
+ int err;
+
+ D1(printk("***jffs_rewrite_data(): node: %u, name: \"%s\", size: %u\n",
+ f->ino, (f->name ? f->name : "(null)"), size));
+
+ /* Create and initialize the new node. */
+ if (!(new_node = jffs_alloc_node())) {
+ D(printk("jffs_rewrite_data(): "
+ "Failed to allocate node.\n"));
+ return -ENOMEM;
+ }
+ DJM(no_jffs_node++);
+ new_node->data_offset = node->data_offset;
+ new_node->removed_size = size;
+ total_name_size = JFFS_PAD(f->nsize);
+ total_data_size = JFFS_PAD(size);
+ total_size = sizeof(struct jffs_raw_inode)
+ + total_name_size + total_data_size;
+ new_node->fm_offset = sizeof(struct jffs_raw_inode)
+ + total_name_size;
+
+retry:
+ jffs_fm_write_lock(fmc);
+ err = 0;
+
+ if ((err = jffs_fmalloc(fmc, total_size, new_node, &fm)) < 0) {
+ DJM(no_jffs_node--);
+ jffs_fm_write_unlock(fmc);
+ D(printk("jffs_rewrite_data(): Failed to allocate fm.\n"));
+ jffs_free_node(new_node);
+ return err;
+ }
+ else if (!fm->nodes) {
+ /* The jffs_fm struct that we got is not big enough. */
+ /* This should never happen, because we deal with this case
+ in jffs_garbage_collect_next().*/
+ printk(KERN_WARNING "jffs_rewrite_data(): Allocated node is too small (%d bytes of %d)\n", fm->size, total_size);
+ if ((err = jffs_write_dummy_node(c, fm)) < 0) {
+ D(printk("jffs_rewrite_data(): "
+ "jffs_write_dummy_node() Failed!\n"));
+ } else {
+ err = -ENOSPC;
+ }
+ DJM(no_jffs_fm--);
+ jffs_fm_write_unlock(fmc);
+ kfree(fm);
+
+ return err;
+ }
+ new_node->fm = fm;
+
+ /* Initialize the raw inode. */
+ raw_inode.magic = JFFS_MAGIC_BITMASK;
+ raw_inode.ino = f->ino;
+ raw_inode.pino = f->pino;
+ raw_inode.version = f->highest_version + 1;
+ raw_inode.mode = f->mode;
+ raw_inode.uid = f->uid;
+ raw_inode.gid = f->gid;
+ raw_inode.atime = f->atime;
+ raw_inode.mtime = f->mtime;
+ raw_inode.ctime = f->ctime;
+ raw_inode.offset = node->data_offset;
+ raw_inode.dsize = size;
+ raw_inode.rsize = size;
+ raw_inode.nsize = f->nsize;
+ raw_inode.nlink = f->nlink;
+ raw_inode.spare = 0;
+ raw_inode.rename = 0;
+ raw_inode.deleted = f->deleted;
+ raw_inode.accurate = 0xff;
+ raw_inode.dchksum = 0;
+ raw_inode.nchksum = 0;
+
+ pos = new_node->fm->offset;
+ pos_dchksum = pos +JFFS_RAW_INODE_DCHKSUM_OFFSET;
+
+ D3(printk("jffs_rewrite_data(): Writing this raw inode "
+ "to pos 0x%ul.\n", pos));
+ D3(jffs_print_raw_inode(&raw_inode));
+
+ if ((err = flash_safe_write(fmc->mtd, pos,
+ (u_char *) &raw_inode,
+ sizeof(struct jffs_raw_inode)
+ - sizeof(__u32)
+ - sizeof(__u16) - sizeof(__u16))) < 0) {
+ jffs_fmfree_partly(fmc, fm,
+ total_name_size + total_data_size);
+ jffs_fm_write_unlock(fmc);
+ printk(KERN_ERR "JFFS: jffs_rewrite_data: Write error during "
+ "rewrite. (raw inode)\n");
+ printk(KERN_ERR "JFFS: jffs_rewrite_data: Now retrying "
+ "rewrite. (raw inode)\n");
+ goto retry;
+ }
+ pos += sizeof(struct jffs_raw_inode);
+
+ /* Write the name to the flash memory. */
+ if (f->nsize) {
+ D3(printk("jffs_rewrite_data(): Writing name \"%s\" to "
+ "pos 0x%ul.\n", f->name, (unsigned int) pos));
+ if ((err = flash_safe_write(fmc->mtd, pos,
+ (u_char *)f->name,
+ f->nsize)) < 0) {
+ jffs_fmfree_partly(fmc, fm, total_data_size);
+ jffs_fm_write_unlock(fmc);
+ printk(KERN_ERR "JFFS: jffs_rewrite_data: Write "
+ "error during rewrite. (name)\n");
+ printk(KERN_ERR "JFFS: jffs_rewrite_data: Now retrying "
+ "rewrite. (name)\n");
+ goto retry;
+ }
+ pos += total_name_size;
+ raw_inode.nchksum = jffs_checksum(f->name, f->nsize);
+ }
+
+ /* Write the data. */
+ if (size) {
+ int r;
+ unsigned char *page;
+ __u32 offset = node->data_offset;
+
+ if (!(page = (unsigned char *)__get_free_page(GFP_KERNEL))) {
+ jffs_fmfree_partly(fmc, fm, 0);
+ return -1;
+ }
+
+ while (size) {
+ __u32 s = min(size, (__u32)PAGE_SIZE);
+ if ((r = jffs_read_data(f, (char *)page,
+ offset, s)) < s) {
+ free_page((unsigned long)page);
+ jffs_fmfree_partly(fmc, fm, 0);
+ jffs_fm_write_unlock(fmc);
+ printk(KERN_ERR "JFFS: jffs_rewrite_data: "
+ "jffs_read_data() "
+ "failed! (r = %d)\n", r);
+ return -1;
+ }
+ if ((err = flash_safe_write(fmc->mtd,
+ pos, page, r)) < 0) {
+ free_page((unsigned long)page);
+ jffs_fmfree_partly(fmc, fm, 0);
+ jffs_fm_write_unlock(fmc);
+ printk(KERN_ERR "JFFS: jffs_rewrite_data: "
+ "Write error during rewrite. "
+ "(data)\n");
+ goto retry;
+ }
+ pos += r;
+ size -= r;
+ offset += r;
+ raw_inode.dchksum += jffs_checksum(page, r);
+ }
+
+ free_page((unsigned long)page);
+ }
+
+ raw_inode.accurate = 0;
+ raw_inode.chksum = jffs_checksum(&raw_inode,
+ sizeof(struct jffs_raw_inode)
+ - sizeof(__u16));
+
+ /* Add the checksum. */
+ if ((err
+ = flash_safe_write(fmc->mtd, pos_dchksum,
+ &((u_char *)
+ &raw_inode)[JFFS_RAW_INODE_DCHKSUM_OFFSET],
+ sizeof(__u32) + sizeof(__u16)
+ + sizeof(__u16))) < 0) {
+ jffs_fmfree_partly(fmc, fm, 0);
+ jffs_fm_write_unlock(fmc);
+ printk(KERN_ERR "JFFS: jffs_rewrite_data: Write error during "
+ "rewrite. (checksum)\n");
+ goto retry;
+ }
+
+ /* Now make the file system aware of the newly written node. */
+ jffs_insert_node(c, f, &raw_inode, f->name, new_node);
+ jffs_fm_write_unlock(fmc);
+
+ D3(printk("jffs_rewrite_data(): Leaving...\n"));
+ return 0;
+} /* jffs_rewrite_data() */
+
+
+/* jffs_garbage_collect_next implements one step in the garbage collect
+ process and is often called multiple times at each occasion of a
+ garbage collect. */
+
+static int
+jffs_garbage_collect_next(struct jffs_control *c)
+{
+ struct jffs_fmcontrol *fmc = c->fmc;
+ struct jffs_node *node;
+ struct jffs_file *f;
+ int err = 0;
+ __u32 size;
+ __u32 data_size;
+ __u32 total_name_size;
+ __u32 extra_available;
+ __u32 space_needed;
+ __u32 free_chunk_size1 = jffs_free_size1(fmc);
+ D2(__u32 free_chunk_size2 = jffs_free_size2(fmc));
+
+ /* Get the oldest node in the flash. */
+ node = jffs_get_oldest_node(fmc);
+ ASSERT(if (!node) {
+ printk(KERN_ERR "JFFS: jffs_garbage_collect_next: "
+ "No oldest node found!\n");
+ err = -1;
+ goto jffs_garbage_collect_next_end;
+
+
+ });
+
+ /* Find its corresponding file too. */
+ f = jffs_find_file(c, node->ino);
+
+ if (!f) {
+ printk (KERN_ERR "JFFS: jffs_garbage_collect_next: "
+ "No file to garbage collect! "
+ "(ino = 0x%08x)\n", node->ino);
+ /* FIXME: Free the offending node and recover. */
+ err = -1;
+ goto jffs_garbage_collect_next_end;
+ }
+
+ /* We always write out the name. Theoretically, we don't need
+ to, but for now it's easier - because otherwise we'd have
+ to keep track of how many times the current name exists on
+ the flash and make sure it never reaches zero.
+
+ The current approach means that would be possible to cause
+ the GC to end up eating its tail by writing lots of nodes
+ with no name for it to garbage-collect. Hence the change in
+ inode.c to write names with _every_ node.
+
+ It sucks, but it _should_ work.
+ */
+ total_name_size = JFFS_PAD(f->nsize);
+
+ D1(printk("jffs_garbage_collect_next(): \"%s\", "
+ "ino: %u, version: %u, location 0x%x, dsize %u\n",
+ (f->name ? f->name : ""), node->ino, node->version,
+ node->fm->offset, node->data_size));
+
+ /* Compute how many data it's possible to rewrite at the moment. */
+ data_size = f->size - node->data_offset;
+
+ /* And from that, the total size of the chunk we want to write */
+ size = sizeof(struct jffs_raw_inode) + total_name_size
+ + data_size + JFFS_GET_PAD_BYTES(data_size);
+
+ /* If that's more than max_chunk_size, reduce it accordingly */
+ if (size > fmc->max_chunk_size) {
+ size = fmc->max_chunk_size;
+ data_size = size - sizeof(struct jffs_raw_inode)
+ - total_name_size;
+ }
+
+ /* If we're asking to take up more space than free_chunk_size1
+ but we _could_ fit in it, shrink accordingly.
+ */
+ if (size > free_chunk_size1) {
+
+ if (free_chunk_size1 <
+ (sizeof(struct jffs_raw_inode) + total_name_size + BLOCK_SIZE)){
+ /* The space left is too small to be of any
+ use really. */
+ struct jffs_fm *dirty_fm
+ = jffs_fmalloced(fmc,
+ fmc->tail->offset + fmc->tail->size,
+ free_chunk_size1, NULL);
+ if (!dirty_fm) {
+ printk(KERN_ERR "JFFS: "
+ "jffs_garbage_collect_next: "
+ "Failed to allocate `dirty' "
+ "flash memory!\n");
+ err = -1;
+ goto jffs_garbage_collect_next_end;
+ }
+ D1(printk("Dirtying end of flash - too small\n"));
+ jffs_write_dummy_node(c, dirty_fm);
+ err = 0;
+ goto jffs_garbage_collect_next_end;
+ }
+ D1(printk("Reducing size of new node from %d to %d to avoid "
+ " exceeding free_chunk_size1\n",
+ size, free_chunk_size1));
+
+ size = free_chunk_size1;
+ data_size = size - sizeof(struct jffs_raw_inode)
+ - total_name_size;
+ }
+
+
+ /* Calculate the amount of space needed to hold the nodes
+ which are remaining in the tail */
+ space_needed = fmc->min_free_size - (node->fm->offset % fmc->sector_size);
+
+ /* From that, calculate how much 'extra' space we can use to
+ increase the size of the node we're writing from the size
+ of the node we're obsoleting
+ */
+ if (space_needed > fmc->free_size) {
+ /* If we've gone below min_free_size for some reason,
+ don't fuck up. This is why we have
+ min_free_size > sector_size. Whinge about it though,
+ just so I can convince myself my maths is right.
+ */
+ D1(printk(KERN_WARNING "jffs_garbage_collect_next(): "
+ "space_needed %d exceeded free_size %d\n",
+ space_needed, fmc->free_size));
+ extra_available = 0;
+ } else {
+ extra_available = fmc->free_size - space_needed;
+ }
+
+ /* Check that we don't use up any more 'extra' space than
+ what's available */
+ if (size > JFFS_PAD(node->data_size) + total_name_size +
+ sizeof(struct jffs_raw_inode) + extra_available) {
+ D1(printk("Reducing size of new node from %d to %ld to avoid "
+ "catching our tail\n", size,
+ (long) (JFFS_PAD(node->data_size) + JFFS_PAD(node->name_size) +
+ sizeof(struct jffs_raw_inode) + extra_available)));
+ D1(printk("space_needed = %d, extra_available = %d\n",
+ space_needed, extra_available));
+
+ size = JFFS_PAD(node->data_size) + total_name_size +
+ sizeof(struct jffs_raw_inode) + extra_available;
+ data_size = size - sizeof(struct jffs_raw_inode)
+ - total_name_size;
+ };
+
+ D2(printk(" total_name_size: %u\n", total_name_size));
+ D2(printk(" data_size: %u\n", data_size));
+ D2(printk(" size: %u\n", size));
+ D2(printk(" f->nsize: %u\n", f->nsize));
+ D2(printk(" f->size: %u\n", f->size));
+ D2(printk(" node->data_offset: %u\n", node->data_offset));
+ D2(printk(" free_chunk_size1: %u\n", free_chunk_size1));
+ D2(printk(" free_chunk_size2: %u\n", free_chunk_size2));
+ D2(printk(" node->fm->offset: 0x%08x\n", node->fm->offset));
+
+ if ((err = jffs_rewrite_data(f, node, data_size))) {
+ printk(KERN_WARNING "jffs_rewrite_data() failed: %d\n", err);
+ return err;
+ }
+
+jffs_garbage_collect_next_end:
+ D3(printk("jffs_garbage_collect_next: Leaving...\n"));
+ return err;
+} /* jffs_garbage_collect_next */
+
+
+/* If an obsolete node is partly going to be erased due to garbage
+ collection, the part that isn't going to be erased must be filled
+ with zeroes so that the scan of the flash will work smoothly next
+ time. (The data in the file could for instance be a JFFS image
+ which could cause enormous confusion during a scan of the flash
+ device if we didn't do this.)
+ There are two phases in this procedure: First, the clearing of
+ the name and data parts of the node. Second, possibly also clearing
+ a part of the raw inode as well. If the box is power cycled during
+ the first phase, only the checksum of this node-to-be-cleared-at-
+ the-end will be wrong. If the box is power cycled during, or after,
+ the clearing of the raw inode, the information like the length of
+ the name and data parts are zeroed. The next time the box is
+ powered up, the scanning algorithm manages this faulty data too
+ because:
+
+ - The checksum is invalid and thus the raw inode must be discarded
+ in any case.
+ - If the lengths of the data part or the name part are zeroed, the
+ scanning just continues after the raw inode. But after the inode
+ the scanning procedure just finds zeroes which is the same as
+ dirt.
+
+ So, in the end, this could never fail. :-) Even if it does fail,
+ the scanning algorithm should manage that too. */
+
+static int
+jffs_clear_end_of_node(struct jffs_control *c, __u32 erase_size)
+{
+ struct jffs_fm *fm;
+ struct jffs_fmcontrol *fmc = c->fmc;
+ __u32 zero_offset;
+ __u32 zero_size;
+ __u32 zero_offset_data;
+ __u32 zero_size_data;
+ __u32 cutting_raw_inode = 0;
+
+ if (!(fm = jffs_cut_node(fmc, erase_size))) {
+ D3(printk("jffs_clear_end_of_node(): fm == NULL\n"));
+ return 0;
+ }
+
+ /* Where and how much shall we clear? */
+ zero_offset = fmc->head->offset + erase_size;
+ zero_size = fm->offset + fm->size - zero_offset;
+
+ /* Do we have to clear the raw_inode explicitly? */
+ if (fm->size - zero_size < sizeof(struct jffs_raw_inode)) {
+ cutting_raw_inode = sizeof(struct jffs_raw_inode)
+ - (fm->size - zero_size);
+ }
+
+ /* First, clear the name and data fields. */
+ zero_offset_data = zero_offset + cutting_raw_inode;
+ zero_size_data = zero_size - cutting_raw_inode;
+ flash_safe_acquire(fmc->mtd);
+ flash_memset(fmc->mtd, zero_offset_data, 0, zero_size_data);
+ flash_safe_release(fmc->mtd);
+
+ /* Should we clear a part of the raw inode? */
+ if (cutting_raw_inode) {
+ /* I guess it is ok to clear the raw inode in this order. */
+ flash_safe_acquire(fmc->mtd);
+ flash_memset(fmc->mtd, zero_offset, 0,
+ cutting_raw_inode);
+ flash_safe_release(fmc->mtd);
+ }
+
+ return 0;
+} /* jffs_clear_end_of_node() */
+
+/* Try to erase as much as possible of the dirt in the flash memory. */
+static long
+jffs_try_to_erase(struct jffs_control *c)
+{
+ struct jffs_fmcontrol *fmc = c->fmc;
+ long erase_size;
+ int err;
+ __u32 offset;
+
+ D3(printk("jffs_try_to_erase()\n"));
+
+ erase_size = jffs_erasable_size(fmc);
+
+ D2(printk("jffs_try_to_erase(): erase_size = %ld\n", erase_size));
+
+ if (erase_size == 0) {
+ return 0;
+ }
+ else if (erase_size < 0) {
+ printk(KERN_ERR "JFFS: jffs_try_to_erase: "
+ "jffs_erasable_size returned %ld.\n", erase_size);
+ return erase_size;
+ }
+
+ if ((err = jffs_clear_end_of_node(c, erase_size)) < 0) {
+ printk(KERN_ERR "JFFS: jffs_try_to_erase: "
+ "Clearing of node failed.\n");
+ return err;
+ }
+
+ offset = fmc->head->offset;
+
+ /* Now, let's try to do the erase. */
+ if ((err = flash_erase_region(fmc->mtd,
+ offset, erase_size)) < 0) {
+ printk(KERN_ERR "JFFS: Erase of flash failed. "
+ "offset = %u, erase_size = %ld\n",
+ offset, erase_size);
+ /* XXX: Here we should allocate this area as dirty
+ with jffs_fmalloced or something similar. Now
+ we just report the error. */
+ return err;
+ }
+
+#if 0
+ /* Check if the erased sectors really got erased. */
+ {
+ __u32 pos;
+ __u32 end;
+
+ pos = (__u32)flash_get_direct_pointer(to_kdev_t(c->sb->s_dev), offset);
+ end = pos + erase_size;
+
+ D2(printk("JFFS: Checking erased sector(s)...\n"));
+
+ flash_safe_acquire(fmc->mtd);
+
+ for (; pos < end; pos += 4) {
+ if (*(__u32 *)pos != JFFS_EMPTY_BITMASK) {
+ printk("JFFS: Erase failed! pos = 0x%lx\n",
+ (long)pos);
+ jffs_hexdump(fmc->mtd, pos,
+ jffs_min(256, end - pos));
+ err = -1;
+ break;
+ }
+ }
+
+ flash_safe_release(fmc->mtd);
+
+ if (!err) {
+ D2(printk("JFFS: Erase succeeded.\n"));
+ }
+ else {
+ /* XXX: Here we should allocate the memory
+ with jffs_fmalloced() in order to prevent
+ JFFS from using this area accidentally. */
+ return err;
+ }
+ }
+#endif
+
+ /* Update the flash memory data structures. */
+ jffs_sync_erase(fmc, erase_size);
+
+ return erase_size;
+}
+
+
+/* There are different criteria that should trigger a garbage collect:
+
+ 1. There is too much dirt in the memory.
+ 2. The free space is becoming small.
+ 3. There are many versions of a node.
+
+ The garbage collect should always be done in a manner that guarantees
+ that future garbage collects cannot be locked. E.g. Rewritten chunks
+ should not be too large (span more than one sector in the flash memory
+ for exemple). Of course there is a limit on how intelligent this garbage
+ collection can be. */
+
+
+static int
+jffs_garbage_collect_now(struct jffs_control *c)
+{
+ struct jffs_fmcontrol *fmc = c->fmc;
+ long erased = 0;
+ int result = 0;
+ D1(int i = 1);
+ D2(printk("***jffs_garbage_collect_now(): fmc->dirty_size = %u, fmc->free_size = 0x%x\n, fcs1=0x%x, fcs2=0x%x",
+ fmc->dirty_size, fmc->free_size, jffs_free_size1(fmc), jffs_free_size2(fmc)));
+ D2(jffs_print_fmcontrol(fmc));
+
+ // down(&fmc->gclock);
+
+ /* If it is possible to garbage collect, do so. */
+
+ while (erased == 0) {
+ D1(printk("***jffs_garbage_collect_now(): round #%u, "
+ "fmc->dirty_size = %u\n", i++, fmc->dirty_size));
+ D2(jffs_print_fmcontrol(fmc));
+
+ if ((erased = jffs_try_to_erase(c)) < 0) {
+ printk(KERN_WARNING "JFFS: Error in "
+ "garbage collector.\n");
+ result = erased;
+ goto gc_end;
+ }
+ if (erased)
+ break;
+
+ if (fmc->free_size == 0) {
+ /* Argh */
+ printk(KERN_ERR "jffs_garbage_collect_now(): free_size == 0. This is BAD.\n");
+ result = -ENOSPC;
+ break;
+ }
+
+ if (fmc->dirty_size < fmc->sector_size) {
+ /* Actually, we _may_ have been able to free some,
+ * if there are many overlapping nodes which aren't
+ * actually marked dirty because they still have
+ * some valid data in each.
+ */
+ result = -ENOSPC;
+ break;
+ }
+
+ /* Let's dare to make a garbage collect. */
+ if ((result = jffs_garbage_collect_next(c)) < 0) {
+ printk(KERN_ERR "JFFS: Something "
+ "has gone seriously wrong "
+ "with a garbage collect.\n");
+ goto gc_end;
+ }
+
+ D1(printk(" jffs_garbage_collect_now(): erased: %ld\n", erased));
+ DJM(jffs_print_memory_allocation_statistics());
+ }
+
+gc_end:
+ // up(&fmc->gclock);
+
+ D3(printk(" jffs_garbage_collect_now(): Leaving...\n"));
+ D1(if (erased) {
+ printk("jffs_g_c_now(): erased = %ld\n", erased);
+ jffs_print_fmcontrol(fmc);
+ });
+
+ if (!erased && !result)
+ return -ENOSPC;
+
+ return result;
+} /* jffs_garbage_collect_now() */
+
+
+/* Determine if it is reasonable to start garbage collection.
+ We start a gc pass if either:
+ - The number of free bytes < MIN_FREE_BYTES && at least one
+ block is dirty, OR
+ - The number of dirty bytes > MAX_DIRTY_BYTES
+*/
+static inline int thread_should_wake (struct jffs_control *c)
+{
+ D1(printk (KERN_NOTICE "thread_should_wake(): free=%d, dirty=%d, blocksize=%d.\n",
+ c->fmc->free_size, c->fmc->dirty_size, c->fmc->sector_size));
+
+ /* If there's not enough dirty space to free a block, there's no point. */
+ if (c->fmc->dirty_size < c->fmc->sector_size) {
+ D2(printk(KERN_NOTICE "thread_should_wake(): Not waking. Insufficient dirty space\n"));
+ return 0;
+ }
+#if 1
+ /* If there is too much RAM used by the various structures, GC */
+ if (jffs_get_node_inuse() > (c->fmc->used_size/c->fmc->max_chunk_size * 5 + jffs_get_file_count() * 2 + 50)) {
+ /* FIXME: Provide proof that this test can be satisfied. We
+ don't want a filesystem doing endless GC just because this
+ condition cannot ever be false.
+ */
+ D2(printk(KERN_NOTICE "thread_should_wake(): Waking due to number of nodes\n"));
+ return 1;
+ }
+#endif
+ /* If there are fewer free bytes than the threshold, GC */
+ if (c->fmc->free_size < c->gc_minfree_threshold) {
+ D2(printk(KERN_NOTICE "thread_should_wake(): Waking due to insufficent free space\n"));
+ return 1;
+ }
+ /* If there are more dirty bytes than the threshold, GC */
+ if (c->fmc->dirty_size > c->gc_maxdirty_threshold) {
+ D2(printk(KERN_NOTICE "thread_should_wake(): Waking due to excessive dirty space\n"));
+ return 1;
+ }
+ /* FIXME: What about the "There are many versions of a node" condition? */
+
+ return 0;
+}
+
+
+void jffs_garbage_collect_trigger(struct jffs_control *c)
+{
+ /* NOTE: We rely on the fact that we have the BKL here.
+ * Otherwise, the gc_task could go away between the check
+ * and the wake_up_process()
+ */
+ if (c->gc_task && thread_should_wake(c))
+ send_sig(SIGHUP, c->gc_task, 1);
+}
+
+
+/* Kernel threads take (void *) as arguments. Thus we pass
+ the jffs_control data as a (void *) and then cast it. */
+int
+jffs_garbage_collect_thread(void *ptr)
+{
+ struct jffs_control *c = (struct jffs_control *) ptr;
+ struct jffs_fmcontrol *fmc = c->fmc;
+ long erased;
+ int result = 0;
+ D1(int i = 1);
+
+ daemonize("jffs_gcd");
+
+ c->gc_task = current;
+
+ lock_kernel();
+ init_completion(&c->gc_thread_comp); /* barrier */
+ spin_lock_irq(¤t->sighand->siglock);
+ siginitsetinv (¤t->blocked, sigmask(SIGHUP) | sigmask(SIGKILL) | sigmask(SIGSTOP) | sigmask(SIGCONT));
+ recalc_sigpending();
+ spin_unlock_irq(¤t->sighand->siglock);
+
+ D1(printk (KERN_NOTICE "jffs_garbage_collect_thread(): Starting infinite loop.\n"));
+
+ for (;;) {
+
+ /* See if we need to start gc. If we don't, go to sleep.
+
+ Current implementation is a BAD THING(tm). If we try
+ to unmount the FS, the unmount operation will sleep waiting
+ for this thread to exit. We need to arrange to send it a
+ sig before the umount process sleeps.
+ */
+
+ if (!thread_should_wake(c))
+ set_current_state (TASK_INTERRUPTIBLE);
+
+ schedule(); /* Yes, we do this even if we want to go
+ on immediately - we're a low priority
+ background task. */
+
+ /* Put_super will send a SIGKILL and then wait on the sem.
+ */
+ while (signal_pending(current)) {
+ siginfo_t info;
+ unsigned long signr = 0;
+
+ spin_lock_irq(¤t->sighand->siglock);
+ signr = dequeue_signal(current, ¤t->blocked, &info);
+ spin_unlock_irq(¤t->sighand->siglock);
+
+ switch(signr) {
+ case SIGSTOP:
+ D1(printk("jffs_garbage_collect_thread(): SIGSTOP received.\n"));
+ set_current_state(TASK_STOPPED);
+ schedule();
+ break;
+
+ case SIGKILL:
+ D1(printk("jffs_garbage_collect_thread(): SIGKILL received.\n"));
+ c->gc_task = NULL;
+ complete_and_exit(&c->gc_thread_comp, 0);
+ }
+ }
+
+
+ D1(printk (KERN_NOTICE "jffs_garbage_collect_thread(): collecting.\n"));
+
+ D3(printk (KERN_NOTICE "g_c_thread(): down biglock\n"));
+ down(&fmc->biglock);
+
+ D1(printk("***jffs_garbage_collect_thread(): round #%u, "
+ "fmc->dirty_size = %u\n", i++, fmc->dirty_size));
+ D2(jffs_print_fmcontrol(fmc));
+
+ if ((erased = jffs_try_to_erase(c)) < 0) {
+ printk(KERN_WARNING "JFFS: Error in "
+ "garbage collector: %ld.\n", erased);
+ }
+
+ if (erased)
+ goto gc_end;
+
+ if (fmc->free_size == 0) {
+ /* Argh. Might as well commit suicide. */
+ printk(KERN_ERR "jffs_garbage_collect_thread(): free_size == 0. This is BAD.\n");
+ send_sig(SIGQUIT, c->gc_task, 1);
+ // panic()
+ goto gc_end;
+ }
+
+ /* Let's dare to make a garbage collect. */
+ if ((result = jffs_garbage_collect_next(c)) < 0) {
+ printk(KERN_ERR "JFFS: Something "
+ "has gone seriously wrong "
+ "with a garbage collect: %d\n", result);
+ }
+
+ gc_end:
+ D3(printk (KERN_NOTICE "g_c_thread(): up biglock\n"));
+ up(&fmc->biglock);
+ } /* for (;;) */
+} /* jffs_garbage_collect_thread() */
diff --git a/fs/jffs/intrep.h b/fs/jffs/intrep.h
new file mode 100644
index 0000000..4ae97b1
--- /dev/null
+++ b/fs/jffs/intrep.h
@@ -0,0 +1,60 @@
+/*
+ * 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: intrep.h,v 1.14 2001/09/23 23:28:37 dwmw2 Exp $
+ *
+ */
+
+#ifndef __LINUX_JFFS_INTREP_H__
+#define __LINUX_JFFS_INTREP_H__
+#include "jffs_fm.h"
+struct jffs_node *jffs_alloc_node(void);
+void jffs_free_node(struct jffs_node *n);
+int jffs_get_node_inuse(void);
+
+void jffs_cleanup_control(struct jffs_control *c);
+int jffs_build_fs(struct super_block *sb);
+
+int jffs_insert_node(struct jffs_control *c, struct jffs_file *f,
+ const struct jffs_raw_inode *raw_inode,
+ const char *name, struct jffs_node *node);
+struct jffs_file *jffs_find_file(struct jffs_control *c, __u32 ino);
+struct jffs_file *jffs_find_child(struct jffs_file *dir, const char *name, int len);
+
+void jffs_free_node(struct jffs_node *node);
+
+int jffs_foreach_file(struct jffs_control *c, int (*func)(struct jffs_file *));
+int jffs_possibly_delete_file(struct jffs_file *f);
+int jffs_insert_file_into_tree(struct jffs_file *f);
+int jffs_unlink_file_from_tree(struct jffs_file *f);
+int jffs_file_count(struct jffs_file *f);
+
+int jffs_write_node(struct jffs_control *c, struct jffs_node *node,
+ struct jffs_raw_inode *raw_inode,
+ const char *name, const unsigned char *buf,
+ int recoverable, struct jffs_file *f);
+int jffs_read_data(struct jffs_file *f, unsigned char *buf, __u32 read_offset, __u32 size);
+
+/* Garbage collection stuff. */
+int jffs_garbage_collect_thread(void *c);
+void jffs_garbage_collect_trigger(struct jffs_control *c);
+
+/* For debugging purposes. */
+void jffs_print_node(struct jffs_node *n);
+void jffs_print_raw_inode(struct jffs_raw_inode *raw_inode);
+#if 0
+int jffs_print_file(struct jffs_file *f);
+#endif /* 0 */
+void jffs_print_hash_table(struct jffs_control *c);
+void jffs_print_tree(struct jffs_file *first_file, int indent);
+
+#endif /* __LINUX_JFFS_INTREP_H__ */
diff --git a/fs/jffs/jffs_fm.c b/fs/jffs/jffs_fm.c
new file mode 100644
index 0000000..0cab8da
--- /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 */
+
diff --git a/fs/jffs/jffs_fm.h b/fs/jffs/jffs_fm.h
new file mode 100644
index 0000000..bc291c4
--- /dev/null
+++ b/fs/jffs/jffs_fm.h
@@ -0,0 +1,148 @@
+/*
+ * 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.h,v 1.13 2001/01/11 12:03:25 dwmw2 Exp $
+ *
+ * Ported to Linux 2.3.x and MTD:
+ * Copyright (C) 2000 Alexander Larsson (alex@cendio.se), Cendio Systems AB
+ *
+ */
+
+#ifndef __LINUX_JFFS_FM_H__
+#define __LINUX_JFFS_FM_H__
+
+#include <linux/types.h>
+#include <linux/jffs.h>
+#include <linux/mtd/mtd.h>
+#include <linux/config.h>
+
+/* The alignment between two nodes in the flash memory. */
+#define JFFS_ALIGN_SIZE 4
+
+/* Mark the on-flash space as obsolete when appropriate. */
+#define JFFS_MARK_OBSOLETE 0
+
+#ifndef CONFIG_JFFS_FS_VERBOSE
+#define CONFIG_JFFS_FS_VERBOSE 1
+#endif
+
+#if CONFIG_JFFS_FS_VERBOSE > 0
+#define D(x) x
+#define D1(x) D(x)
+#else
+#define D(x)
+#define D1(x)
+#endif
+
+#if CONFIG_JFFS_FS_VERBOSE > 1
+#define D2(x) D(x)
+#else
+#define D2(x)
+#endif
+
+#if CONFIG_JFFS_FS_VERBOSE > 2
+#define D3(x) D(x)
+#else
+#define D3(x)
+#endif
+
+#define ASSERT(x) x
+
+/* How many padding bytes should be inserted between two chunks of data
+ on the flash? */
+#define JFFS_GET_PAD_BYTES(size) ( (JFFS_ALIGN_SIZE-1) & -(__u32)(size) )
+#define JFFS_PAD(size) ( (size + (JFFS_ALIGN_SIZE-1)) & ~(JFFS_ALIGN_SIZE-1) )
+
+
+
+struct jffs_node_ref
+{
+ struct jffs_node *node;
+ struct jffs_node_ref *next;
+};
+
+
+/* The struct jffs_fm represents a chunk of data in the flash memory. */
+struct jffs_fm
+{
+ __u32 offset;
+ __u32 size;
+ struct jffs_fm *prev;
+ struct jffs_fm *next;
+ struct jffs_node_ref *nodes; /* USED if != 0. */
+};
+
+struct jffs_fmcontrol
+{
+ __u32 flash_size;
+ __u32 used_size;
+ __u32 dirty_size;
+ __u32 free_size;
+ __u32 sector_size;
+ __u32 min_free_size; /* The minimum free space needed to be able
+ to perform garbage collections. */
+ __u32 max_chunk_size; /* The maximum size of a chunk of data. */
+ struct mtd_info *mtd;
+ struct jffs_control *c;
+ struct jffs_fm *head;
+ struct jffs_fm *tail;
+ struct jffs_fm *head_extra;
+ struct jffs_fm *tail_extra;
+ struct semaphore biglock;
+};
+
+/* Notice the two members head_extra and tail_extra in the jffs_control
+ structure above. Those are only used during the scanning of the flash
+ memory; while the file system is being built. If the data in the flash
+ memory is organized like
+
+ +----------------+------------------+----------------+
+ | USED / DIRTY | FREE | USED / DIRTY |
+ +----------------+------------------+----------------+
+
+ then the scan is split in two parts. The first scanned part of the
+ flash memory is organized through the members head and tail. The
+ second scanned part is organized with head_extra and tail_extra. When
+ the scan is completed, the two lists are merged together. The jffs_fm
+ struct that head_extra references is the logical beginning of the
+ flash memory so it will be referenced by the head member. */
+
+
+
+struct jffs_fmcontrol *jffs_build_begin(struct jffs_control *c, int unit);
+void jffs_build_end(struct jffs_fmcontrol *fmc);
+void jffs_cleanup_fmcontrol(struct jffs_fmcontrol *fmc);
+
+int jffs_fmalloc(struct jffs_fmcontrol *fmc, __u32 size,
+ struct jffs_node *node, struct jffs_fm **result);
+int jffs_fmfree(struct jffs_fmcontrol *fmc, struct jffs_fm *fm,
+ struct jffs_node *node);
+
+__u32 jffs_free_size1(struct jffs_fmcontrol *fmc);
+__u32 jffs_free_size2(struct jffs_fmcontrol *fmc);
+void jffs_sync_erase(struct jffs_fmcontrol *fmc, int erased_size);
+struct jffs_fm *jffs_cut_node(struct jffs_fmcontrol *fmc, __u32 size);
+struct jffs_node *jffs_get_oldest_node(struct jffs_fmcontrol *fmc);
+long jffs_erasable_size(struct jffs_fmcontrol *fmc);
+struct jffs_fm *jffs_fmalloced(struct jffs_fmcontrol *fmc, __u32 offset,
+ __u32 size, struct jffs_node *node);
+int jffs_add_node(struct jffs_node *node);
+void jffs_fmfree_partly(struct jffs_fmcontrol *fmc, struct jffs_fm *fm,
+ __u32 size);
+
+void jffs_print_fmcontrol(struct jffs_fmcontrol *fmc);
+void jffs_print_fm(struct jffs_fm *fm);
+#if 0
+void jffs_print_node_ref(struct jffs_node_ref *ref);
+#endif /* 0 */
+
+#endif /* __LINUX_JFFS_FM_H__ */
diff --git a/fs/jffs/jffs_proc.c b/fs/jffs/jffs_proc.c
new file mode 100644
index 0000000..9bdd99a
--- /dev/null
+++ b/fs/jffs/jffs_proc.c
@@ -0,0 +1,261 @@
+/*
+ * JFFS -- Journaling Flash File System, Linux implementation.
+ *
+ * Copyright (C) 2000 Axis Communications AB.
+ *
+ * Created by Simon Kagstrom <simonk@axis.com>.
+ *
+ * $Id: jffs_proc.c,v 1.5 2001/06/02 14:34:55 dwmw2 Exp $
+ *
+ * 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.
+ *
+ * Overview:
+ * This file defines JFFS partition entries in the proc file system.
+ *
+ * TODO:
+ * Create some more proc files for different kinds of info, i.e. statistics
+ * about written and read bytes, number of calls to different routines,
+ * reports about failures.
+ */
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/jffs.h>
+#include <linux/slab.h>
+#include <linux/proc_fs.h>
+#include <linux/time.h>
+#include <linux/types.h>
+#include "jffs_fm.h"
+#include "jffs_proc.h"
+
+/*
+ * Structure for a JFFS partition in the system
+ */
+struct jffs_partition_dir {
+ struct jffs_control *c;
+ struct proc_dir_entry *part_root;
+ struct proc_dir_entry *part_info;
+ struct proc_dir_entry *part_layout;
+ struct jffs_partition_dir *next;
+};
+
+/*
+ * Structure for top-level entry in '/proc/fs' directory
+ */
+struct proc_dir_entry *jffs_proc_root;
+
+/*
+ * Linked list of 'jffs_partition_dirs' to help us track
+ * the mounted JFFS partitions in the system
+ */
+static struct jffs_partition_dir *jffs_part_dirs;
+
+/*
+ * Read functions for entries
+ */
+static int jffs_proc_info_read(char *page, char **start, off_t off,
+ int count, int *eof, void *data);
+static int jffs_proc_layout_read (char *page, char **start, off_t off,
+ int count, int *eof, void *data);
+
+
+/*
+ * Register a JFFS partition directory (called upon mount)
+ */
+int jffs_register_jffs_proc_dir(int mtd, struct jffs_control *c)
+{
+ struct jffs_partition_dir *part_dir;
+ struct proc_dir_entry *part_info = NULL;
+ struct proc_dir_entry *part_layout = NULL;
+ struct proc_dir_entry *part_root = NULL;
+ char name[10];
+
+ sprintf(name, "%d", mtd);
+ /* Allocate structure for local JFFS partition table */
+ part_dir = (struct jffs_partition_dir *)
+ kmalloc(sizeof (struct jffs_partition_dir), GFP_KERNEL);
+ if (!part_dir)
+ goto out;
+
+ /* Create entry for this partition */
+ part_root = proc_mkdir(name, jffs_proc_root);
+ if (!part_root)
+ goto out1;
+
+ /* Create entry for 'info' file */
+ part_info = create_proc_entry ("info", 0, part_root);
+ if (!part_info)
+ goto out2;
+ part_info->read_proc = jffs_proc_info_read;
+ part_info->data = (void *) c;
+
+ /* Create entry for 'layout' file */
+ part_layout = create_proc_entry ("layout", 0, part_root);
+ if (!part_layout)
+ goto out3;
+ part_layout->read_proc = jffs_proc_layout_read;
+ part_layout->data = (void *) c;
+
+ /* Fill in structure for table and insert in the list */
+ part_dir->c = c;
+ part_dir->part_root = part_root;
+ part_dir->part_info = part_info;
+ part_dir->part_layout = part_layout;
+ part_dir->next = jffs_part_dirs;
+ jffs_part_dirs = part_dir;
+
+ /* Return happy */
+ return 0;
+
+out3:
+ remove_proc_entry("info", part_root);
+out2:
+ remove_proc_entry(name, jffs_proc_root);
+out1:
+ kfree(part_dir);
+out:
+ return -ENOMEM;
+}
+
+
+/*
+ * Unregister a JFFS partition directory (called at umount)
+ */
+int jffs_unregister_jffs_proc_dir(struct jffs_control *c)
+{
+ struct jffs_partition_dir *part_dir = jffs_part_dirs;
+ struct jffs_partition_dir *prev_part_dir = NULL;
+
+ while (part_dir) {
+ if (part_dir->c == c) {
+ /* Remove entries for partition */
+ remove_proc_entry (part_dir->part_info->name,
+ part_dir->part_root);
+ remove_proc_entry (part_dir->part_layout->name,
+ part_dir->part_root);
+ remove_proc_entry (part_dir->part_root->name,
+ jffs_proc_root);
+
+ /* Remove entry from list */
+ if (prev_part_dir)
+ prev_part_dir->next = part_dir->next;
+ else
+ jffs_part_dirs = part_dir->next;
+
+ /*
+ * Check to see if this is the last one
+ * and remove the entry from '/proc/fs'
+ * if it is.
+ */
+ if (jffs_part_dirs == part_dir->next)
+ remove_proc_entry ("jffs", proc_root_fs);
+
+ /* Free memory for entry */
+ kfree(part_dir);
+
+ /* Return happy */
+ return 0;
+ }
+
+ /* Move to next entry */
+ prev_part_dir = part_dir;
+ part_dir = part_dir->next;
+ }
+
+ /* Return unhappy */
+ return -1;
+}
+
+
+/*
+ * Read a JFFS partition's `info' file
+ */
+static int jffs_proc_info_read (char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct jffs_control *c = (struct jffs_control *) data;
+ int len = 0;
+
+ /* Get information on the parition */
+ len += sprintf (page,
+ "partition size: %08lX (%u)\n"
+ "sector size: %08lX (%u)\n"
+ "used size: %08lX (%u)\n"
+ "dirty size: %08lX (%u)\n"
+ "free size: %08lX (%u)\n\n",
+ (unsigned long) c->fmc->flash_size, c->fmc->flash_size,
+ (unsigned long) c->fmc->sector_size, c->fmc->sector_size,
+ (unsigned long) c->fmc->used_size, c->fmc->used_size,
+ (unsigned long) c->fmc->dirty_size, c->fmc->dirty_size,
+ (unsigned long) (c->fmc->flash_size -
+ (c->fmc->used_size + c->fmc->dirty_size)),
+ c->fmc->flash_size - (c->fmc->used_size + c->fmc->dirty_size));
+
+ /* We're done */
+ *eof = 1;
+
+ /* Return length */
+ return len;
+}
+
+
+/*
+ * Read a JFFS partition's `layout' file
+ */
+static int jffs_proc_layout_read (char *page, char **start, off_t off,
+ int count, int *eof, void *data)
+{
+ struct jffs_control *c = (struct jffs_control *) data;
+ struct jffs_fm *fm = NULL;
+ struct jffs_fm *last_fm = NULL;
+ int len = 0;
+
+ /* Get the first item in the list */
+ fm = c->fmc->head;
+
+ /* Print free space */
+ if (fm && fm->offset) {
+ len += sprintf (page, "00000000 %08lX free\n",
+ (unsigned long) fm->offset);
+ }
+
+ /* Loop through all of the flash control structures */
+ while (fm && (len < (off + count))) {
+ if (fm->nodes) {
+ len += sprintf (page + len,
+ "%08lX %08lX ino=%08lX, ver=%08lX\n",
+ (unsigned long) fm->offset,
+ (unsigned long) fm->size,
+ (unsigned long) fm->nodes->node->ino,
+ (unsigned long) fm->nodes->node->version);
+ }
+ else {
+ len += sprintf (page + len,
+ "%08lX %08lX dirty\n",
+ (unsigned long) fm->offset,
+ (unsigned long) fm->size);
+ }
+ last_fm = fm;
+ fm = fm->next;
+ }
+
+ /* Print free space */
+ if ((len < (off + count)) && last_fm
+ && (last_fm->offset < c->fmc->flash_size)) {
+ len += sprintf (page + len,
+ "%08lX %08lX free\n",
+ (unsigned long) last_fm->offset +
+ last_fm->size,
+ (unsigned long) (c->fmc->flash_size -
+ (last_fm->offset + last_fm->size)));
+ }
+
+ /* We're done */
+ *eof = 1;
+
+ /* Return length */
+ return len;
+}
diff --git a/fs/jffs/jffs_proc.h b/fs/jffs/jffs_proc.h
new file mode 100644
index 0000000..39a1c5d
--- /dev/null
+++ b/fs/jffs/jffs_proc.h
@@ -0,0 +1,28 @@
+/*
+ * JFFS -- Journaling Flash File System, Linux implementation.
+ *
+ * Copyright (C) 2000 Axis Communications AB.
+ *
+ * Created by Simon Kagstrom <simonk@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_proc.h,v 1.2 2000/11/15 22:04:12 sjhill Exp $
+ */
+
+/* jffs_proc.h defines a structure for inclusion in the proc-file system. */
+#ifndef __LINUX_JFFS_PROC_H__
+#define __LINUX_JFFS_PROC_H__
+
+#include <linux/proc_fs.h>
+
+/* The proc_dir_entry for jffs (defined in jffs_proc.c). */
+extern struct proc_dir_entry *jffs_proc_root;
+
+int jffs_register_jffs_proc_dir(int mtd, struct jffs_control *c);
+int jffs_unregister_jffs_proc_dir(struct jffs_control *c);
+
+#endif /* __LINUX_JFFS_PROC_H__ */
