1 files changed, 34 insertions, 44 deletions

diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c
index 1506673c087..61e6723535b 100644
--- a/fs/jffs2/file.c
+++ b/fs/jffs2/file.c
@@ -10,8 +10,6 @@
  *
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/time.h>
@@ -87,8 +85,7 @@ static int jffs2_do_readpage_nolock (struct inode *inode, struct page *pg)
         unsigned char *pg_buf;
         int ret;
 
-        jffs2_dbg(2, "%s(): ino #%lu, page at offset 0x%lx\n",
-                  __func__, inode->i_ino, pg->index << PAGE_CACHE_SHIFT);
+        D2(printk(KERN_DEBUG "jffs2_do_readpage_nolock(): ino #%lu, page at offset 0x%lx\n", inode->i_ino, pg->index << PAGE_CACHE_SHIFT));
 
         BUG_ON(!PageLocked(pg));
 
@@ -108,7 +105,7 @@ static int jffs2_do_readpage_nolock (struct inode *inode, struct page *pg)
         flush_dcache_page(pg);
         kunmap(pg);
 
-        jffs2_dbg(2, "readpage finished\n");
+        D2(printk(KERN_DEBUG "readpage finished\n"));
         return ret;
 }
 
@@ -138,39 +135,33 @@ static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
         struct page *pg;
         struct inode *inode = mapping->host;
         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
-        struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
-        struct jffs2_raw_inode ri;
-        uint32_t alloc_len = 0;
         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
         uint32_t pageofs = index << PAGE_CACHE_SHIFT;
         int ret = 0;
 
-        jffs2_dbg(1, "%s()\n", __func__);
-
-        if (pageofs > inode->i_size) {
-                ret = jffs2_reserve_space(c, sizeof(ri), &alloc_len,
-                                          ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
-                if (ret)
-                        return ret;
-        }
-
-        mutex_lock(&f->sem);
         pg = grab_cache_page_write_begin(mapping, index, flags);
-        if (!pg) {
-                if (alloc_len)
-                        jffs2_complete_reservation(c);
-                mutex_unlock(&f->sem);
+        if (!pg)
                 return -ENOMEM;
-        }
         *pagep = pg;
 
-        if (alloc_len) {
+        D1(printk(KERN_DEBUG "jffs2_write_begin()\n"));
+
+        if (pageofs > inode->i_size) {
                 /* Make new hole frag from old EOF to new page */
+                struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
+                struct jffs2_raw_inode ri;
                 struct jffs2_full_dnode *fn;
+                uint32_t alloc_len;
 
-                jffs2_dbg(1, "Writing new hole frag 0x%x-0x%x between current EOF and new page\n",
-                          (unsigned int)inode->i_size, pageofs);
+                D1(printk(KERN_DEBUG "Writing new hole frag 0x%x-0x%x between current EOF and new page\n",
+                          (unsigned int)inode->i_size, pageofs));
+
+                ret = jffs2_reserve_space(c, sizeof(ri), &alloc_len,
+                                          ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
+                if (ret)
+                        goto out_page;
 
+                mutex_lock(&f->sem);
                 memset(&ri, 0, sizeof(ri));
 
                 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
@@ -181,8 +172,8 @@ static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
                 ri.ino = cpu_to_je32(f->inocache->ino);
                 ri.version = cpu_to_je32(++f->highest_version);
                 ri.mode = cpu_to_jemode(inode->i_mode);
-                ri.uid = cpu_to_je16(i_uid_read(inode));
-                ri.gid = cpu_to_je16(i_gid_read(inode));
+                ri.uid = cpu_to_je16(inode->i_uid);
+                ri.gid = cpu_to_je16(inode->i_gid);
                 ri.isize = cpu_to_je32(max((uint32_t)inode->i_size, pageofs));
                 ri.atime = ri.ctime = ri.mtime = cpu_to_je32(get_seconds());
                 ri.offset = cpu_to_je32(inode->i_size);
@@ -197,6 +188,7 @@ static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
                 if (IS_ERR(fn)) {
                         ret = PTR_ERR(fn);
                         jffs2_complete_reservation(c);
+                        mutex_unlock(&f->sem);
                         goto out_page;
                 }
                 ret = jffs2_add_full_dnode_to_inode(c, f, fn);
@@ -206,15 +198,16 @@ static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
                         f->metadata = NULL;
                 }
                 if (ret) {
-                        jffs2_dbg(1, "Eep. add_full_dnode_to_inode() failed in write_begin, returned %d\n",
-                                  ret);
+                        D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in write_begin, returned %d\n", ret));
                         jffs2_mark_node_obsolete(c, fn->raw);
                         jffs2_free_full_dnode(fn);
                         jffs2_complete_reservation(c);
+                        mutex_unlock(&f->sem);
                         goto out_page;
                 }
                 jffs2_complete_reservation(c);
                 inode->i_size = pageofs;
+                mutex_unlock(&f->sem);
         }
 
         /*
@@ -223,18 +216,18 @@ static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
          * case of a short-copy.
          */
         if (!PageUptodate(pg)) {
+                mutex_lock(&f->sem);
                 ret = jffs2_do_readpage_nolock(inode, pg);
+                mutex_unlock(&f->sem);
                 if (ret)
                         goto out_page;
         }
-        mutex_unlock(&f->sem);
-        jffs2_dbg(1, "end write_begin(). pg->flags %lx\n", pg->flags);
+        D1(printk(KERN_DEBUG "end write_begin(). pg->flags %lx\n", pg->flags));
         return ret;
 
 out_page:
         unlock_page(pg);
         page_cache_release(pg);
-        mutex_unlock(&f->sem);
         return ret;
 }
 
@@ -255,9 +248,8 @@ static int jffs2_write_end(struct file *filp, struct address_space *mapping,
         int ret = 0;
         uint32_t writtenlen = 0;
 
-        jffs2_dbg(1, "%s(): ino #%lu, page at 0x%lx, range %d-%d, flags %lx\n",
-                  __func__, inode->i_ino, pg->index << PAGE_CACHE_SHIFT,
-                  start, end, pg->flags);
+        D1(printk(KERN_DEBUG "jffs2_write_end(): ino #%lu, page at 0x%lx, range %d-%d, flags %lx\n",
+                  inode->i_ino, pg->index << PAGE_CACHE_SHIFT, start, end, pg->flags));
 
         /* We need to avoid deadlock with page_cache_read() in
            jffs2_garbage_collect_pass(). So the page must be
@@ -276,8 +268,7 @@ static int jffs2_write_end(struct file *filp, struct address_space *mapping,
         ri = jffs2_alloc_raw_inode();
 
         if (!ri) {
-                jffs2_dbg(1, "%s(): Allocation of raw inode failed\n",
-                          __func__);
+                D1(printk(KERN_DEBUG "jffs2_write_end(): Allocation of raw inode failed\n"));
                 unlock_page(pg);
                 page_cache_release(pg);
                 return -ENOMEM;
@@ -286,8 +277,8 @@ static int jffs2_write_end(struct file *filp, struct address_space *mapping,
         /* Set the fields that the generic jffs2_write_inode_range() code can't find */
         ri->ino = cpu_to_je32(inode->i_ino);
         ri->mode = cpu_to_jemode(inode->i_mode);
-        ri->uid = cpu_to_je16(i_uid_read(inode));
-        ri->gid = cpu_to_je16(i_gid_read(inode));
+        ri->uid = cpu_to_je16(inode->i_uid);
+        ri->gid = cpu_to_je16(inode->i_gid);
         ri->isize = cpu_to_je32((uint32_t)inode->i_size);
         ri->atime = ri->ctime = ri->mtime = cpu_to_je32(get_seconds());
 
@@ -324,14 +315,13 @@ static int jffs2_write_end(struct file *filp, struct address_space *mapping,
                 /* generic_file_write has written more to the page cache than we've
                    actually written to the medium. Mark the page !Uptodate so that
                    it gets reread */
-                jffs2_dbg(1, "%s(): Not all bytes written. Marking page !uptodate\n",
-                        __func__);
+                D1(printk(KERN_DEBUG "jffs2_write_end(): Not all bytes written. Marking page !uptodate\n"));
                 SetPageError(pg);
                 ClearPageUptodate(pg);
         }
 
-        jffs2_dbg(1, "%s() returning %d\n",
-                  __func__, writtenlen > 0 ? writtenlen : ret);
+        D1(printk(KERN_DEBUG "jffs2_write_end() returning %d\n",
+                                        writtenlen > 0 ? writtenlen : ret));
         unlock_page(pg);
         page_cache_release(pg);
         return writtenlen > 0 ? writtenlen : ret;