redonkable/freescale-linux-fslc
redonkable/freescale-linux-fslc
1
0
Fork 0
Code Releases Activity

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

Browse source 
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>
This commit is contained in:
Joe Perches 2016-03-17 14:19:50 -07:00 committed by Linus Torvalds
parent 756a025f00
commit 1170532bb4
20 changed files with 118 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
mm/backing-dev.c
View file

@ -1026,8 +1026,8 @@ int pdflush_proc_obsolete(struct ctl_table *table, int write,
if (copy_to_user(buffer, kbuf, sizeof(kbuf))) if (copy_to_user(buffer, kbuf, sizeof(kbuf)))
return -EFAULT; return -EFAULT;
printk_once(KERN_WARNING "%s exported in /proc is scheduled for removal\n", pr_warn_once("%s exported in /proc is scheduled for removal\n",
table->procname); table->procname);
*lenp = 2; *lenp = 2;
*ppos += *lenp; *ppos += *lenp;

7
mm/bootmem.c
View file

@ -50,8 +50,7 @@ early_param("bootmem_debug", bootmem_debug_setup);
#define bdebug(fmt, args...) ({ \ #define bdebug(fmt, args...) ({ \
if (unlikely(bootmem_debug)) \ if (unlikely(bootmem_debug)) \
printk(KERN_INFO \ pr_info("bootmem::%s " fmt, \
"bootmem::%s " fmt, \
__func__, ## args); \ __func__, ## args); \
}) })
@ -680,7 +679,7 @@ static void * __init ___alloc_bootmem(unsigned long size, unsigned long align,
/* /*
* Whoops, we cannot satisfy the allocation request. * Whoops, we cannot satisfy the allocation request.
*/ */
printk(KERN_ALERT "bootmem alloc of %lu bytes failed!\n", size); pr_alert("bootmem alloc of %lu bytes failed!\n", size);
panic("Out of memory"); panic("Out of memory");
return NULL; return NULL;
} }
@ -755,7 +754,7 @@ void * __init ___alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
if (ptr) if (ptr)
return ptr; return ptr;
printk(KERN_ALERT "bootmem alloc of %lu bytes failed!\n", size); pr_alert("bootmem alloc of %lu bytes failed!\n", size);
panic("Out of memory"); panic("Out of memory");
return NULL; return NULL;
} }

12
mm/dmapool.c
View file

@ -294,8 +294,7 @@ void dma_pool_destroy(struct dma_pool *pool)
"dma_pool_destroy %s, %p busy\n", "dma_pool_destroy %s, %p busy\n",
pool->name, page->vaddr); pool->name, page->vaddr);
else else
printk(KERN_ERR pr_err("dma_pool_destroy %s, %p busy\n",
"dma_pool_destroy %s, %p busy\n",
pool->name, page->vaddr); pool->name, page->vaddr);
/* leak the still-in-use consistent memory */ /* leak the still-in-use consistent memory */
list_del(&page->page_list); list_del(&page->page_list);
@ -424,7 +423,7 @@ void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
"dma_pool_free %s, %p/%lx (bad dma)\n", "dma_pool_free %s, %p/%lx (bad dma)\n",
pool->name, vaddr, (unsigned long)dma); pool->name, vaddr, (unsigned long)dma);
else else
printk(KERN_ERR "dma_pool_free %s, %p/%lx (bad dma)\n", pr_err("dma_pool_free %s, %p/%lx (bad dma)\n",
pool->name, vaddr, (unsigned long)dma); pool->name, vaddr, (unsigned long)dma);
return; return;
} }
@ -438,8 +437,7 @@ void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
"dma_pool_free %s, %p (bad vaddr)/%Lx\n", "dma_pool_free %s, %p (bad vaddr)/%Lx\n",
pool->name, vaddr, (unsigned long long)dma); pool->name, vaddr, (unsigned long long)dma);
else else
printk(KERN_ERR pr_err("dma_pool_free %s, %p (bad vaddr)/%Lx\n",
"dma_pool_free %s, %p (bad vaddr)/%Lx\n",
pool->name, vaddr, (unsigned long long)dma); pool->name, vaddr, (unsigned long long)dma);
return; return;
} }
@ -455,8 +453,8 @@ void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
dev_err(pool->dev, "dma_pool_free %s, dma %Lx already free\n", dev_err(pool->dev, "dma_pool_free %s, dma %Lx already free\n",
pool->name, (unsigned long long)dma); pool->name, (unsigned long long)dma);
else else
printk(KERN_ERR "dma_pool_free %s, dma %Lx already free\n", pr_err("dma_pool_free %s, dma %Lx already free\n",
pool->name, (unsigned long long)dma); pool->name, (unsigned long long)dma);
return; return;
} }
} }

2
mm/internal.h
View file

@ -386,7 +386,7 @@ extern int mminit_loglevel;
do { \ do { \
if (level < mminit_loglevel) { \ if (level < mminit_loglevel) { \
if (level <= MMINIT_WARNING) \ if (level <= MMINIT_WARNING) \
printk(KERN_WARNING "mminit::" prefix " " fmt, ##arg); \ pr_warn("mminit::" prefix " " fmt, ##arg); \
else \ else \
printk(KERN_DEBUG "mminit::" prefix " " fmt, ##arg); \ printk(KERN_DEBUG "mminit::" prefix " " fmt, ##arg); \
} \ } \

2
mm/kmemcheck.c
View file

@ -20,7 +20,7 @@ void kmemcheck_alloc_shadow(struct page *page, int order, gfp_t flags, int node)
shadow = alloc_pages_node(node, flags | __GFP_NOTRACK, order); shadow = alloc_pages_node(node, flags | __GFP_NOTRACK, order);
if (!shadow) { if (!shadow) {
if (printk_ratelimit()) if (printk_ratelimit())
printk(KERN_ERR "kmemcheck: failed to allocate shadow bitmap\n"); pr_err("kmemcheck: failed to allocate shadow bitmap\n");
return; return;
} }

2
mm/kmemleak-test.c
View file

@ -49,7 +49,7 @@ static int __init kmemleak_test_init(void)
struct test_node *elem; struct test_node *elem;
int i; int i;
printk(KERN_INFO "Kmemleak testing\n"); pr_info("Kmemleak testing\n");
/* make some orphan objects */ /* make some orphan objects */
pr_info("kmalloc(32) = %p\n", kmalloc(32, GFP_KERNEL)); pr_info("kmalloc(32) = %p\n", kmalloc(32, GFP_KERNEL));

52
mm/memory-failure.c
View file

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

17
mm/memory.c
View file

@ -660,9 +660,8 @@ static void print_bad_pte(struct vm_area_struct *vma, unsigned long addr,
return; return;
} }
if (nr_unshown) { if (nr_unshown) {
printk(KERN_ALERT pr_alert("BUG: Bad page map: %lu messages suppressed\n",
"BUG: Bad page map: %lu messages suppressed\n", nr_unshown);
nr_unshown);
nr_unshown = 0; nr_unshown = 0;
} }
nr_shown = 0; nr_shown = 0;
@ -673,15 +672,13 @@ static void print_bad_pte(struct vm_area_struct *vma, unsigned long addr,
mapping = vma->vm_file ? vma->vm_file->f_mapping : NULL; mapping = vma->vm_file ? vma->vm_file->f_mapping : NULL;
index = linear_page_index(vma, addr); index = linear_page_index(vma, addr);
printk(KERN_ALERT pr_alert("BUG: Bad page map in process %s pte:%08llx pmd:%08llx\n",
"BUG: Bad page map in process %s pte:%08llx pmd:%08llx\n", current->comm,
current->comm, (long long)pte_val(pte), (long long)pmd_val(*pmd));
(long long)pte_val(pte), (long long)pmd_val(*pmd));
if (page) if (page)
dump_page(page, "bad pte"); dump_page(page, "bad pte");
printk(KERN_ALERT pr_alert("addr:%p vm_flags:%08lx anon_vma:%p mapping:%p index:%lx\n",
"addr:%p vm_flags:%08lx anon_vma:%p mapping:%p index:%lx\n", (void *)addr, vma->vm_flags, vma->anon_vma, mapping, index);
(void *)addr, vma->vm_flags, vma->anon_vma, mapping, index);
/* /*
* Choose text because data symbols depend on CONFIG_KALLSYMS_ALL=y * Choose text because data symbols depend on CONFIG_KALLSYMS_ALL=y
*/ */

7
mm/mm_init.c
View file

@ -55,13 +55,12 @@ void __init mminit_verify_zonelist(void)
/* Iterate the zonelist */ /* Iterate the zonelist */
for_each_zone_zonelist(zone, z, zonelist, zoneid) { for_each_zone_zonelist(zone, z, zonelist, zoneid) {
#ifdef CONFIG_NUMA #ifdef CONFIG_NUMA
printk(KERN_CONT "%d:%s ", pr_cont("%d:%s ", zone->node, zone->name);
zone->node, zone->name);
#else #else
printk(KERN_CONT "0:%s ", zone->name); pr_cont("0:%s ", zone->name);
#endif /* CONFIG_NUMA */ #endif /* CONFIG_NUMA */
} }
printk(KERN_CONT "\n"); pr_cont("\n");
} }
} }
} }

4
mm/nobootmem.c
View file

@ -288,7 +288,7 @@ static void * __init ___alloc_bootmem(unsigned long size, unsigned long align,
/* /*
* Whoops, we cannot satisfy the allocation request. * Whoops, we cannot satisfy the allocation request.
*/ */
printk(KERN_ALERT "bootmem alloc of %lu bytes failed!\n", size); pr_alert("bootmem alloc of %lu bytes failed!\n", size);
panic("Out of memory"); panic("Out of memory");
return NULL; return NULL;
} }
@ -360,7 +360,7 @@ static void * __init ___alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
if (ptr) if (ptr)
return ptr; return ptr;
printk(KERN_ALERT "bootmem alloc of %lu bytes failed!\n", size); pr_alert("bootmem alloc of %lu bytes failed!\n", size);
panic("Out of memory"); panic("Out of memory");
return NULL; return NULL;
} }

24
mm/page_alloc.c
View file

@ -544,11 +544,11 @@ static int __init debug_guardpage_minorder_setup(char *buf)
unsigned long res; unsigned long res;
if (kstrtoul(buf, 10, &res) < 0 || res > MAX_ORDER / 2) { if (kstrtoul(buf, 10, &res) < 0 || res > MAX_ORDER / 2) {
printk(KERN_ERR "Bad debug_guardpage_minorder value\n"); pr_err("Bad debug_guardpage_minorder value\n");
return 0; return 0;
} }
_debug_guardpage_minorder = res; _debug_guardpage_minorder = res;
printk(KERN_INFO "Setting debug_guardpage_minorder to %lu\n", res); pr_info("Setting debug_guardpage_minorder to %lu\n", res);
return 0; return 0;
} }
__setup("debug_guardpage_minorder=", debug_guardpage_minorder_setup); __setup("debug_guardpage_minorder=", debug_guardpage_minorder_setup);
@ -4073,8 +4073,7 @@ static int __parse_numa_zonelist_order(char *s)
} else if (*s == 'z' || *s == 'Z') { } else if (*s == 'z' || *s == 'Z') {
user_zonelist_order = ZONELIST_ORDER_ZONE; user_zonelist_order = ZONELIST_ORDER_ZONE;
} else { } else {
printk(KERN_WARNING pr_warn("Ignoring invalid numa_zonelist_order value: %s\n", s);
"Ignoring invalid numa_zonelist_order value: %s\n", s);
return -EINVAL; return -EINVAL;
} }
return 0; return 0;
@ -5458,8 +5457,7 @@ static void __paginginit free_area_init_core(struct pglist_data *pgdat)
" %s zone: %lu pages used for memmap\n", " %s zone: %lu pages used for memmap\n",
zone_names[j], memmap_pages); zone_names[j], memmap_pages);
} else } else
printk(KERN_WARNING pr_warn(" %s zone: %lu pages exceeds freesize %lu\n",
" %s zone: %lu pages exceeds freesize %lu\n",
zone_names[j], memmap_pages, freesize); zone_names[j], memmap_pages, freesize);
} }
@ -5667,8 +5665,7 @@ static unsigned long __init find_min_pfn_for_node(int nid)
min_pfn = min(min_pfn, start_pfn); min_pfn = min(min_pfn, start_pfn);
if (min_pfn == ULONG_MAX) { if (min_pfn == ULONG_MAX) {
printk(KERN_WARNING pr_warn("Could not find start_pfn for node %d\n", nid);
"Could not find start_pfn for node %d\n", nid);
return 0; return 0;
} }
@ -6686,11 +6683,8 @@ void *__init alloc_large_system_hash(const char *tablename,
if (!table) if (!table)
panic("Failed to allocate %s hash table\n", tablename); panic("Failed to allocate %s hash table\n", tablename);
printk(KERN_INFO "%s hash table entries: %ld (order: %d, %lu bytes)\n", pr_info("%s hash table entries: %ld (order: %d, %lu bytes)\n",
tablename, tablename, 1UL << log2qty, ilog2(size) - PAGE_SHIFT, size);
(1UL << log2qty),
ilog2(size) - PAGE_SHIFT,
size);
if (_hash_shift) if (_hash_shift)
*_hash_shift = log2qty; *_hash_shift = log2qty;
@ -7191,8 +7185,8 @@ __offline_isolated_pages(unsigned long start_pfn, unsigned long end_pfn)
BUG_ON(!PageBuddy(page)); BUG_ON(!PageBuddy(page));
order = page_order(page); order = page_order(page);
#ifdef CONFIG_DEBUG_VM #ifdef CONFIG_DEBUG_VM
printk(KERN_INFO "remove from free list %lx %d %lx\n", pr_info("remove from free list %lx %d %lx\n",
pfn, 1 << order, end_pfn); pfn, 1 << order, end_pfn);
#endif #endif
list_del(&page->lru); list_del(&page->lru);
rmv_page_order(page); rmv_page_order(page);

22
mm/page_io.c
View file

@ -56,10 +56,10 @@ void end_swap_bio_write(struct bio *bio)
* Also clear PG_reclaim to avoid rotate_reclaimable_page() * Also clear PG_reclaim to avoid rotate_reclaimable_page()
*/ */
set_page_dirty(page); set_page_dirty(page);
printk(KERN_ALERT "Write-error on swap-device (%u:%u:%Lu)\n", pr_alert("Write-error on swap-device (%u:%u:%llu)\n",
imajor(bio->bi_bdev->bd_inode), imajor(bio->bi_bdev->bd_inode),
iminor(bio->bi_bdev->bd_inode), iminor(bio->bi_bdev->bd_inode),
(unsigned long long)bio->bi_iter.bi_sector); (unsigned long long)bio->bi_iter.bi_sector);
ClearPageReclaim(page); ClearPageReclaim(page);
} }
end_page_writeback(page); end_page_writeback(page);
@ -73,10 +73,10 @@ static void end_swap_bio_read(struct bio *bio)
if (bio->bi_error) { if (bio->bi_error) {
SetPageError(page); SetPageError(page);
ClearPageUptodate(page); ClearPageUptodate(page);
printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n", pr_alert("Read-error on swap-device (%u:%u:%llu)\n",
imajor(bio->bi_bdev->bd_inode), imajor(bio->bi_bdev->bd_inode),
iminor(bio->bi_bdev->bd_inode), iminor(bio->bi_bdev->bd_inode),
(unsigned long long)bio->bi_iter.bi_sector); (unsigned long long)bio->bi_iter.bi_sector);
goto out; goto out;
} }
@ -216,7 +216,7 @@ reprobe:
out: out:
return ret; return ret;
bad_bmap: bad_bmap:
printk(KERN_ERR "swapon: swapfile has holes\n"); pr_err("swapon: swapfile has holes\n");
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
@ -290,8 +290,8 @@ int __swap_writepage(struct page *page, struct writeback_control *wbc,
*/ */
set_page_dirty(page); set_page_dirty(page);
ClearPageReclaim(page); ClearPageReclaim(page);
pr_err_ratelimited("Write error on dio swapfile (%Lu)\n", pr_err_ratelimited("Write error on dio swapfile (%llu)\n",
page_file_offset(page)); page_file_offset(page));
} }
end_page_writeback(page); end_page_writeback(page);
return ret; return ret;

6
mm/percpu-km.c
View file

@ -95,7 +95,7 @@ static int __init pcpu_verify_alloc_info(const struct pcpu_alloc_info *ai)
/* all units must be in a single group */ /* all units must be in a single group */
if (ai->nr_groups != 1) { if (ai->nr_groups != 1) {
printk(KERN_CRIT "percpu: can't handle more than one groups\n"); pr_crit("percpu: can't handle more than one groups\n");
return -EINVAL; return -EINVAL;
} }
@ -103,8 +103,8 @@ static int __init pcpu_verify_alloc_info(const struct pcpu_alloc_info *ai)
alloc_pages = roundup_pow_of_two(nr_pages); alloc_pages = roundup_pow_of_two(nr_pages);
if (alloc_pages > nr_pages) if (alloc_pages > nr_pages)
printk(KERN_WARNING "percpu: wasting %zu pages per chunk\n", pr_warn("percpu: wasting %zu pages per chunk\n",
alloc_pages - nr_pages); alloc_pages - nr_pages);
return 0; return 0;
} }

12
mm/percpu.c
View file

@ -1449,20 +1449,20 @@ static void pcpu_dump_alloc_info(const char *lvl,
for (alloc_end += gi->nr_units / upa; for (alloc_end += gi->nr_units / upa;
alloc < alloc_end; alloc++) { alloc < alloc_end; alloc++) {
if (!(alloc % apl)) { if (!(alloc % apl)) {
printk(KERN_CONT "\n"); pr_cont("\n");
printk("%spcpu-alloc: ", lvl); printk("%spcpu-alloc: ", lvl);
} }
printk(KERN_CONT "[%0*d] ", group_width, group); pr_cont("[%0*d] ", group_width, group);
for (unit_end += upa; unit < unit_end; unit++) for (unit_end += upa; unit < unit_end; unit++)
if (gi->cpu_map[unit] != NR_CPUS) if (gi->cpu_map[unit] != NR_CPUS)
printk(KERN_CONT "%0*d ", cpu_width, pr_cont("%0*d ",
gi->cpu_map[unit]); cpu_width, gi->cpu_map[unit]);
else else
printk(KERN_CONT "%s ", empty_str); pr_cont("%s ", empty_str);
} }
} }
printk(KERN_CONT "\n"); pr_cont("\n");
} }
/** /**

14
mm/shmem.c
View file

@ -2823,9 +2823,8 @@ static int shmem_parse_options(char *options, struct shmem_sb_info *sbinfo,
if ((value = strchr(this_char,'=')) != NULL) { if ((value = strchr(this_char,'=')) != NULL) {
*value++ = 0; *value++ = 0;
} else { } else {
printk(KERN_ERR pr_err("tmpfs: No value for mount option '%s'\n",
"tmpfs: No value for mount option '%s'\n", this_char);
this_char);
goto error; goto error;
} }
@ -2880,8 +2879,7 @@ static int shmem_parse_options(char *options, struct shmem_sb_info *sbinfo,
if (mpol_parse_str(value, &mpol)) if (mpol_parse_str(value, &mpol))
goto bad_val; goto bad_val;
} else { } else {
printk(KERN_ERR "tmpfs: Bad mount option %s\n", pr_err("tmpfs: Bad mount option %s\n", this_char);
this_char);
goto error; goto error;
} }
} }
@ -2889,7 +2887,7 @@ static int shmem_parse_options(char *options, struct shmem_sb_info *sbinfo,
return 0; return 0;
bad_val: bad_val:
printk(KERN_ERR "tmpfs: Bad value '%s' for mount option '%s'\n", pr_err("tmpfs: Bad value '%s' for mount option '%s'\n",
value, this_char); value, this_char);
error: error:
mpol_put(mpol); mpol_put(mpol);
@ -3286,14 +3284,14 @@ int __init shmem_init(void)
error = register_filesystem(&shmem_fs_type); error = register_filesystem(&shmem_fs_type);
if (error) { if (error) {
printk(KERN_ERR "Could not register tmpfs\n"); pr_err("Could not register tmpfs\n");
goto out2; goto out2;
} }
shm_mnt = kern_mount(&shmem_fs_type); shm_mnt = kern_mount(&shmem_fs_type);
if (IS_ERR(shm_mnt)) { if (IS_ERR(shm_mnt)) {
error = PTR_ERR(shm_mnt); error = PTR_ERR(shm_mnt);
printk(KERN_ERR "Could not kern_mount tmpfs\n"); pr_err("Could not kern_mount tmpfs\n");
goto out1; goto out1;
} }
return 0; return 0;

51
mm/slab.c
View file

@ -474,7 +474,7 @@ static unsigned int cache_estimate(unsigned long gfporder, size_t buffer_size,
static void __slab_error(const char *function, struct kmem_cache *cachep, static void __slab_error(const char *function, struct kmem_cache *cachep,
char *msg) char *msg)
{ {
printk(KERN_ERR "slab error in %s(): cache `%s': %s\n", pr_err("slab error in %s(): cache `%s': %s\n",
function, cachep->name, msg); function, cachep->name, msg);
dump_stack(); dump_stack();
add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE); add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE);
@ -1553,7 +1553,7 @@ static void dump_line(char *data, int offset, int limit)
unsigned char error = 0; unsigned char error = 0;
int bad_count = 0; int bad_count = 0;
printk(KERN_ERR "%03x: ", offset); pr_err("%03x: ", offset);
for (i = 0; i < limit; i++) { for (i = 0; i < limit; i++) {
if (data[offset + i] != POISON_FREE) { if (data[offset + i] != POISON_FREE) {
error = data[offset + i]; error = data[offset + i];
@ -1566,11 +1566,11 @@ static void dump_line(char *data, int offset, int limit)
if (bad_count == 1) { if (bad_count == 1) {
error ^= POISON_FREE; error ^= POISON_FREE;
if (!(error & (error - 1))) { if (!(error & (error - 1))) {
printk(KERN_ERR "Single bit error detected. Probably bad RAM.\n"); pr_err("Single bit error detected. Probably bad RAM.\n");
#ifdef CONFIG_X86 #ifdef CONFIG_X86
printk(KERN_ERR "Run memtest86+ or a similar memory test tool.\n"); pr_err("Run memtest86+ or a similar memory test tool.\n");
#else #else
printk(KERN_ERR "Run a memory test tool.\n"); pr_err("Run a memory test tool.\n");
#endif #endif
} }
} }
@ -1585,13 +1585,13 @@ static void print_objinfo(struct kmem_cache *cachep, void *objp, int lines)
char *realobj; char *realobj;
if (cachep->flags & SLAB_RED_ZONE) { if (cachep->flags & SLAB_RED_ZONE) {
printk(KERN_ERR "Redzone: 0x%llx/0x%llx.\n", pr_err("Redzone: 0x%llx/0x%llx\n",
*dbg_redzone1(cachep, objp), *dbg_redzone1(cachep, objp),
*dbg_redzone2(cachep, objp)); *dbg_redzone2(cachep, objp));
} }
if (cachep->flags & SLAB_STORE_USER) { if (cachep->flags & SLAB_STORE_USER) {
printk(KERN_ERR "Last user: [<%p>](%pSR)\n", pr_err("Last user: [<%p>](%pSR)\n",
*dbg_userword(cachep, objp), *dbg_userword(cachep, objp),
*dbg_userword(cachep, objp)); *dbg_userword(cachep, objp));
} }
@ -1627,9 +1627,9 @@ static void check_poison_obj(struct kmem_cache *cachep, void *objp)
/* Mismatch ! */ /* Mismatch ! */
/* Print header */ /* Print header */
if (lines == 0) { if (lines == 0) {
printk(KERN_ERR pr_err("Slab corruption (%s): %s start=%p, len=%d\n",
"Slab corruption (%s): %s start=%p, len=%d\n", print_tainted(), cachep->name,
print_tainted(), cachep->name, realobj, size); realobj, size);
print_objinfo(cachep, objp, 0); print_objinfo(cachep, objp, 0);
} }
/* Hexdump the affected line */ /* Hexdump the affected line */
@ -1656,15 +1656,13 @@ static void check_poison_obj(struct kmem_cache *cachep, void *objp)
if (objnr) { if (objnr) {
objp = index_to_obj(cachep, page, objnr - 1); objp = index_to_obj(cachep, page, objnr - 1);
realobj = (char *)objp + obj_offset(cachep); realobj = (char *)objp + obj_offset(cachep);
printk(KERN_ERR "Prev obj: start=%p, len=%d\n", pr_err("Prev obj: start=%p, len=%d\n", realobj, size);
realobj, size);
print_objinfo(cachep, objp, 2); print_objinfo(cachep, objp, 2);
} }
if (objnr + 1 < cachep->num) { if (objnr + 1 < cachep->num) {
objp = index_to_obj(cachep, page, objnr + 1); objp = index_to_obj(cachep, page, objnr + 1);
realobj = (char *)objp + obj_offset(cachep); realobj = (char *)objp + obj_offset(cachep);
printk(KERN_ERR "Next obj: start=%p, len=%d\n", pr_err("Next obj: start=%p, len=%d\n", realobj, size);
realobj, size);
print_objinfo(cachep, objp, 2); print_objinfo(cachep, objp, 2);
} }
} }
@ -2463,7 +2461,7 @@ static void slab_put_obj(struct kmem_cache *cachep,
/* Verify double free bug */ /* Verify double free bug */
for (i = page->active; i < cachep->num; i++) { for (i = page->active; i < cachep->num; i++) {
if (get_free_obj(page, i) == objnr) { if (get_free_obj(page, i) == objnr) {
printk(KERN_ERR "slab: double free detected in cache '%s', objp %p\n", pr_err("slab: double free detected in cache '%s', objp %p\n",
cachep->name, objp); cachep->name, objp);
BUG(); BUG();
} }
@ -2583,7 +2581,7 @@ failed:
static void kfree_debugcheck(const void *objp) static void kfree_debugcheck(const void *objp)
{ {
if (!virt_addr_valid(objp)) { if (!virt_addr_valid(objp)) {
printk(KERN_ERR "kfree_debugcheck: out of range ptr %lxh.\n", pr_err("kfree_debugcheck: out of range ptr %lxh\n",
(unsigned long)objp); (unsigned long)objp);
BUG(); BUG();
} }
@ -2607,8 +2605,8 @@ static inline void verify_redzone_free(struct kmem_cache *cache, void *obj)
else else
slab_error(cache, "memory outside object was overwritten"); slab_error(cache, "memory outside object was overwritten");
printk(KERN_ERR "%p: redzone 1:0x%llx, redzone 2:0x%llx.\n", pr_err("%p: redzone 1:0x%llx, redzone 2:0x%llx\n",
obj, redzone1, redzone2); obj, redzone1, redzone2);
} }
static void *cache_free_debugcheck(struct kmem_cache *cachep, void *objp, static void *cache_free_debugcheck(struct kmem_cache *cachep, void *objp,
@ -2896,10 +2894,9 @@ static void *cache_alloc_debugcheck_after(struct kmem_cache *cachep,
if (*dbg_redzone1(cachep, objp) != RED_INACTIVE || if (*dbg_redzone1(cachep, objp) != RED_INACTIVE ||
*dbg_redzone2(cachep, objp) != RED_INACTIVE) { *dbg_redzone2(cachep, objp) != RED_INACTIVE) {
slab_error(cachep, "double free, or memory outside object was overwritten"); slab_error(cachep, "double free, or memory outside object was overwritten");
printk(KERN_ERR pr_err("%p: redzone 1:0x%llx, redzone 2:0x%llx\n",
"%p: redzone 1:0x%llx, redzone 2:0x%llx\n", objp, *dbg_redzone1(cachep, objp),
objp, *dbg_redzone1(cachep, objp), *dbg_redzone2(cachep, objp));
*dbg_redzone2(cachep, objp));
} }
*dbg_redzone1(cachep, objp) = RED_ACTIVE; *dbg_redzone1(cachep, objp) = RED_ACTIVE;
*dbg_redzone2(cachep, objp) = RED_ACTIVE; *dbg_redzone2(cachep, objp) = RED_ACTIVE;
@ -2910,7 +2907,7 @@ static void *cache_alloc_debugcheck_after(struct kmem_cache *cachep,
cachep->ctor(objp); cachep->ctor(objp);
if (ARCH_SLAB_MINALIGN && if (ARCH_SLAB_MINALIGN &&
((unsigned long)objp & (ARCH_SLAB_MINALIGN-1))) { ((unsigned long)objp & (ARCH_SLAB_MINALIGN-1))) {
printk(KERN_ERR "0x%p: not aligned to ARCH_SLAB_MINALIGN=%d\n", pr_err("0x%p: not aligned to ARCH_SLAB_MINALIGN=%d\n",
objp, (int)ARCH_SLAB_MINALIGN); objp, (int)ARCH_SLAB_MINALIGN);
} }
return objp; return objp;
@ -3837,7 +3834,7 @@ static int enable_cpucache(struct kmem_cache *cachep, gfp_t gfp)
skip_setup: skip_setup:
err = do_tune_cpucache(cachep, limit, batchcount, shared, gfp); err = do_tune_cpucache(cachep, limit, batchcount, shared, gfp);
if (err) if (err)
printk(KERN_ERR "enable_cpucache failed for %s, error %d.\n", pr_err("enable_cpucache failed for %s, error %d\n",
cachep->name, -err); cachep->name, -err);
return err; return err;
} }
@ -3993,7 +3990,7 @@ void get_slabinfo(struct kmem_cache *cachep, struct slabinfo *sinfo)
name = cachep->name; name = cachep->name;
if (error) if (error)
printk(KERN_ERR "slab: cache %s error: %s\n", name, error); pr_err("slab: cache %s error: %s\n", name, error);
sinfo->active_objs = active_objs; sinfo->active_objs = active_objs;
sinfo->num_objs = num_objs; sinfo->num_objs = num_objs;

2
mm/slab_common.c
View file

@ -442,7 +442,7 @@ out_unlock:
panic("kmem_cache_create: Failed to create slab '%s'. Error %d\n", panic("kmem_cache_create: Failed to create slab '%s'. Error %d\n",
name, err); name, err);
else { else {
printk(KERN_WARNING "kmem_cache_create(%s) failed with error %d", pr_warn("kmem_cache_create(%s) failed with error %d\n",
name, err); name, err);
dump_stack(); dump_stack();
} }

6
mm/sparse-vmemmap.c
View file

@ -166,8 +166,8 @@ void __meminit vmemmap_verify(pte_t *pte, int node,
int actual_node = early_pfn_to_nid(pfn); int actual_node = early_pfn_to_nid(pfn);
if (node_distance(actual_node, node) > LOCAL_DISTANCE) if (node_distance(actual_node, node) > LOCAL_DISTANCE)
printk(KERN_WARNING "[%lx-%lx] potential offnode page_structs\n", pr_warn("[%lx-%lx] potential offnode page_structs\n",
start, end - 1); start, end - 1);
} }
pte_t * __meminit vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node) pte_t * __meminit vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node)
@ -292,7 +292,7 @@ void __init sparse_mem_maps_populate_node(struct page **map_map,
if (map_map[pnum]) if (map_map[pnum])
continue; continue;
ms = __nr_to_section(pnum); ms = __nr_to_section(pnum);
printk(KERN_ERR "%s: sparsemem memory map backing failed some memory will not be available.\n", pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
__func__); __func__);
ms->section_mem_map = 0; ms->section_mem_map = 0;
} }

17
mm/sparse.c
View file

@ -313,9 +313,8 @@ static void __init check_usemap_section_nr(int nid, unsigned long *usemap)
usemap_nid = sparse_early_nid(__nr_to_section(usemap_snr)); usemap_nid = sparse_early_nid(__nr_to_section(usemap_snr));
if (usemap_nid != nid) { if (usemap_nid != nid) {
printk(KERN_INFO pr_info("node %d must be removed before remove section %ld\n",
"node %d must be removed before remove section %ld\n", nid, usemap_snr);
nid, usemap_snr);
return; return;
} }
/* /*
@ -324,10 +323,8 @@ static void __init check_usemap_section_nr(int nid, unsigned long *usemap)
* gather other removable sections for dynamic partitioning. * gather other removable sections for dynamic partitioning.
* Just notify un-removable section's number here. * Just notify un-removable section's number here.
*/ */
printk(KERN_INFO "Section %ld and %ld (node %d)", usemap_snr, pr_info("Section %ld and %ld (node %d) have a circular dependency on usemap and pgdat allocations\n",
pgdat_snr, nid); usemap_snr, pgdat_snr, nid);
printk(KERN_CONT
" have a circular dependency on usemap and pgdat allocations\n");
} }
#else #else
static unsigned long * __init static unsigned long * __init
@ -355,7 +352,7 @@ static void __init sparse_early_usemaps_alloc_node(void *data,
usemap = sparse_early_usemaps_alloc_pgdat_section(NODE_DATA(nodeid), usemap = sparse_early_usemaps_alloc_pgdat_section(NODE_DATA(nodeid),
size * usemap_count); size * usemap_count);
if (!usemap) { if (!usemap) {
printk(KERN_WARNING "%s: allocation failed\n", __func__); pr_warn("%s: allocation failed\n", __func__);
return; return;
} }
@ -428,7 +425,7 @@ void __init sparse_mem_maps_populate_node(struct page **map_map,
if (map_map[pnum]) if (map_map[pnum])
continue; continue;
ms = __nr_to_section(pnum); ms = __nr_to_section(pnum);
printk(KERN_ERR "%s: sparsemem memory map backing failed some memory will not be available.\n", pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
__func__); __func__);
ms->section_mem_map = 0; ms->section_mem_map = 0;
} }
@ -456,7 +453,7 @@ static struct page __init *sparse_early_mem_map_alloc(unsigned long pnum)
if (map) if (map)
return map; return map;
printk(KERN_ERR "%s: sparsemem memory map backing failed some memory will not be available.\n", pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
__func__); __func__);
ms->section_mem_map = 0; ms->section_mem_map = 0;
return NULL; return NULL;

5
mm/swap_cgroup.c
View file

@ -174,9 +174,8 @@ int swap_cgroup_swapon(int type, unsigned long max_pages)
return 0; return 0;
nomem: nomem:
printk(KERN_INFO "couldn't allocate enough memory for swap_cgroup.\n"); pr_info("couldn't allocate enough memory for swap_cgroup\n");
printk(KERN_INFO pr_info("swap_cgroup can be disabled by swapaccount=0 boot option\n");
"swap_cgroup can be disabled by swapaccount=0 boot option\n");
return -ENOMEM; return -ENOMEM;
} }