mm: convert printk(KERN_<LEVEL> to pr_<level>

Most of the mm subsystem uses pr_<level> so make it consistent.

Miscellanea:

 - Realign arguments
 - Add missing newline to format
 - kmemleak-test.c has a "kmemleak: " prefix added to the
   "Kmemleak testing" logging message via pr_fmt

Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Tejun Heo <tj@kernel.org>	[percpu]
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 21 insertions, 31 deletions

diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 67c30eb993f0..5a544c6c0717 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -184,9 +184,8 @@ static int kill_proc(struct task_struct *t, unsigned long addr, int trapno,
         struct siginfo si;
         int ret;
 
-        printk(KERN_ERR
-                "MCE %#lx: Killing %s:%d due to hardware memory corruption\n",
-                pfn, t->comm, t->pid);
+        pr_err("MCE %#lx: Killing %s:%d due to hardware memory corruption\n",
+               pfn, t->comm, t->pid);
         si.si_signo = SIGBUS;
         si.si_errno = 0;
         si.si_addr = (void *)addr;
@@ -209,8 +208,8 @@ static int kill_proc(struct task_struct *t, unsigned long addr, int trapno,
                 ret = send_sig_info(SIGBUS, &si, t);  /* synchronous? */
         }
         if (ret < 0)
-                printk(KERN_INFO "MCE: Error sending signal to %s:%d: %d\n",
-                       t->comm, t->pid, ret);
+                pr_info("MCE: Error sending signal to %s:%d: %d\n",
+                        t->comm, t->pid, ret);
         return ret;
 }
 
@@ -290,8 +289,7 @@ static void add_to_kill(struct task_struct *tsk, struct page *p,
         } else {
                 tk = kmalloc(sizeof(struct to_kill), GFP_ATOMIC);
                 if (!tk) {
-                        printk(KERN_ERR
-                "MCE: Out of memory while machine check handling\n");
+                        pr_err("MCE: Out of memory while machine check handling\n");
                         return;
                 }
         }
@@ -336,9 +334,8 @@ static void kill_procs(struct list_head *to_kill, int forcekill, int trapno,
                          * signal and then access the memory. Just kill it.
                          */
                         if (fail || tk->addr_valid == 0) {
-                                printk(KERN_ERR
-                "MCE %#lx: forcibly killing %s:%d because of failure to unmap corrupted page\n",
-                                        pfn, tk->tsk->comm, tk->tsk->pid);
+                                pr_err("MCE %#lx: forcibly killing %s:%d because of failure to unmap corrupted page\n",
+                                       pfn, tk->tsk->comm, tk->tsk->pid);
                                 force_sig(SIGKILL, tk->tsk);
                         }
 
@@ -350,9 +347,8 @@ static void kill_procs(struct list_head *to_kill, int forcekill, int trapno,
                          */
                         else if (kill_proc(tk->tsk, tk->addr, trapno,
                                               pfn, page, flags) < 0)
-                                printk(KERN_ERR
-                "MCE %#lx: Cannot send advisory machine check signal to %s:%d\n",
-                                        pfn, tk->tsk->comm, tk->tsk->pid);
+                                pr_err("MCE %#lx: Cannot send advisory machine check signal to %s:%d\n",
+                                       pfn, tk->tsk->comm, tk->tsk->pid);
                 }
                 put_task_struct(tk->tsk);
                 kfree(tk);
@@ -563,7 +559,7 @@ static int me_kernel(struct page *p, unsigned long pfn)
  */
 static int me_unknown(struct page *p, unsigned long pfn)
 {
-        printk(KERN_ERR "MCE %#lx: Unknown page state\n", pfn);
+        pr_err("MCE %#lx: Unknown page state\n", pfn);
         return MF_FAILED;
 }
 
@@ -608,8 +604,8 @@ static int me_pagecache_clean(struct page *p, unsigned long pfn)
         if (mapping->a_ops->error_remove_page) {
                 err = mapping->a_ops->error_remove_page(mapping, p);
                 if (err != 0) {
-                        printk(KERN_INFO "MCE %#lx: Failed to punch page: %d\n",
-                                        pfn, err);
+                        pr_info("MCE %#lx: Failed to punch page: %d\n",
+                                pfn, err);
                 } else if (page_has_private(p) &&
                                 !try_to_release_page(p, GFP_NOIO)) {
                         pr_info("MCE %#lx: failed to release buffers\n", pfn);
@@ -624,8 +620,7 @@ static int me_pagecache_clean(struct page *p, unsigned long pfn)
                 if (invalidate_inode_page(p))
                         ret = MF_RECOVERED;
                 else
-                        printk(KERN_INFO "MCE %#lx: Failed to invalidate\n",
-                                pfn);
+                        pr_info("MCE %#lx: Failed to invalidate\n", pfn);
         }
         return ret;
 }
@@ -854,8 +849,7 @@ static int page_action(struct page_state *ps, struct page *p,
         if (ps->action == me_swapcache_dirty && result == MF_DELAYED)
                 count--;
         if (count != 0) {
-                printk(KERN_ERR
-                       "MCE %#lx: %s still referenced by %d users\n",
+                pr_err("MCE %#lx: %s still referenced by %d users\n",
                        pfn, action_page_types[ps->type], count);
                 result = MF_FAILED;
         }
@@ -934,8 +928,7 @@ static int hwpoison_user_mappings(struct page *p, unsigned long pfn,
         }
 
         if (PageSwapCache(p)) {
-                printk(KERN_ERR
-                       "MCE %#lx: keeping poisoned page in swap cache\n", pfn);
+                pr_err("MCE %#lx: keeping poisoned page in swap cache\n", pfn);
                 ttu |= TTU_IGNORE_HWPOISON;
         }
 
@@ -953,8 +946,7 @@ static int hwpoison_user_mappings(struct page *p, unsigned long pfn,
                 } else {
                         kill = 0;
                         ttu |= TTU_IGNORE_HWPOISON;
-                        printk(KERN_INFO
-        "MCE %#lx: corrupted page was clean: dropped without side effects\n",
+                        pr_info("MCE %#lx: corrupted page was clean: dropped without side effects\n",
                                 pfn);
                 }
         }
@@ -972,8 +964,8 @@ static int hwpoison_user_mappings(struct page *p, unsigned long pfn,
 
         ret = try_to_unmap(hpage, ttu);
         if (ret != SWAP_SUCCESS)
-                printk(KERN_ERR "MCE %#lx: failed to unmap page (mapcount=%d)\n",
-                                pfn, page_mapcount(hpage));
+                pr_err("MCE %#lx: failed to unmap page (mapcount=%d)\n",
+                       pfn, page_mapcount(hpage));
 
         /*
          * Now that the dirty bit has been propagated to the
@@ -1040,16 +1032,14 @@ int memory_failure(unsigned long pfn, int trapno, int flags)
                 panic("Memory failure from trap %d on page %lx", trapno, pfn);
 
         if (!pfn_valid(pfn)) {
-                printk(KERN_ERR
-                       "MCE %#lx: memory outside kernel control\n",
-                       pfn);
+                pr_err("MCE %#lx: memory outside kernel control\n", pfn);
                 return -ENXIO;
         }
 
         p = pfn_to_page(pfn);
         orig_head = hpage = compound_head(p);
         if (TestSetPageHWPoison(p)) {
-                printk(KERN_ERR "MCE %#lx: already hardware poisoned\n", pfn);
+                pr_err("MCE %#lx: already hardware poisoned\n", pfn);
                 return 0;
         }
 
@@ -1180,7 +1170,7 @@ int memory_failure(unsigned long pfn, int trapno, int flags)
          * unpoison always clear PG_hwpoison inside page lock
          */
         if (!PageHWPoison(p)) {
-                printk(KERN_ERR "MCE %#lx: just unpoisoned\n", pfn);
+                pr_err("MCE %#lx: just unpoisoned\n", pfn);
                 num_poisoned_pages_sub(nr_pages);
                 unlock_page(hpage);
                 put_hwpoison_page(hpage);