libceph: introduce and switch to reopen_session()

[linux-2.6-block.git] / mm / memory-failure.c

diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index ac595e7a3a955d457e8ff3b6934e8728e8db6d5d..5a544c6c0717c4908fe23e17a976847fb22981ce 100644 (file)
--- 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;
 }
@@ -826,8 +821,6 @@ static struct page_state {
 #undef lru
 #undef swapbacked
 #undef head
-#undef tail
-#undef compound
 #undef slab
 #undef reserved
 
@@ -856,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;
        }
@@ -936,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;
        }
 
@@ -955,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);
                }
        }
@@ -974,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
@@ -1042,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;
        }
 
@@ -1182,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);