13 files changed, 36 insertions, 37 deletions

diff --git a/fs/jffs/jffs_fm.c b/fs/jffs/jffs_fm.c
index 077258b2103e..5a95fbdd6fdb 100644
--- a/fs/jffs/jffs_fm.c
+++ b/fs/jffs/jffs_fm.c
@@ -17,6 +17,7 @@
  *
  */
 #include <linux/slab.h>
+#include <linux/err.h>
 #include <linux/blkdev.h>
 #include <linux/jffs.h>
 #include "jffs_fm.h"
@@ -104,7 +105,7 @@ jffs_build_begin(struct jffs_control *c, int unit)
 
         mtd = get_mtd_device(NULL, unit);
 
-        if (!mtd) {
+        if (IS_ERR(mtd)) {
                 kfree(fmc);
                 DJM(no_jffs_fmcontrol--);
                 return NULL;
diff --git a/fs/jffs2/debug.c b/fs/jffs2/debug.c
index 72b4fc13a106..4189e4a36050 100644
--- a/fs/jffs2/debug.c
+++ b/fs/jffs2/debug.c
@@ -178,8 +178,8 @@ __jffs2_dbg_acct_paranoia_check_nolock(struct jffs2_sb_info *c,
         while (ref2) {
                 uint32_t totlen = ref_totlen(c, jeb, ref2);
 
-                if (ref2->flash_offset < jeb->offset ||
-                                ref2->flash_offset > jeb->offset + c->sector_size) {
+                if (ref_offset(ref2) < jeb->offset ||
+                                ref_offset(ref2) > jeb->offset + c->sector_size) {
                         JFFS2_ERROR("node_ref %#08x shouldn't be in block at %#08x.\n",
                                 ref_offset(ref2), jeb->offset);
                         goto error;
diff --git a/fs/jffs2/debug.h b/fs/jffs2/debug.h
index 3daf3bca0376..f89c85d5a3f8 100644
--- a/fs/jffs2/debug.h
+++ b/fs/jffs2/debug.h
@@ -13,6 +13,7 @@
 #ifndef _JFFS2_DEBUG_H_
 #define _JFFS2_DEBUG_H_
 
+#include <linux/sched.h>
 
 #ifndef CONFIG_JFFS2_FS_DEBUG
 #define CONFIG_JFFS2_FS_DEBUG 0
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 7bc1a4201c0c..abb90c0c09cc 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -502,12 +502,11 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
         if (ret)
                 return ret;
 
-        c->inocache_list = kmalloc(INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
+        c->inocache_list = kcalloc(INOCACHE_HASHSIZE, sizeof(struct jffs2_inode_cache *), GFP_KERNEL);
         if (!c->inocache_list) {
                 ret = -ENOMEM;
                 goto out_wbuf;
         }
-        memset(c->inocache_list, 0, INOCACHE_HASHSIZE * sizeof(struct jffs2_inode_cache *));
 
         jffs2_init_xattr_subsystem(c);
 
diff --git a/fs/jffs2/gc.c b/fs/jffs2/gc.c
index daff3341ff92..3a3cf225981f 100644
--- a/fs/jffs2/gc.c
+++ b/fs/jffs2/gc.c
@@ -838,6 +838,8 @@ static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct
 
                 for (raw = f->inocache->nodes; raw != (void *)f->inocache; raw = raw->next_in_ino) {
 
+                        cond_resched();
+
                         /* We only care about obsolete ones */
                         if (!(ref_obsolete(raw)))
                                 continue;
diff --git a/fs/jffs2/nodelist.h b/fs/jffs2/nodelist.h
index 0ddfd70307fb..4178b4b55948 100644
--- a/fs/jffs2/nodelist.h
+++ b/fs/jffs2/nodelist.h
@@ -294,23 +294,21 @@ static inline int jffs2_encode_dev(union jffs2_device_node *jdev, dev_t rdev)
 
 static inline struct jffs2_node_frag *frag_first(struct rb_root *root)
 {
-        struct rb_node *node = root->rb_node;
+        struct rb_node *node = rb_first(root);
 
         if (!node)
                 return NULL;
-        while(node->rb_left)
-                node = node->rb_left;
+
         return rb_entry(node, struct jffs2_node_frag, rb);
 }
 
 static inline struct jffs2_node_frag *frag_last(struct rb_root *root)
 {
-        struct rb_node *node = root->rb_node;
+        struct rb_node *node = rb_last(root);
 
         if (!node)
                 return NULL;
-        while(node->rb_right)
-                node = node->rb_right;
+
         return rb_entry(node, struct jffs2_node_frag, rb);
 }
 
diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c
index 266423b2709d..58a0b912e9d0 100644
--- a/fs/jffs2/readinode.c
+++ b/fs/jffs2/readinode.c
@@ -944,13 +944,12 @@ int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 int jffs2_do_crccheck_inode(struct jffs2_sb_info *c, struct jffs2_inode_cache *ic)
 {
         struct jffs2_raw_inode n;
-        struct jffs2_inode_info *f = kmalloc(sizeof(*f), GFP_KERNEL);
+        struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
         int ret;
 
         if (!f)
                 return -ENOMEM;
 
-        memset(f, 0, sizeof(*f));
         init_MUTEX_LOCKED(&f->sem);
         f->inocache = ic;
 
diff --git a/fs/jffs2/scan.c b/fs/jffs2/scan.c
index e2413466ddd5..3af746eaff0e 100644
--- a/fs/jffs2/scan.c
+++ b/fs/jffs2/scan.c
@@ -128,17 +128,19 @@ int jffs2_scan_medium(struct jffs2_sb_info *c)
         }
 
         if (jffs2_sum_active()) {
-                s = kmalloc(sizeof(struct jffs2_summary), GFP_KERNEL);
+                s = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL);
                 if (!s) {
+                        kfree(flashbuf);
                         JFFS2_WARNING("Can't allocate memory for summary\n");
                         return -ENOMEM;
                 }
-                memset(s, 0, sizeof(struct jffs2_summary));
         }
 
         for (i=0; i<c->nr_blocks; i++) {
                 struct jffs2_eraseblock *jeb = &c->blocks[i];
 
+                cond_resched();
+
                 /* reset summary info for next eraseblock scan */
                 jffs2_sum_reset_collected(s);
 
diff --git a/fs/jffs2/summary.c b/fs/jffs2/summary.c
index e52cef526d90..25265965bdc1 100644
--- a/fs/jffs2/summary.c
+++ b/fs/jffs2/summary.c
@@ -26,15 +26,13 @@
 
 int jffs2_sum_init(struct jffs2_sb_info *c)
 {
-        c->summary = kmalloc(sizeof(struct jffs2_summary), GFP_KERNEL);
+        c->summary = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL);
 
         if (!c->summary) {
                 JFFS2_WARNING("Can't allocate memory for summary information!\n");
                 return -ENOMEM;
         }
 
-        memset(c->summary, 0, sizeof(struct jffs2_summary));
-
         c->summary->sum_buf = vmalloc(c->sector_size);
 
         if (!c->summary->sum_buf) {
@@ -398,6 +396,8 @@ static int jffs2_sum_process_sum_data(struct jffs2_sb_info *c, struct jffs2_eras
         for (i=0; i<je32_to_cpu(summary->sum_num); i++) {
                 dbg_summary("processing summary index %d\n", i);
 
+                cond_resched();
+
                 /* Make sure there's a spare ref for dirty space */
                 err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
                 if (err)
diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index 7deb78254021..08a0e6c49e61 100644
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -17,6 +17,7 @@
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/fs.h>
+#include <linux/err.h>
 #include <linux/mount.h>
 #include <linux/jffs2.h>
 #include <linux/pagemap.h>
@@ -184,9 +185,9 @@ static int jffs2_get_sb_mtdnr(struct file_system_type *fs_type,
         struct mtd_info *mtd;
 
         mtd = get_mtd_device(NULL, mtdnr);
-        if (!mtd) {
+        if (IS_ERR(mtd)) {
                 D1(printk(KERN_DEBUG "jffs2: MTD device #%u doesn't appear to exist\n", mtdnr));
-                return -EINVAL;
+                return PTR_ERR(mtd);
         }
 
         return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd, mnt);
@@ -221,7 +222,7 @@ static int jffs2_get_sb(struct file_system_type *fs_type,
                         D1(printk(KERN_DEBUG "jffs2_get_sb(): mtd:%%s, name \"%s\"\n", dev_name+4));
                         for (mtdnr = 0; mtdnr < MAX_MTD_DEVICES; mtdnr++) {
                                 mtd = get_mtd_device(NULL, mtdnr);
-                                if (mtd) {
+                                if (!IS_ERR(mtd)) {
                                         if (!strcmp(mtd->name, dev_name+4))
                                                 return jffs2_get_sb_mtd(fs_type, flags, dev_name, data, mtd, mnt);
                                         put_mtd_device(mtd);
diff --git a/fs/jffs2/symlink.c b/fs/jffs2/symlink.c
index fc211b6e9b03..b90d5aa3d969 100644
--- a/fs/jffs2/symlink.c
+++ b/fs/jffs2/symlink.c
@@ -51,7 +51,7 @@ static void *jffs2_follow_link(struct dentry *dentry, struct nameidata *nd)
          */
 
         if (!p) {
-                printk(KERN_ERR "jffs2_follow_link(): can't find symlink taerget\n");
+                printk(KERN_ERR "jffs2_follow_link(): can't find symlink target\n");
                 p = ERR_PTR(-EIO);
         }
         D1(printk(KERN_DEBUG "jffs2_follow_link(): target path is '%s'\n", (char *) f->target));
diff --git a/fs/jffs2/wbuf.c b/fs/jffs2/wbuf.c
index 70707309dfa1..9c99859f5edd 100644
--- a/fs/jffs2/wbuf.c
+++ b/fs/jffs2/wbuf.c
@@ -969,8 +969,7 @@ int jffs2_check_oob_empty(struct jffs2_sb_info *c,
         int oobsize = c->mtd->oobsize;
         struct mtd_oob_ops ops;
 
-        ops.len = NR_OOB_SCAN_PAGES * oobsize;
-        ops.ooblen = oobsize;
+        ops.ooblen = NR_OOB_SCAN_PAGES * oobsize;
         ops.oobbuf = c->oobbuf;
         ops.ooboffs = 0;
         ops.datbuf = NULL;
@@ -983,10 +982,10 @@ int jffs2_check_oob_empty(struct jffs2_sb_info *c,
                 return ret;
         }
 
-        if (ops.retlen < ops.len) {
+        if (ops.oobretlen < ops.ooblen) {
                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB "
                           "returned short read (%zd bytes not %d) for block "
-                          "at %08x\n", ops.retlen, ops.len, jeb->offset));
+                          "at %08x\n", ops.oobretlen, ops.ooblen, jeb->offset));
                 return -EIO;
         }
 
@@ -1005,7 +1004,7 @@ int jffs2_check_oob_empty(struct jffs2_sb_info *c,
         }
 
         /* we know, we are aligned :) */
-        for (page = oobsize; page < ops.len; page += sizeof(long)) {
+        for (page = oobsize; page < ops.ooblen; page += sizeof(long)) {
                 long dat = *(long *)(&ops.oobbuf[page]);
                 if(dat != -1)
                         return 1;
@@ -1033,7 +1032,6 @@ int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c,
                 return 2;
         }
 
-        ops.len = oobsize;
         ops.ooblen = oobsize;
         ops.oobbuf = c->oobbuf;
         ops.ooboffs = 0;
@@ -1048,10 +1046,10 @@ int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c,
                 return ret;
         }
 
-        if (ops.retlen < ops.len) {
+        if (ops.oobretlen < ops.ooblen) {
                 D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): "
                             "Read OOB return short read (%zd bytes not %d) "
-                            "for block at %08x\n", ops.retlen, ops.len,
+                            "for block at %08x\n", ops.oobretlen, ops.ooblen,
                             jeb->offset));
                 return -EIO;
         }
@@ -1090,8 +1088,7 @@ int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
         n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
         n.totlen = cpu_to_je32(8);
 
-        ops.len = c->fsdata_len;
-        ops.ooblen = c->fsdata_len;;
+        ops.ooblen = c->fsdata_len;
         ops.oobbuf = (uint8_t *)&n;
         ops.ooboffs = c->fsdata_pos;
         ops.datbuf = NULL;
@@ -1105,10 +1102,10 @@ int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
                           jeb->offset, ret));
                 return ret;
         }
-        if (ops.retlen != ops.len) {
+        if (ops.oobretlen != ops.ooblen) {
                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): "
                           "Short write for block at %08x: %zd not %d\n",
-                          jeb->offset, ops.retlen, ops.len));
+                          jeb->offset, ops.oobretlen, ops.ooblen));
                 return -EIO;
         }
         return 0;
diff --git a/fs/jffs2/xattr.c b/fs/jffs2/xattr.c
index 4da09ce1d1f5..4bb3f1897330 100644
--- a/fs/jffs2/xattr.c
+++ b/fs/jffs2/xattr.c
@@ -399,8 +399,6 @@ static void unrefer_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datu
 {
         /* must be called under down_write(xattr_sem) */
         if (atomic_dec_and_lock(&xd->refcnt, &c->erase_completion_lock)) {
-                uint32_t xid = xd->xid, version = xd->version;
-
                 unload_xattr_datum(c, xd);
                 xd->flags |= JFFS2_XFLAGS_DEAD;
                 if (xd->node == (void *)xd) {
@@ -411,7 +409,8 @@ static void unrefer_xattr_datum(struct jffs2_sb_info *c, struct jffs2_xattr_datu
                 }
                 spin_unlock(&c->erase_completion_lock);
 
-                dbg_xattr("xdatum(xid=%u, version=%u) was removed.\n", xid, version);
+                dbg_xattr("xdatum(xid=%u, version=%u) was removed.\n",
+                          xd->xid, xd->version);
         }
 }