1 files changed, 40 insertions, 27 deletions

diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index c0d5c9d770da..bb6f993ebca9 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -10,6 +10,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/capability.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
@@ -39,7 +41,7 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
         int ret;
         int alloc_type = ALLOC_NORMAL;
 
-        D1(printk(KERN_DEBUG "jffs2_setattr(): ino #%lu\n", inode->i_ino));
+        jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
 
         /* Special cases - we don't want more than one data node
            for these types on the medium at any time. So setattr
@@ -50,7 +52,8 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
                 /* For these, we don't actually need to read the old node */
                 mdatalen = jffs2_encode_dev(&dev, inode->i_rdev);
                 mdata = (char *)&dev;
-                D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of kdev_t\n", mdatalen));
+                jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n",
+                          __func__, mdatalen);
         } else if (S_ISLNK(inode->i_mode)) {
                 mutex_lock(&f->sem);
                 mdatalen = f->metadata->size;
@@ -66,7 +69,8 @@ int jffs2_do_setattr (struct inode *inode, struct iattr *iattr)
                         return ret;
                 }
                 mutex_unlock(&f->sem);
-                D1(printk(KERN_DEBUG "jffs2_setattr(): Writing %d bytes of symlink target\n", mdatalen));
+                jffs2_dbg(1, "%s(): Writing %d bytes of symlink target\n",
+                          __func__, mdatalen);
         }
 
         ri = jffs2_alloc_raw_inode();
@@ -233,7 +237,8 @@ void jffs2_evict_inode (struct inode *inode)
         struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
         struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
 
-        D1(printk(KERN_DEBUG "jffs2_evict_inode(): ino #%lu mode %o\n", inode->i_ino, inode->i_mode));
+        jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
+                  __func__, inode->i_ino, inode->i_mode);
         truncate_inode_pages(&inode->i_data, 0);
         end_writeback(inode);
         jffs2_do_clear_inode(c, f);
@@ -249,7 +254,7 @@ struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
         dev_t rdev = 0;
         int ret;
 
-        D1(printk(KERN_DEBUG "jffs2_iget(): ino == %lu\n", ino));
+        jffs2_dbg(1, "%s(): ino == %lu\n", __func__, ino);
 
         inode = iget_locked(sb, ino);
         if (!inode)
@@ -317,14 +322,16 @@ struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
                 /* Read the device numbers from the media */
                 if (f->metadata->size != sizeof(jdev.old_id) &&
                     f->metadata->size != sizeof(jdev.new_id)) {
-                        printk(KERN_NOTICE "Device node has strange size %d\n", f->metadata->size);
+                        pr_notice("Device node has strange size %d\n",
+                                  f->metadata->size);
                         goto error_io;
                 }
-                D1(printk(KERN_DEBUG "Reading device numbers from flash\n"));
+                jffs2_dbg(1, "Reading device numbers from flash\n");
                 ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
                 if (ret < 0) {
                         /* Eep */
-                        printk(KERN_NOTICE "Read device numbers for inode %lu failed\n", (unsigned long)inode->i_ino);
+                        pr_notice("Read device numbers for inode %lu failed\n",
+                                  (unsigned long)inode->i_ino);
                         goto error;
                 }
                 if (f->metadata->size == sizeof(jdev.old_id))
@@ -339,12 +346,13 @@ struct inode *jffs2_iget(struct super_block *sb, unsigned long ino)
                 break;
 
         default:
-                printk(KERN_WARNING "jffs2_read_inode(): Bogus imode %o for ino %lu\n", inode->i_mode, (unsigned long)inode->i_ino);
+                pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
+                        __func__, inode->i_mode, (unsigned long)inode->i_ino);
         }
 
         mutex_unlock(&f->sem);
 
-        D1(printk(KERN_DEBUG "jffs2_read_inode() returning\n"));
+        jffs2_dbg(1, "jffs2_read_inode() returning\n");
         unlock_new_inode(inode);
         return inode;
 
@@ -362,11 +370,13 @@ void jffs2_dirty_inode(struct inode *inode, int flags)
         struct iattr iattr;
 
         if (!(inode->i_state & I_DIRTY_DATASYNC)) {
-                D2(printk(KERN_DEBUG "jffs2_dirty_inode() not calling setattr() for ino #%lu\n", inode->i_ino));
+                jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
+                          __func__, inode->i_ino);
                 return;
         }
 
-        D1(printk(KERN_DEBUG "jffs2_dirty_inode() calling setattr() for ino #%lu\n", inode->i_ino));
+        jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
+                  __func__, inode->i_ino);
 
         iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
         iattr.ia_mode = inode->i_mode;
@@ -414,7 +424,8 @@ struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_r
         struct jffs2_inode_info *f;
         int ret;
 
-        D1(printk(KERN_DEBUG "jffs2_new_inode(): dir_i %ld, mode 0x%x\n", dir_i->i_ino, mode));
+        jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
+                  __func__, dir_i->i_ino, mode);
 
         c = JFFS2_SB_INFO(sb);
 
@@ -504,11 +515,11 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
 
 #ifndef CONFIG_JFFS2_FS_WRITEBUFFER
         if (c->mtd->type == MTD_NANDFLASH) {
-                printk(KERN_ERR "jffs2: Cannot operate on NAND flash unless jffs2 NAND support is compiled in.\n");
+                pr_err("Cannot operate on NAND flash unless jffs2 NAND support is compiled in\n");
                 return -EINVAL;
         }
         if (c->mtd->type == MTD_DATAFLASH) {
-                printk(KERN_ERR "jffs2: Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in.\n");
+                pr_err("Cannot operate on DataFlash unless jffs2 DataFlash support is compiled in\n");
                 return -EINVAL;
         }
 #endif
@@ -522,12 +533,13 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
          */
         if ((c->sector_size * blocks) != c->flash_size) {
                 c->flash_size = c->sector_size * blocks;
-                printk(KERN_INFO "jffs2: Flash size not aligned to erasesize, reducing to %dKiB\n",
+                pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
                         c->flash_size / 1024);
         }
 
         if (c->flash_size < 5*c->sector_size) {
-                printk(KERN_ERR "jffs2: Too few erase blocks (%d)\n", c->flash_size / c->sector_size);
+                pr_err("Too few erase blocks (%d)\n",
+                       c->flash_size / c->sector_size);
                 return -EINVAL;
         }
 
@@ -550,17 +562,17 @@ int jffs2_do_fill_super(struct super_block *sb, void *data, int silent)
         if ((ret = jffs2_do_mount_fs(c)))
                 goto out_inohash;
 
-        D1(printk(KERN_DEBUG "jffs2_do_fill_super(): Getting root inode\n"));
+        jffs2_dbg(1, "%s(): Getting root inode\n", __func__);
         root_i = jffs2_iget(sb, 1);
         if (IS_ERR(root_i)) {
-                D1(printk(KERN_WARNING "get root inode failed\n"));
+                jffs2_dbg(1, "get root inode failed\n");
                 ret = PTR_ERR(root_i);
                 goto out_root;
         }
 
         ret = -ENOMEM;
 
-        D1(printk(KERN_DEBUG "jffs2_do_fill_super(): d_alloc_root()\n"));
+        jffs2_dbg(1, "%s(): d_make_root()\n", __func__);
         sb->s_root = d_make_root(root_i);
         if (!sb->s_root)
                 goto out_root;
@@ -618,20 +630,21 @@ struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
                 */
                 inode = ilookup(OFNI_BS_2SFFJ(c), inum);
                 if (!inode) {
-                        D1(printk(KERN_DEBUG "ilookup() failed for ino #%u; inode is probably deleted.\n",
-                                  inum));
+                        jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
+                                  inum);
 
                         spin_lock(&c->inocache_lock);
                         ic = jffs2_get_ino_cache(c, inum);
                         if (!ic) {
-                                D1(printk(KERN_DEBUG "Inode cache for ino #%u is gone.\n", inum));
+                                jffs2_dbg(1, "Inode cache for ino #%u is gone\n",
+                                          inum);
                                 spin_unlock(&c->inocache_lock);
                                 return NULL;
                         }
                         if (ic->state != INO_STATE_CHECKEDABSENT) {
                                 /* Wait for progress. Don't just loop */
-                                D1(printk(KERN_DEBUG "Waiting for ino #%u in state %d\n",
-                                          ic->ino, ic->state));
+                                jffs2_dbg(1, "Waiting for ino #%u in state %d\n",
+                                          ic->ino, ic->state);
                                 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
                         } else {
                                 spin_unlock(&c->inocache_lock);
@@ -649,8 +662,8 @@ struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
                         return ERR_CAST(inode);
         }
         if (is_bad_inode(inode)) {
-                printk(KERN_NOTICE "Eep. read_inode() failed for ino #%u. unlinked %d\n",
-                       inum, unlinked);
+                pr_notice("Eep. read_inode() failed for ino #%u. unlinked %d\n",
+                          inum, unlinked);
                 /* NB. This will happen again. We need to do something appropriate here. */
                 iput(inode);
                 return ERR_PTR(-EIO);