patch-2.4.10 linux/fs/jffs2/build.c
Next file: linux/fs/jffs2/compr.c
Previous file: linux/fs/jffs2/background.c
Back to the patch index
Back to the overall index
- Lines: 258
- Date:
Fri Sep 14 14:04:07 2001
- Orig file:
v2.4.9/linux/fs/jffs2/build.c
- Orig date:
Wed Dec 31 16:00:00 1969
diff -u --recursive --new-file v2.4.9/linux/fs/jffs2/build.c linux/fs/jffs2/build.c
@@ -0,0 +1,257 @@
+/*
+ * JFFS2 -- Journalling Flash File System, Version 2.
+ *
+ * Copyright (C) 2001 Red Hat, Inc.
+ *
+ * Created by David Woodhouse <dwmw2@cambridge.redhat.com>
+ *
+ * The original JFFS, from which the design for JFFS2 was derived,
+ * was designed and implemented by Axis Communications AB.
+ *
+ * The contents of this file are subject to the Red Hat eCos Public
+ * License Version 1.1 (the "Licence"); you may not use this file
+ * except in compliance with the Licence. You may obtain a copy of
+ * the Licence at http://www.redhat.com/
+ *
+ * Software distributed under the Licence is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing rights and
+ * limitations under the Licence.
+ *
+ * The Original Code is JFFS2 - Journalling Flash File System, version 2
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License version 2 (the "GPL"), in
+ * which case the provisions of the GPL are applicable instead of the
+ * above. If you wish to allow the use of your version of this file
+ * only under the terms of the GPL and not to allow others to use your
+ * version of this file under the RHEPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice and
+ * other provisions required by the GPL. If you do not delete the
+ * provisions above, a recipient may use your version of this file
+ * under either the RHEPL or the GPL.
+ *
+ * $Id: build.c,v 1.16 2001/03/15 15:38:23 dwmw2 Exp $
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/jffs2.h>
+#include <linux/slab.h>
+#include "nodelist.h"
+
+int jffs2_build_inode_pass1(struct jffs2_sb_info *, struct jffs2_inode_cache *);
+int jffs2_build_remove_unlinked_inode(struct jffs2_sb_info *, struct jffs2_inode_cache *);
+
+
+#define for_each_inode(i, c, ic) for (i=0; i<INOCACHE_HASHSIZE; i++) for (ic=c->inocache_list[i]; ic; ic=ic->next)
+
+/* Scan plan:
+ - Scan physical nodes. Build map of inodes/dirents. Allocate inocaches as we go
+ - Scan directory tree from top down, setting nlink in inocaches
+ - Scan inocaches for inodes with nlink==0
+*/
+int jffs2_build_filesystem(struct jffs2_sb_info *c)
+{
+ int ret;
+ int i;
+ struct jffs2_inode_cache *ic;
+
+ /* First, scan the medium and build all the inode caches with
+ lists of physical nodes */
+ ret = jffs2_scan_medium(c);
+ if (ret)
+ return ret;
+
+ D1(printk(KERN_DEBUG "Scanned flash completely\n"));
+ /* Now build the data map for each inode, marking obsoleted nodes
+ as such, and also increase nlink of any children. */
+ for_each_inode(i, c, ic) {
+ D1(printk(KERN_DEBUG "Pass 1: ino #%u\n", ic->ino));
+ ret = jffs2_build_inode_pass1(c, ic);
+ if (ret) {
+ D1(printk(KERN_WARNING "Eep. jffs2_build_inode_pass1 for ino %d returned %d\n", ic->ino, ret));
+ return ret;
+ }
+ }
+ D1(printk(KERN_DEBUG "Pass 1 complete\n"));
+
+ /* Next, scan for inodes with nlink == 0 and remove them. If
+ they were directories, then decrement the nlink of their
+ children too, and repeat the scan. As that's going to be
+ a fairly uncommon occurrence, it's not so evil to do it this
+ way. Recursion bad. */
+ do {
+ D1(printk(KERN_DEBUG "Pass 2 (re)starting\n"));
+ ret = 0;
+ for_each_inode(i, c, ic) {
+ D1(printk(KERN_DEBUG "Pass 2: ino #%u, nlink %d, ic %p, nodes %p\n", ic->ino, ic->nlink, ic, ic->nodes));
+ if (ic->nlink)
+ continue;
+
+ ret = jffs2_build_remove_unlinked_inode(c, ic);
+ if (ret)
+ break;
+ /* -EAGAIN means the inode's nlink was zero, so we deleted it,
+ and furthermore that it had children and their nlink has now
+ gone to zero too. So we have to restart the scan. */
+ }
+ } while(ret == -EAGAIN);
+
+ D1(printk(KERN_DEBUG "Pass 2 complete\n"));
+
+ /* Finally, we can scan again and free the dirent nodes and scan_info structs */
+ for_each_inode(i, c, ic) {
+ struct jffs2_scan_info *scan = ic->scan;
+ struct jffs2_full_dirent *fd;
+ D1(printk(KERN_DEBUG "Pass 3: ino #%u, ic %p, nodes %p\n", ic->ino, ic, ic->nodes));
+ if (!scan) {
+ if (ic->nlink) {
+ D1(printk(KERN_WARNING "Why no scan struct for ino #%u which has nlink %d?\n", ic->ino, ic->nlink));
+ }
+ continue;
+ }
+ ic->scan = NULL;
+ while(scan->dents) {
+ fd = scan->dents;
+ scan->dents = fd->next;
+ jffs2_free_full_dirent(fd);
+ }
+ kfree(scan);
+ }
+ D1(printk(KERN_DEBUG "Pass 3 complete\n"));
+
+ return ret;
+}
+
+int jffs2_build_inode_pass1(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
+{
+ struct jffs2_tmp_dnode_info *tn;
+ struct jffs2_full_dirent *fd;
+ struct jffs2_node_frag *fraglist = NULL;
+ struct jffs2_tmp_dnode_info *metadata = NULL;
+
+ D1(printk(KERN_DEBUG "jffs2_build_inode building inode #%u\n", ic->ino));
+ if (ic->ino > c->highest_ino)
+ c->highest_ino = ic->ino;
+
+ if (!ic->scan->tmpnodes && ic->ino != 1) {
+ D1(printk(KERN_DEBUG "jffs2_build_inode: ino #%u has no data nodes!\n", ic->ino));
+ }
+ /* Build the list to make sure any obsolete nodes are marked as such */
+ while(ic->scan->tmpnodes) {
+ tn = ic->scan->tmpnodes;
+ ic->scan->tmpnodes = tn->next;
+
+ if (metadata && tn->version > metadata->version) {
+ D1(printk(KERN_DEBUG "jffs2_build_inode_pass1 ignoring old metadata at 0x%08x\n",
+ metadata->fn->raw->flash_offset &~3));
+
+ jffs2_free_full_dnode(metadata->fn);
+ jffs2_free_tmp_dnode_info(metadata);
+ metadata = NULL;
+ }
+
+ if (tn->fn->size) {
+ jffs2_add_full_dnode_to_fraglist (c, &fraglist, tn->fn);
+ jffs2_free_tmp_dnode_info(tn);
+ } else {
+ if (!metadata) {
+ metadata = tn;
+ } else {
+ D1(printk(KERN_DEBUG "jffs2_build_inode_pass1 ignoring new metadata at 0x%08x\n",
+ tn->fn->raw->flash_offset &~3));
+
+ jffs2_free_full_dnode(tn->fn);
+ jffs2_free_tmp_dnode_info(tn);
+ }
+ }
+ }
+
+ /* OK. Now clear up */
+ if (metadata) {
+ jffs2_free_full_dnode(metadata->fn);
+ jffs2_free_tmp_dnode_info(metadata);
+ }
+ metadata = NULL;
+
+ while (fraglist) {
+ struct jffs2_node_frag *frag;
+ frag = fraglist;
+ fraglist = fraglist->next;
+
+ if (frag->node && !(--frag->node->frags)) {
+ jffs2_free_full_dnode(frag->node);
+ }
+ jffs2_free_node_frag(frag);
+ }
+
+ /* Now for each child, increase nlink */
+ for(fd=ic->scan->dents; fd; fd = fd->next) {
+ struct jffs2_inode_cache *child_ic;
+ if (!fd->ino)
+ continue;
+
+ child_ic = jffs2_get_ino_cache(c, fd->ino);
+ if (!child_ic) {
+ printk(KERN_NOTICE "Eep. Child \"%s\" (ino #%u) of dir ino #%u doesn't exist!\n",
+ fd->name, fd->ino, ic->ino);
+ continue;
+ }
+
+ if (child_ic->nlink++ && fd->type == DT_DIR) {
+ printk(KERN_NOTICE "Child dir \"%s\" (ino #%u) of dir ino #%u appears to be a hard link\n", fd->name, fd->ino, ic->ino);
+ /* What do we do about it? */
+ }
+ D1(printk(KERN_DEBUG "Increased nlink for child \"%s\" (ino #%u)\n", fd->name, fd->ino));
+ /* Can't free them. We might need them in pass 2 */
+ }
+ return 0;
+}
+
+int jffs2_build_remove_unlinked_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
+{
+ struct jffs2_raw_node_ref *raw;
+ struct jffs2_full_dirent *fd;
+ int ret = 0;
+
+ if(!ic->scan) {
+ D1(printk(KERN_DEBUG "ino #%u was already removed\n", ic->ino));
+ return 0;
+ }
+
+ D1(printk(KERN_DEBUG "JFFS2: Removing ino #%u with nlink == zero.\n", ic->ino));
+
+ for (raw = ic->nodes; raw != (void *)ic; raw = raw->next_in_ino) {
+ D1(printk(KERN_DEBUG "obsoleting node at 0x%08x\n", raw->flash_offset&~3));
+ jffs2_mark_node_obsolete(c, raw);
+ }
+
+ if (ic->scan->dents) {
+ printk(KERN_NOTICE "Inode #%u was a directory with children - removing those too...\n", ic->ino);
+
+ while(ic->scan->dents) {
+ struct jffs2_inode_cache *child_ic;
+
+ fd = ic->scan->dents;
+ ic->scan->dents = fd->next;
+
+ D1(printk(KERN_DEBUG "Removing child \"%s\", ino #%u\n",
+ fd->name, fd->ino));
+
+ child_ic = jffs2_get_ino_cache(c, fd->ino);
+ if (!child_ic) {
+ printk(KERN_NOTICE "Cannot remove child \"%s\", ino #%u, because it doesn't exist\n", fd->name, fd->ino);
+ continue;
+ }
+ jffs2_free_full_dirent(fd);
+ child_ic->nlink--;
+ }
+ ret = -EAGAIN;
+ }
+ kfree(ic->scan);
+ ic->scan = NULL;
+ // jffs2_del_ino_cache(c, ic);
+ // jffs2_free_inode_cache(ic);
+ return ret;
+}
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)