Patched in Tegra support.

1 files changed, 49 insertions, 64 deletions

diff --git a/fs/jffs2/write.c b/fs/jffs2/write.c
index b634de4c810..30d175b6d29 100644
--- a/fs/jffs2/write.c
+++ b/fs/jffs2/write.c
@@ -9,8 +9,6 @@
  *
  */
 
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/crc32.h>
@@ -38,7 +36,7 @@ int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
         f->inocache->state = INO_STATE_PRESENT;
 
         jffs2_add_ino_cache(c, f->inocache);
-        jffs2_dbg(1, "%s(): Assigned ino# %d\n", __func__, f->inocache->ino);
+        D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino));
         ri->ino = cpu_to_je32(f->inocache->ino);
 
         ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
@@ -70,7 +68,7 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
         unsigned long cnt = 2;
 
         D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) {
-                pr_crit("Eep. CRC not correct in jffs2_write_dnode()\n");
+                printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n");
                 BUG();
         }
            );
@@ -80,9 +78,7 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
         vecs[1].iov_len = datalen;
 
         if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
-                pr_warn("%s(): ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n",
-                        __func__, je32_to_cpu(ri->totlen),
-                        sizeof(*ri), datalen);
+                printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", je32_to_cpu(ri->totlen), sizeof(*ri), datalen);
         }
 
         fn = jffs2_alloc_full_dnode();
@@ -99,9 +95,9 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
 
         if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
                 BUG_ON(!retried);
-                jffs2_dbg(1, "%s(): dnode_version %d, highest version %d -> updating dnode\n",
-                          __func__,
-                          je32_to_cpu(ri->version), f->highest_version);
+                D1(printk(KERN_DEBUG "jffs2_write_dnode : dnode_version %d, "
+                                "highest version %d -> updating dnode\n",
+                                je32_to_cpu(ri->version), f->highest_version));
                 ri->version = cpu_to_je32(++f->highest_version);
                 ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
         }
@@ -110,8 +106,8 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
                                  (alloc_mode==ALLOC_GC)?0:f->inocache->ino);
 
         if (ret || (retlen != sizeof(*ri) + datalen)) {
-                pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
-                          sizeof(*ri) + datalen, flash_ofs, ret, retlen);
+                printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
+                       sizeof(*ri)+datalen, flash_ofs, ret, retlen);
 
                 /* Mark the space as dirtied */
                 if (retlen) {
@@ -122,8 +118,7 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
                            this node */
                         jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
                 } else {
-                        pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
-                                  flash_ofs);
+                        printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
                 }
                 if (!retried && alloc_mode != ALLOC_NORETRY) {
                         /* Try to reallocate space and retry */
@@ -132,7 +127,7 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
 
                         retried = 1;
 
-                        jffs2_dbg(1, "Retrying failed write.\n");
+                        D1(printk(KERN_DEBUG "Retrying failed write.\n"));
 
                         jffs2_dbg_acct_sanity_check(c,jeb);
                         jffs2_dbg_acct_paranoia_check(c, jeb);
@@ -152,16 +147,14 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
 
                         if (!ret) {
                                 flash_ofs = write_ofs(c);
-                                jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write.\n",
-                                          flash_ofs);
+                                D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
 
                                 jffs2_dbg_acct_sanity_check(c,jeb);
                                 jffs2_dbg_acct_paranoia_check(c, jeb);
 
                                 goto retry;
                         }
-                        jffs2_dbg(1, "Failed to allocate space to retry failed write: %d!\n",
-                                  ret);
+                        D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
                 }
                 /* Release the full_dnode which is now useless, and return */
                 jffs2_free_full_dnode(fn);
@@ -190,10 +183,10 @@ struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2
         fn->size = je32_to_cpu(ri->dsize);
         fn->frags = 0;
 
-        jffs2_dbg(1, "jffs2_write_dnode wrote node at 0x%08x(%d) with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n",
+        D1(printk(KERN_DEBUG "jffs2_write_dnode wrote node at 0x%08x(%d) with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n",
                   flash_ofs & ~3, flash_ofs & 3, je32_to_cpu(ri->dsize),
                   je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc),
-                  je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen));
+                  je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)));
 
         if (retried) {
                 jffs2_dbg_acct_sanity_check(c,NULL);
@@ -213,23 +206,22 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
         int retried = 0;
         int ret;
 
-        jffs2_dbg(1, "%s(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n",
-                  __func__,
+        D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n",
                   je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
-                  je32_to_cpu(rd->name_crc));
+                  je32_to_cpu(rd->name_crc)));
 
         D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
-                pr_crit("Eep. CRC not correct in jffs2_write_dirent()\n");
+                printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
                 BUG();
            });
 
         if (strnlen(name, namelen) != namelen) {
                 /* This should never happen, but seems to have done on at least one
                    occasion: https://dev.laptop.org/ticket/4184 */
-                pr_crit("Error in jffs2_write_dirent() -- name contains zero bytes!\n");
-                pr_crit("Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
-                        je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
-                        je32_to_cpu(rd->name_crc));
+                printk(KERN_CRIT "Error in jffs2_write_dirent() -- name contains zero bytes!\n");
+                printk(KERN_CRIT "Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
+                       je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
+                       je32_to_cpu(rd->name_crc));
                 WARN_ON(1);
                 return ERR_PTR(-EIO);
         }
@@ -257,9 +249,9 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
 
         if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
                 BUG_ON(!retried);
-                jffs2_dbg(1, "%s(): dirent_version %d, highest version %d -> updating dirent\n",
-                          __func__,
-                          je32_to_cpu(rd->version), f->highest_version);
+                D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, "
+                                     "highest version %d -> updating dirent\n",
+                                     je32_to_cpu(rd->version), f->highest_version));
                 rd->version = cpu_to_je32(++f->highest_version);
                 fd->version = je32_to_cpu(rd->version);
                 rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
@@ -268,14 +260,13 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
         ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
                                  (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino));
         if (ret || (retlen != sizeof(*rd) + namelen)) {
-                pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
-                          sizeof(*rd) + namelen, flash_ofs, ret, retlen);
+                printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
+                               sizeof(*rd)+namelen, flash_ofs, ret, retlen);
                 /* Mark the space as dirtied */
                 if (retlen) {
                         jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
                 } else {
-                        pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
-                                  flash_ofs);
+                        printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", flash_ofs);
                 }
                 if (!retried) {
                         /* Try to reallocate space and retry */
@@ -284,7 +275,7 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
 
                         retried = 1;
 
-                        jffs2_dbg(1, "Retrying failed write.\n");
+                        D1(printk(KERN_DEBUG "Retrying failed write.\n"));
 
                         jffs2_dbg_acct_sanity_check(c,jeb);
                         jffs2_dbg_acct_paranoia_check(c, jeb);
@@ -304,14 +295,12 @@ struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jff
 
                         if (!ret) {
                                 flash_ofs = write_ofs(c);
-                                jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write\n",
-                                          flash_ofs);
+                                D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
                                 jffs2_dbg_acct_sanity_check(c,jeb);
                                 jffs2_dbg_acct_paranoia_check(c, jeb);
                                 goto retry;
                         }
-                        jffs2_dbg(1, "Failed to allocate space to retry failed write: %d!\n",
-                                  ret);
+                        D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
                 }
                 /* Release the full_dnode which is now useless, and return */
                 jffs2_free_full_dirent(fd);
@@ -344,8 +333,8 @@ int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
         int ret = 0;
         uint32_t writtenlen = 0;
 
-        jffs2_dbg(1, "%s(): Ino #%u, ofs 0x%x, len 0x%x\n",
-                  __func__, f->inocache->ino, offset, writelen);
+        D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
+                  f->inocache->ino, offset, writelen));
 
         while(writelen) {
                 struct jffs2_full_dnode *fn;
@@ -356,13 +345,12 @@ int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                 int retried = 0;
 
         retry:
-                jffs2_dbg(2, "jffs2_commit_write() loop: 0x%x to write to 0x%x\n",
-                          writelen, offset);
+                D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
 
                 ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
                                         &alloclen, ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
                 if (ret) {
-                        jffs2_dbg(1, "jffs2_reserve_space returned %d\n", ret);
+                        D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
                         break;
                 }
                 mutex_lock(&f->sem);
@@ -398,7 +386,7 @@ int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                         if (!retried) {
                                 /* Write error to be retried */
                                 retried = 1;
-                                jffs2_dbg(1, "Retrying node write in jffs2_write_inode_range()\n");
+                                D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
                                 goto retry;
                         }
                         break;
@@ -411,8 +399,7 @@ int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                 }
                 if (ret) {
                         /* Eep */
-                        jffs2_dbg(1, "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n",
-                                  ret);
+                        D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
                         jffs2_mark_node_obsolete(c, fn->raw);
                         jffs2_free_full_dnode(fn);
 
@@ -423,11 +410,11 @@ int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
                 mutex_unlock(&f->sem);
                 jffs2_complete_reservation(c);
                 if (!datalen) {
-                        pr_warn("Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
+                        printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
                         ret = -EIO;
                         break;
                 }
-                jffs2_dbg(1, "increasing writtenlen by %d\n", datalen);
+                D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
                 writtenlen += datalen;
                 offset += datalen;
                 writelen -= datalen;
@@ -452,7 +439,7 @@ int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
          */
         ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
                                 JFFS2_SUMMARY_INODE_SIZE);
-        jffs2_dbg(1, "%s(): reserved 0x%x bytes\n", __func__, alloclen);
+        D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
         if (ret)
                 return ret;
 
@@ -463,11 +450,11 @@ int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
 
         fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
 
-        jffs2_dbg(1, "jffs2_do_create created file with mode 0x%x\n",
-                  jemode_to_cpu(ri->mode));
+        D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
+                  jemode_to_cpu(ri->mode)));
 
         if (IS_ERR(fn)) {
-                jffs2_dbg(1, "jffs2_write_dnode() failed\n");
+                D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
                 /* Eeek. Wave bye bye */
                 mutex_unlock(&f->sem);
                 jffs2_complete_reservation(c);
@@ -493,7 +480,7 @@ int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
 
         if (ret) {
                 /* Eep. */
-                jffs2_dbg(1, "jffs2_reserve_space() for dirent failed\n");
+                D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
                 return ret;
         }
 
@@ -610,8 +597,8 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
                             !memcmp(fd->name, name, namelen) &&
                             !fd->name[namelen]) {
 
-                                jffs2_dbg(1, "Marking old dirent node (ino #%u) @%08x obsolete\n",
-                                          fd->ino, ref_offset(fd->raw));
+                                D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
+                                          fd->ino, ref_offset(fd->raw)));
                                 jffs2_mark_node_obsolete(c, fd->raw);
                                 /* We don't want to remove it from the list immediately,
                                    because that screws up getdents()/seek() semantics even
@@ -640,13 +627,11 @@ int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
                                 dead_f->dents = fd->next;
 
                                 if (fd->ino) {
-                                        pr_warn("Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
-                                                dead_f->inocache->ino,
-                                                fd->name, fd->ino);
+                                        printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
+                                               dead_f->inocache->ino, fd->name, fd->ino);
                                 } else {
-                                        jffs2_dbg(1, "Removing deletion dirent for \"%s\" from dir ino #%u\n",
-                                                  fd->name,
-                                                  dead_f->inocache->ino);
+                                        D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
+                                                fd->name, dead_f->inocache->ino));
                                 }
                                 if (fd->raw)
                                         jffs2_mark_node_obsolete(c, fd->raw);