aboutsummaryrefslogtreecommitdiffstats
path: root/kernel
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2013-11-13 01:45:43 -0500
committerLinus Torvalds <torvalds@linux-foundation.org>2013-11-13 01:45:43 -0500
commit5cbb3d216e2041700231bcfc383ee5f8b7fc8b74 (patch)
treea738fa82dbcefa9bd283c08bc67f38827be63937 /kernel
parent9bc9ccd7db1c9f043f75380b5a5b94912046a60e (diff)
parent4e9b45a19241354daec281d7a785739829b52359 (diff)
Merge branch 'akpm' (patches from Andrew Morton)
Merge first patch-bomb from Andrew Morton: "Quite a lot of other stuff is banked up awaiting further next->mainline merging, but this batch contains: - Lots of random misc patches - OCFS2 - Most of MM - backlight updates - lib/ updates - printk updates - checkpatch updates - epoll tweaking - rtc updates - hfs - hfsplus - documentation - procfs - update gcov to gcc-4.7 format - IPC" * emailed patches from Andrew Morton <akpm@linux-foundation.org>: (269 commits) ipc, msg: fix message length check for negative values ipc/util.c: remove unnecessary work pending test devpts: plug the memory leak in kill_sb ./Makefile: export initial ramdisk compression config option init/Kconfig: add option to disable kernel compression drivers: w1: make w1_slave::flags long to avoid memory corruption drivers/w1/masters/ds1wm.cuse dev_get_platdata() drivers/memstick/core/ms_block.c: fix unreachable state in h_msb_read_page() drivers/memstick/core/mspro_block.c: fix attributes array allocation drivers/pps/clients/pps-gpio.c: remove redundant of_match_ptr kernel/panic.c: reduce 1 byte usage for print tainted buffer gcov: reuse kbasename helper kernel/gcov/fs.c: use pr_warn() kernel/module.c: use pr_foo() gcov: compile specific gcov implementation based on gcc version gcov: add support for gcc 4.7 gcov format gcov: move gcov structs definitions to a gcc version specific file kernel/taskstats.c: return -ENOMEM when alloc memory fails in add_del_listener() kernel/taskstats.c: add nla_nest_cancel() for failure processing between nla_nest_start() and nla_nest_end() kernel/sysctl_binary.c: use scnprintf() instead of snprintf() ...
Diffstat (limited to 'kernel')
-rw-r--r--kernel/cpu.c29
-rw-r--r--kernel/delayacct.c7
-rw-r--r--kernel/events/core.c3
-rw-r--r--kernel/gcov/Kconfig30
-rw-r--r--kernel/gcov/Makefile32
-rw-r--r--kernel/gcov/base.c32
-rw-r--r--kernel/gcov/fs.c52
-rw-r--r--kernel/gcov/gcc_3_4.c115
-rw-r--r--kernel/gcov/gcc_4_7.c560
-rw-r--r--kernel/gcov/gcov.h65
-rw-r--r--kernel/kprobes.c4
-rw-r--r--kernel/kthread.c73
-rw-r--r--kernel/module.c103
-rw-r--r--kernel/panic.c2
-rw-r--r--kernel/printk/printk.c35
-rw-r--r--kernel/ptrace.c3
-rw-r--r--kernel/sys.c1
-rw-r--r--kernel/sysctl.c5
-rw-r--r--kernel/sysctl_binary.c6
-rw-r--r--kernel/taskstats.c16
20 files changed, 934 insertions, 239 deletions
diff --git a/kernel/cpu.c b/kernel/cpu.c
index 63aa50d7ce1e..973d034acf84 100644
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -437,11 +437,6 @@ int cpu_up(unsigned int cpu)
437{ 437{
438 int err = 0; 438 int err = 0;
439 439
440#ifdef CONFIG_MEMORY_HOTPLUG
441 int nid;
442 pg_data_t *pgdat;
443#endif
444
445 if (!cpu_possible(cpu)) { 440 if (!cpu_possible(cpu)) {
446 printk(KERN_ERR "can't online cpu %d because it is not " 441 printk(KERN_ERR "can't online cpu %d because it is not "
447 "configured as may-hotadd at boot time\n", cpu); 442 "configured as may-hotadd at boot time\n", cpu);
@@ -452,27 +447,9 @@ int cpu_up(unsigned int cpu)
452 return -EINVAL; 447 return -EINVAL;
453 } 448 }
454 449
455#ifdef CONFIG_MEMORY_HOTPLUG 450 err = try_online_node(cpu_to_node(cpu));
456 nid = cpu_to_node(cpu); 451 if (err)
457 if (!node_online(nid)) { 452 return err;
458 err = mem_online_node(nid);
459 if (err)
460 return err;
461 }
462
463 pgdat = NODE_DATA(nid);
464 if (!pgdat) {
465 printk(KERN_ERR
466 "Can't online cpu %d due to NULL pgdat\n", cpu);
467 return -ENOMEM;
468 }
469
470 if (pgdat->node_zonelists->_zonerefs->zone == NULL) {
471 mutex_lock(&zonelists_mutex);
472 build_all_zonelists(NULL, NULL);
473 mutex_unlock(&zonelists_mutex);
474 }
475#endif
476 453
477 cpu_maps_update_begin(); 454 cpu_maps_update_begin();
478 455
diff --git a/kernel/delayacct.c b/kernel/delayacct.c
index d473988c1d0b..54996b71e66d 100644
--- a/kernel/delayacct.c
+++ b/kernel/delayacct.c
@@ -108,12 +108,6 @@ int __delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk)
108 struct timespec ts; 108 struct timespec ts;
109 cputime_t utime, stime, stimescaled, utimescaled; 109 cputime_t utime, stime, stimescaled, utimescaled;
110 110
111 /* Though tsk->delays accessed later, early exit avoids
112 * unnecessary returning of other data
113 */
114 if (!tsk->delays)
115 goto done;
116
117 tmp = (s64)d->cpu_run_real_total; 111 tmp = (s64)d->cpu_run_real_total;
118 task_cputime(tsk, &utime, &stime); 112 task_cputime(tsk, &utime, &stime);
119 cputime_to_timespec(utime + stime, &ts); 113 cputime_to_timespec(utime + stime, &ts);
@@ -158,7 +152,6 @@ int __delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk)
158 d->freepages_count += tsk->delays->freepages_count; 152 d->freepages_count += tsk->delays->freepages_count;
159 spin_unlock_irqrestore(&tsk->delays->lock, flags); 153 spin_unlock_irqrestore(&tsk->delays->lock, flags);
160 154
161done:
162 return 0; 155 return 0;
163} 156}
164 157
diff --git a/kernel/events/core.c b/kernel/events/core.c
index 8c875ef6e120..d724e7757cd1 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -2234,9 +2234,6 @@ static void __perf_event_sync_stat(struct perf_event *event,
2234 perf_event_update_userpage(next_event); 2234 perf_event_update_userpage(next_event);
2235} 2235}
2236 2236
2237#define list_next_entry(pos, member) \
2238 list_entry(pos->member.next, typeof(*pos), member)
2239
2240static void perf_event_sync_stat(struct perf_event_context *ctx, 2237static void perf_event_sync_stat(struct perf_event_context *ctx,
2241 struct perf_event_context *next_ctx) 2238 struct perf_event_context *next_ctx)
2242{ 2239{
diff --git a/kernel/gcov/Kconfig b/kernel/gcov/Kconfig
index d4da55d1fb65..d04ce8ac4399 100644
--- a/kernel/gcov/Kconfig
+++ b/kernel/gcov/Kconfig
@@ -46,4 +46,34 @@ config GCOV_PROFILE_ALL
46 larger and run slower. Also be sure to exclude files from profiling 46 larger and run slower. Also be sure to exclude files from profiling
47 which are not linked to the kernel image to prevent linker errors. 47 which are not linked to the kernel image to prevent linker errors.
48 48
49choice
50 prompt "Specify GCOV format"
51 depends on GCOV_KERNEL
52 default GCOV_FORMAT_AUTODETECT
53 ---help---
54 The gcov format is usually determined by the GCC version, but there are
55 exceptions where format changes are integrated in lower-version GCCs.
56 In such a case use this option to adjust the format used in the kernel
57 accordingly.
58
59 If unsure, choose "Autodetect".
60
61config GCOV_FORMAT_AUTODETECT
62 bool "Autodetect"
63 ---help---
64 Select this option to use the format that corresponds to your GCC
65 version.
66
67config GCOV_FORMAT_3_4
68 bool "GCC 3.4 format"
69 ---help---
70 Select this option to use the format defined by GCC 3.4.
71
72config GCOV_FORMAT_4_7
73 bool "GCC 4.7 format"
74 ---help---
75 Select this option to use the format defined by GCC 4.7.
76
77endchoice
78
49endmenu 79endmenu
diff --git a/kernel/gcov/Makefile b/kernel/gcov/Makefile
index e97ca59e2520..52aa7e8de927 100644
--- a/kernel/gcov/Makefile
+++ b/kernel/gcov/Makefile
@@ -1,3 +1,33 @@
1ccflags-y := -DSRCTREE='"$(srctree)"' -DOBJTREE='"$(objtree)"' 1ccflags-y := -DSRCTREE='"$(srctree)"' -DOBJTREE='"$(objtree)"'
2 2
3obj-$(CONFIG_GCOV_KERNEL) := base.o fs.o gcc_3_4.o 3# if-lt
4# Usage VAR := $(call if-lt, $(a), $(b))
5# Returns 1 if (a < b)
6if-lt = $(shell [ $(1) -lt $(2) ] && echo 1)
7
8ifeq ($(CONFIG_GCOV_FORMAT_3_4),y)
9 cc-ver := 0304
10else ifeq ($(CONFIG_GCOV_FORMAT_4_7),y)
11 cc-ver := 0407
12else
13# Use cc-version if available, otherwise set 0
14#
15# scripts/Kbuild.include, which contains cc-version function, is not included
16# during make clean "make -f scripts/Makefile.clean obj=kernel/gcov"
17# Meaning cc-ver is empty causing if-lt test to fail with
18# "/bin/sh: line 0: [: -lt: unary operator expected" error mesage.
19# This has no affect on the clean phase, but the error message could be
20# confusing/annoying. So this dummy workaround sets cc-ver to zero if cc-version
21# is not available. We can probably move if-lt to Kbuild.include, so it's also
22# not defined during clean or to include Kbuild.include in
23# scripts/Makefile.clean. But the following workaround seems least invasive.
24 cc-ver := $(if $(call cc-version),$(call cc-version),0)
25endif
26
27obj-$(CONFIG_GCOV_KERNEL) := base.o fs.o
28
29ifeq ($(call if-lt, $(cc-ver), 0407),1)
30 obj-$(CONFIG_GCOV_KERNEL) += gcc_3_4.o
31else
32 obj-$(CONFIG_GCOV_KERNEL) += gcc_4_7.o
33endif
diff --git a/kernel/gcov/base.c b/kernel/gcov/base.c
index 9b22d03cc581..f45b75b713c0 100644
--- a/kernel/gcov/base.c
+++ b/kernel/gcov/base.c
@@ -20,7 +20,6 @@
20#include <linux/mutex.h> 20#include <linux/mutex.h>
21#include "gcov.h" 21#include "gcov.h"
22 22
23static struct gcov_info *gcov_info_head;
24static int gcov_events_enabled; 23static int gcov_events_enabled;
25static DEFINE_MUTEX(gcov_lock); 24static DEFINE_MUTEX(gcov_lock);
26 25
@@ -34,7 +33,7 @@ void __gcov_init(struct gcov_info *info)
34 33
35 mutex_lock(&gcov_lock); 34 mutex_lock(&gcov_lock);
36 if (gcov_version == 0) { 35 if (gcov_version == 0) {
37 gcov_version = info->version; 36 gcov_version = gcov_info_version(info);
38 /* 37 /*
39 * Printing gcc's version magic may prove useful for debugging 38 * Printing gcc's version magic may prove useful for debugging
40 * incompatibility reports. 39 * incompatibility reports.
@@ -45,8 +44,7 @@ void __gcov_init(struct gcov_info *info)
45 * Add new profiling data structure to list and inform event 44 * Add new profiling data structure to list and inform event
46 * listener. 45 * listener.
47 */ 46 */
48 info->next = gcov_info_head; 47 gcov_info_link(info);
49 gcov_info_head = info;
50 if (gcov_events_enabled) 48 if (gcov_events_enabled)
51 gcov_event(GCOV_ADD, info); 49 gcov_event(GCOV_ADD, info);
52 mutex_unlock(&gcov_lock); 50 mutex_unlock(&gcov_lock);
@@ -81,6 +79,12 @@ void __gcov_merge_delta(gcov_type *counters, unsigned int n_counters)
81} 79}
82EXPORT_SYMBOL(__gcov_merge_delta); 80EXPORT_SYMBOL(__gcov_merge_delta);
83 81
82void __gcov_merge_ior(gcov_type *counters, unsigned int n_counters)
83{
84 /* Unused. */
85}
86EXPORT_SYMBOL(__gcov_merge_ior);
87
84/** 88/**
85 * gcov_enable_events - enable event reporting through gcov_event() 89 * gcov_enable_events - enable event reporting through gcov_event()
86 * 90 *
@@ -91,13 +95,15 @@ EXPORT_SYMBOL(__gcov_merge_delta);
91 */ 95 */
92void gcov_enable_events(void) 96void gcov_enable_events(void)
93{ 97{
94 struct gcov_info *info; 98 struct gcov_info *info = NULL;
95 99
96 mutex_lock(&gcov_lock); 100 mutex_lock(&gcov_lock);
97 gcov_events_enabled = 1; 101 gcov_events_enabled = 1;
102
98 /* Perform event callback for previously registered entries. */ 103 /* Perform event callback for previously registered entries. */
99 for (info = gcov_info_head; info; info = info->next) 104 while ((info = gcov_info_next(info)))
100 gcov_event(GCOV_ADD, info); 105 gcov_event(GCOV_ADD, info);
106
101 mutex_unlock(&gcov_lock); 107 mutex_unlock(&gcov_lock);
102} 108}
103 109
@@ -112,25 +118,23 @@ static int gcov_module_notifier(struct notifier_block *nb, unsigned long event,
112 void *data) 118 void *data)
113{ 119{
114 struct module *mod = data; 120 struct module *mod = data;
115 struct gcov_info *info; 121 struct gcov_info *info = NULL;
116 struct gcov_info *prev; 122 struct gcov_info *prev = NULL;
117 123
118 if (event != MODULE_STATE_GOING) 124 if (event != MODULE_STATE_GOING)
119 return NOTIFY_OK; 125 return NOTIFY_OK;
120 mutex_lock(&gcov_lock); 126 mutex_lock(&gcov_lock);
121 prev = NULL; 127
122 /* Remove entries located in module from linked list. */ 128 /* Remove entries located in module from linked list. */
123 for (info = gcov_info_head; info; info = info->next) { 129 while ((info = gcov_info_next(info))) {
124 if (within(info, mod->module_core, mod->core_size)) { 130 if (within(info, mod->module_core, mod->core_size)) {
125 if (prev) 131 gcov_info_unlink(prev, info);
126 prev->next = info->next;
127 else
128 gcov_info_head = info->next;
129 if (gcov_events_enabled) 132 if (gcov_events_enabled)
130 gcov_event(GCOV_REMOVE, info); 133 gcov_event(GCOV_REMOVE, info);
131 } else 134 } else
132 prev = info; 135 prev = info;
133 } 136 }
137
134 mutex_unlock(&gcov_lock); 138 mutex_unlock(&gcov_lock);
135 139
136 return NOTIFY_OK; 140 return NOTIFY_OK;
diff --git a/kernel/gcov/fs.c b/kernel/gcov/fs.c
index 7a7d2ee96d42..15ff01a76379 100644
--- a/kernel/gcov/fs.c
+++ b/kernel/gcov/fs.c
@@ -75,7 +75,7 @@ static int __init gcov_persist_setup(char *str)
75 unsigned long val; 75 unsigned long val;
76 76
77 if (kstrtoul(str, 0, &val)) { 77 if (kstrtoul(str, 0, &val)) {
78 pr_warning("invalid gcov_persist parameter '%s'\n", str); 78 pr_warn("invalid gcov_persist parameter '%s'\n", str);
79 return 0; 79 return 0;
80 } 80 }
81 gcov_persist = val; 81 gcov_persist = val;
@@ -242,7 +242,7 @@ static struct gcov_node *get_node_by_name(const char *name)
242 242
243 list_for_each_entry(node, &all_head, all) { 243 list_for_each_entry(node, &all_head, all) {
244 info = get_node_info(node); 244 info = get_node_info(node);
245 if (info && (strcmp(info->filename, name) == 0)) 245 if (info && (strcmp(gcov_info_filename(info), name) == 0))
246 return node; 246 return node;
247 } 247 }
248 248
@@ -279,7 +279,7 @@ static ssize_t gcov_seq_write(struct file *file, const char __user *addr,
279 seq = file->private_data; 279 seq = file->private_data;
280 info = gcov_iter_get_info(seq->private); 280 info = gcov_iter_get_info(seq->private);
281 mutex_lock(&node_lock); 281 mutex_lock(&node_lock);
282 node = get_node_by_name(info->filename); 282 node = get_node_by_name(gcov_info_filename(info));
283 if (node) { 283 if (node) {
284 /* Reset counts or remove node for unloaded modules. */ 284 /* Reset counts or remove node for unloaded modules. */
285 if (node->num_loaded == 0) 285 if (node->num_loaded == 0)
@@ -365,7 +365,7 @@ static const char *deskew(const char *basename)
365 */ 365 */
366static void add_links(struct gcov_node *node, struct dentry *parent) 366static void add_links(struct gcov_node *node, struct dentry *parent)
367{ 367{
368 char *basename; 368 const char *basename;
369 char *target; 369 char *target;
370 int num; 370 int num;
371 int i; 371 int i;
@@ -376,14 +376,14 @@ static void add_links(struct gcov_node *node, struct dentry *parent)
376 if (!node->links) 376 if (!node->links)
377 return; 377 return;
378 for (i = 0; i < num; i++) { 378 for (i = 0; i < num; i++) {
379 target = get_link_target(get_node_info(node)->filename, 379 target = get_link_target(
380 &gcov_link[i]); 380 gcov_info_filename(get_node_info(node)),
381 &gcov_link[i]);
381 if (!target) 382 if (!target)
382 goto out_err; 383 goto out_err;
383 basename = strrchr(target, '/'); 384 basename = kbasename(target);
384 if (!basename) 385 if (basename == target)
385 goto out_err; 386 goto out_err;
386 basename++;
387 node->links[i] = debugfs_create_symlink(deskew(basename), 387 node->links[i] = debugfs_create_symlink(deskew(basename),
388 parent, target); 388 parent, target);
389 if (!node->links[i]) 389 if (!node->links[i])
@@ -450,7 +450,7 @@ static struct gcov_node *new_node(struct gcov_node *parent,
450 } else 450 } else
451 node->dentry = debugfs_create_dir(node->name, parent->dentry); 451 node->dentry = debugfs_create_dir(node->name, parent->dentry);
452 if (!node->dentry) { 452 if (!node->dentry) {
453 pr_warning("could not create file\n"); 453 pr_warn("could not create file\n");
454 kfree(node); 454 kfree(node);
455 return NULL; 455 return NULL;
456 } 456 }
@@ -463,7 +463,7 @@ static struct gcov_node *new_node(struct gcov_node *parent,
463 463
464err_nomem: 464err_nomem:
465 kfree(node); 465 kfree(node);
466 pr_warning("out of memory\n"); 466 pr_warn("out of memory\n");
467 return NULL; 467 return NULL;
468} 468}
469 469
@@ -576,7 +576,7 @@ static void add_node(struct gcov_info *info)
576 struct gcov_node *parent; 576 struct gcov_node *parent;
577 struct gcov_node *node; 577 struct gcov_node *node;
578 578
579 filename = kstrdup(info->filename, GFP_KERNEL); 579 filename = kstrdup(gcov_info_filename(info), GFP_KERNEL);
580 if (!filename) 580 if (!filename)
581 return; 581 return;
582 parent = &root_node; 582 parent = &root_node;
@@ -630,8 +630,8 @@ static void add_info(struct gcov_node *node, struct gcov_info *info)
630 */ 630 */
631 loaded_info = kcalloc(num + 1, sizeof(struct gcov_info *), GFP_KERNEL); 631 loaded_info = kcalloc(num + 1, sizeof(struct gcov_info *), GFP_KERNEL);
632 if (!loaded_info) { 632 if (!loaded_info) {
633 pr_warning("could not add '%s' (out of memory)\n", 633 pr_warn("could not add '%s' (out of memory)\n",
634 info->filename); 634 gcov_info_filename(info));
635 return; 635 return;
636 } 636 }
637 memcpy(loaded_info, node->loaded_info, 637 memcpy(loaded_info, node->loaded_info,
@@ -644,8 +644,9 @@ static void add_info(struct gcov_node *node, struct gcov_info *info)
644 * data set replaces the copy of the last one. 644 * data set replaces the copy of the last one.
645 */ 645 */
646 if (!gcov_info_is_compatible(node->unloaded_info, info)) { 646 if (!gcov_info_is_compatible(node->unloaded_info, info)) {
647 pr_warning("discarding saved data for %s " 647 pr_warn("discarding saved data for %s "
648 "(incompatible version)\n", info->filename); 648 "(incompatible version)\n",
649 gcov_info_filename(info));
649 gcov_info_free(node->unloaded_info); 650 gcov_info_free(node->unloaded_info);
650 node->unloaded_info = NULL; 651 node->unloaded_info = NULL;
651 } 652 }
@@ -655,8 +656,8 @@ static void add_info(struct gcov_node *node, struct gcov_info *info)
655 * The initial one takes precedence. 656 * The initial one takes precedence.
656 */ 657 */
657 if (!gcov_info_is_compatible(node->loaded_info[0], info)) { 658 if (!gcov_info_is_compatible(node->loaded_info[0], info)) {
658 pr_warning("could not add '%s' (incompatible " 659 pr_warn("could not add '%s' (incompatible "
659 "version)\n", info->filename); 660 "version)\n", gcov_info_filename(info));
660 kfree(loaded_info); 661 kfree(loaded_info);
661 return; 662 return;
662 } 663 }
@@ -691,8 +692,9 @@ static void save_info(struct gcov_node *node, struct gcov_info *info)
691 else { 692 else {
692 node->unloaded_info = gcov_info_dup(info); 693 node->unloaded_info = gcov_info_dup(info);
693 if (!node->unloaded_info) { 694 if (!node->unloaded_info) {
694 pr_warning("could not save data for '%s' " 695 pr_warn("could not save data for '%s' "
695 "(out of memory)\n", info->filename); 696 "(out of memory)\n",
697 gcov_info_filename(info));
696 } 698 }
697 } 699 }
698} 700}
@@ -707,8 +709,8 @@ static void remove_info(struct gcov_node *node, struct gcov_info *info)
707 709
708 i = get_info_index(node, info); 710 i = get_info_index(node, info);
709 if (i < 0) { 711 if (i < 0) {
710 pr_warning("could not remove '%s' (not found)\n", 712 pr_warn("could not remove '%s' (not found)\n",
711 info->filename); 713 gcov_info_filename(info));
712 return; 714 return;
713 } 715 }
714 if (gcov_persist) 716 if (gcov_persist)
@@ -735,7 +737,7 @@ void gcov_event(enum gcov_action action, struct gcov_info *info)
735 struct gcov_node *node; 737 struct gcov_node *node;
736 738
737 mutex_lock(&node_lock); 739 mutex_lock(&node_lock);
738 node = get_node_by_name(info->filename); 740 node = get_node_by_name(gcov_info_filename(info));
739 switch (action) { 741 switch (action) {
740 case GCOV_ADD: 742 case GCOV_ADD:
741 if (node) 743 if (node)
@@ -747,8 +749,8 @@ void gcov_event(enum gcov_action action, struct gcov_info *info)
747 if (node) 749 if (node)
748 remove_info(node, info); 750 remove_info(node, info);
749 else { 751 else {
750 pr_warning("could not remove '%s' (not found)\n", 752 pr_warn("could not remove '%s' (not found)\n",
751 info->filename); 753 gcov_info_filename(info));
752 } 754 }
753 break; 755 break;
754 } 756 }
diff --git a/kernel/gcov/gcc_3_4.c b/kernel/gcov/gcc_3_4.c
index ae5bb4260033..27bc88a35013 100644
--- a/kernel/gcov/gcc_3_4.c
+++ b/kernel/gcov/gcc_3_4.c
@@ -21,6 +21,121 @@
21#include <linux/vmalloc.h> 21#include <linux/vmalloc.h>
22#include "gcov.h" 22#include "gcov.h"
23 23
24#define GCOV_COUNTERS 5
25
26static struct gcov_info *gcov_info_head;
27
28/**
29 * struct gcov_fn_info - profiling meta data per function
30 * @ident: object file-unique function identifier
31 * @checksum: function checksum
32 * @n_ctrs: number of values per counter type belonging to this function
33 *
34 * This data is generated by gcc during compilation and doesn't change
35 * at run-time.
36 */
37struct gcov_fn_info {
38 unsigned int ident;
39 unsigned int checksum;
40 unsigned int n_ctrs[0];
41};
42
43/**
44 * struct gcov_ctr_info - profiling data per counter type
45 * @num: number of counter values for this type
46 * @values: array of counter values for this type
47 * @merge: merge function for counter values of this type (unused)
48 *
49 * This data is generated by gcc during compilation and doesn't change
50 * at run-time with the exception of the values array.
51 */
52struct gcov_ctr_info {
53 unsigned int num;
54 gcov_type *values;
55 void (*merge)(gcov_type *, unsigned int);
56};
57
58/**
59 * struct gcov_info - profiling data per object file
60 * @version: gcov version magic indicating the gcc version used for compilation
61 * @next: list head for a singly-linked list
62 * @stamp: time stamp
63 * @filename: name of the associated gcov data file
64 * @n_functions: number of instrumented functions
65 * @functions: function data
66 * @ctr_mask: mask specifying which counter types are active
67 * @counts: counter data per counter type
68 *
69 * This data is generated by gcc during compilation and doesn't change
70 * at run-time with the exception of the next pointer.
71 */
72struct gcov_info {
73 unsigned int version;
74 struct gcov_info *next;
75 unsigned int stamp;
76 const char *filename;
77 unsigned int n_functions;
78 const struct gcov_fn_info *functions;
79 unsigned int ctr_mask;
80 struct gcov_ctr_info counts[0];
81};
82
83/**
84 * gcov_info_filename - return info filename
85 * @info: profiling data set
86 */
87const char *gcov_info_filename(struct gcov_info *info)
88{
89 return info->filename;
90}
91
92/**
93 * gcov_info_version - return info version
94 * @info: profiling data set
95 */
96unsigned int gcov_info_version(struct gcov_info *info)
97{
98 return info->version;
99}
100
101/**
102 * gcov_info_next - return next profiling data set
103 * @info: profiling data set
104 *
105 * Returns next gcov_info following @info or first gcov_info in the chain if
106 * @info is %NULL.
107 */
108struct gcov_info *gcov_info_next(struct gcov_info *info)
109{
110 if (!info)
111 return gcov_info_head;
112
113 return info->next;
114}
115
116/**
117 * gcov_info_link - link/add profiling data set to the list
118 * @info: profiling data set
119 */
120void gcov_info_link(struct gcov_info *info)
121{
122 info->next = gcov_info_head;
123 gcov_info_head = info;
124}
125
126/**
127 * gcov_info_unlink - unlink/remove profiling data set from the list
128 * @prev: previous profiling data set
129 * @info: profiling data set
130 */
131void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info)
132{
133 if (prev)
134 prev->next = info->next;
135 else
136 gcov_info_head = info->next;
137}
138
24/* Symbolic links to be created for each profiling data file. */ 139/* Symbolic links to be created for each profiling data file. */
25const struct gcov_link gcov_link[] = { 140const struct gcov_link gcov_link[] = {
26 { OBJ_TREE, "gcno" }, /* Link to .gcno file in $(objtree). */ 141 { OBJ_TREE, "gcno" }, /* Link to .gcno file in $(objtree). */
diff --git a/kernel/gcov/gcc_4_7.c b/kernel/gcov/gcc_4_7.c
new file mode 100644
index 000000000000..2c6e4631c814
--- /dev/null
+++ b/kernel/gcov/gcc_4_7.c
@@ -0,0 +1,560 @@
1/*
2 * This code provides functions to handle gcc's profiling data format
3 * introduced with gcc 4.7.
4 *
5 * This file is based heavily on gcc_3_4.c file.
6 *
7 * For a better understanding, refer to gcc source:
8 * gcc/gcov-io.h
9 * libgcc/libgcov.c
10 *
11 * Uses gcc-internal data definitions.
12 */
13
14#include <linux/errno.h>
15#include <linux/slab.h>
16#include <linux/string.h>
17#include <linux/seq_file.h>
18#include <linux/vmalloc.h>
19#include "gcov.h"
20
21#define GCOV_COUNTERS 8
22#define GCOV_TAG_FUNCTION_LENGTH 3
23
24static struct gcov_info *gcov_info_head;
25
26/**
27 * struct gcov_ctr_info - information about counters for a single function
28 * @num: number of counter values for this type
29 * @values: array of counter values for this type
30 *
31 * This data is generated by gcc during compilation and doesn't change
32 * at run-time with the exception of the values array.
33 */
34struct gcov_ctr_info {
35 unsigned int num;
36 gcov_type *values;
37};
38
39/**
40 * struct gcov_fn_info - profiling meta data per function
41 * @key: comdat key
42 * @ident: unique ident of function
43 * @lineno_checksum: function lineo_checksum
44 * @cfg_checksum: function cfg checksum
45 * @ctrs: instrumented counters
46 *
47 * This data is generated by gcc during compilation and doesn't change
48 * at run-time.
49 *
50 * Information about a single function. This uses the trailing array
51 * idiom. The number of counters is determined from the merge pointer
52 * array in gcov_info. The key is used to detect which of a set of
53 * comdat functions was selected -- it points to the gcov_info object
54 * of the object file containing the selected comdat function.
55 */
56struct gcov_fn_info {
57 const struct gcov_info *key;
58 unsigned int ident;
59 unsigned int lineno_checksum;
60 unsigned int cfg_checksum;
61 struct gcov_ctr_info ctrs[0];
62};
63
64/**
65 * struct gcov_info - profiling data per object file
66 * @version: gcov version magic indicating the gcc version used for compilation
67 * @next: list head for a singly-linked list
68 * @stamp: uniquifying time stamp
69 * @filename: name of the associated gcov data file
70 * @merge: merge functions (null for unused counter type)
71 * @n_functions: number of instrumented functions
72 * @functions: pointer to pointers to function information
73 *
74 * This data is generated by gcc during compilation and doesn't change
75 * at run-time with the exception of the next pointer.
76 */
77struct gcov_info {
78 unsigned int version;
79 struct gcov_info *next;
80 unsigned int stamp;
81 const char *filename;
82 void (*merge[GCOV_COUNTERS])(gcov_type *, unsigned int);
83 unsigned int n_functions;
84 struct gcov_fn_info **functions;
85};
86
87/**
88 * gcov_info_filename - return info filename
89 * @info: profiling data set
90 */
91const char *gcov_info_filename(struct gcov_info *info)
92{
93 return info->filename;
94}
95
96/**
97 * gcov_info_version - return info version
98 * @info: profiling data set
99 */
100unsigned int gcov_info_version(struct gcov_info *info)
101{
102 return info->version;
103}
104
105/**
106 * gcov_info_next - return next profiling data set
107 * @info: profiling data set
108 *
109 * Returns next gcov_info following @info or first gcov_info in the chain if
110 * @info is %NULL.
111 */
112struct gcov_info *gcov_info_next(struct gcov_info *info)
113{
114 if (!info)
115 return gcov_info_head;
116
117 return info->next;
118}
119
120/**
121 * gcov_info_link - link/add profiling data set to the list
122 * @info: profiling data set
123 */
124void gcov_info_link(struct gcov_info *info)
125{
126 info->next = gcov_info_head;
127 gcov_info_head = info;
128}
129
130/**
131 * gcov_info_unlink - unlink/remove profiling data set from the list
132 * @prev: previous profiling data set
133 * @info: profiling data set
134 */
135void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info)
136{
137 if (prev)
138 prev->next = info->next;
139 else
140 gcov_info_head = info->next;
141}
142
143/* Symbolic links to be created for each profiling data file. */
144const struct gcov_link gcov_link[] = {
145 { OBJ_TREE, "gcno" }, /* Link to .gcno file in $(objtree). */
146 { 0, NULL},
147};
148
149/*
150 * Determine whether a counter is active. Doesn't change at run-time.
151 */
152static int counter_active(struct gcov_info *info, unsigned int type)
153{
154 return info->merge[type] ? 1 : 0;
155}
156
157/* Determine number of active counters. Based on gcc magic. */
158static unsigned int num_counter_active(struct gcov_info *info)
159{
160 unsigned int i;
161 unsigned int result = 0;
162
163 for (i = 0; i < GCOV_COUNTERS; i++) {
164 if (counter_active(info, i))
165 result++;
166 }
167 return result;
168}
169
170/**
171 * gcov_info_reset - reset profiling data to zero
172 * @info: profiling data set
173 */
174void gcov_info_reset(struct gcov_info *info)
175{
176 struct gcov_ctr_info *ci_ptr;
177 unsigned int fi_idx;
178 unsigned int ct_idx;
179
180 for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
181 ci_ptr = info->functions[fi_idx]->ctrs;
182
183 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
184 if (!counter_active(info, ct_idx))
185 continue;
186
187 memset(ci_ptr->values, 0,
188 sizeof(gcov_type) * ci_ptr->num);
189 ci_ptr++;
190 }
191 }
192}
193
194/**
195 * gcov_info_is_compatible - check if profiling data can be added
196 * @info1: first profiling data set
197 * @info2: second profiling data set
198 *
199 * Returns non-zero if profiling data can be added, zero otherwise.
200 */
201int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
202{
203 return (info1->stamp == info2->stamp);
204}
205
206/**
207 * gcov_info_add - add up profiling data
208 * @dest: profiling data set to which data is added
209 * @source: profiling data set which is added
210 *
211 * Adds profiling counts of @source to @dest.
212 */
213void gcov_info_add(struct gcov_info *dst, struct gcov_info *src)
214{
215 struct gcov_ctr_info *dci_ptr;
216 struct gcov_ctr_info *sci_ptr;
217 unsigned int fi_idx;
218 unsigned int ct_idx;
219 unsigned int val_idx;
220
221 for (fi_idx = 0; fi_idx < src->n_functions; fi_idx++) {
222 dci_ptr = dst->functions[fi_idx]->ctrs;
223 sci_ptr = src->functions[fi_idx]->ctrs;
224
225 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
226 if (!counter_active(src, ct_idx))
227 continue;
228
229 for (val_idx = 0; val_idx < sci_ptr->num; val_idx++)
230 dci_ptr->values[val_idx] +=
231 sci_ptr->values[val_idx];
232
233 dci_ptr++;
234 sci_ptr++;
235 }
236 }
237}
238
239/**
240 * gcov_info_dup - duplicate profiling data set
241 * @info: profiling data set to duplicate
242 *
243 * Return newly allocated duplicate on success, %NULL on error.
244 */
245struct gcov_info *gcov_info_dup(struct gcov_info *info)
246{
247 struct gcov_info *dup;
248 struct gcov_ctr_info *dci_ptr; /* dst counter info */
249 struct gcov_ctr_info *sci_ptr; /* src counter info */
250 unsigned int active;
251 unsigned int fi_idx; /* function info idx */
252 unsigned int ct_idx; /* counter type idx */
253 size_t fi_size; /* function info size */
254 size_t cv_size; /* counter values size */
255
256 dup = kmemdup(info, sizeof(*dup), GFP_KERNEL);
257 if (!dup)
258 return NULL;
259
260 dup->next = NULL;
261 dup->filename = NULL;
262 dup->functions = NULL;
263
264 dup->filename = kstrdup(info->filename, GFP_KERNEL);
265 if (!dup->filename)
266 goto err_free;
267
268 dup->functions = kcalloc(info->n_functions,
269 sizeof(struct gcov_fn_info *), GFP_KERNEL);
270 if (!dup->functions)
271 goto err_free;
272
273 active = num_counter_active(info);
274 fi_size = sizeof(struct gcov_fn_info);
275 fi_size += sizeof(struct gcov_ctr_info) * active;
276
277 for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
278 dup->functions[fi_idx] = kzalloc(fi_size, GFP_KERNEL);
279 if (!dup->functions[fi_idx])
280 goto err_free;
281
282 *(dup->functions[fi_idx]) = *(info->functions[fi_idx]);
283
284 sci_ptr = info->functions[fi_idx]->ctrs;
285 dci_ptr = dup->functions[fi_idx]->ctrs;
286
287 for (ct_idx = 0; ct_idx < active; ct_idx++) {
288
289 cv_size = sizeof(gcov_type) * sci_ptr->num;
290
291 dci_ptr->values = vmalloc(cv_size);
292
293 if (!dci_ptr->values)
294 goto err_free;
295
296 dci_ptr->num = sci_ptr->num;
297 memcpy(dci_ptr->values, sci_ptr->values, cv_size);
298
299 sci_ptr++;
300 dci_ptr++;
301 }
302 }
303
304 return dup;
305err_free:
306 gcov_info_free(dup);
307 return NULL;
308}
309
310/**
311 * gcov_info_free - release memory for profiling data set duplicate
312 * @info: profiling data set duplicate to free
313 */
314void gcov_info_free(struct gcov_info *info)
315{
316 unsigned int active;
317 unsigned int fi_idx;
318 unsigned int ct_idx;
319 struct gcov_ctr_info *ci_ptr;
320
321 if (!info->functions)
322 goto free_info;
323
324 active = num_counter_active(info);
325
326 for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
327 if (!info->functions[fi_idx])
328 continue;
329
330 ci_ptr = info->functions[fi_idx]->ctrs;
331
332 for (ct_idx = 0; ct_idx < active; ct_idx++, ci_ptr++)
333 vfree(ci_ptr->values);
334
335 kfree(info->functions[fi_idx]);
336 }
337
338free_info:
339 kfree(info->functions);
340 kfree(info->filename);
341 kfree(info);
342}
343
344#define ITER_STRIDE PAGE_SIZE
345
346/**
347 * struct gcov_iterator - specifies current file position in logical records
348 * @info: associated profiling data
349 * @buffer: buffer containing file data
350 * @size: size of buffer
351 * @pos: current position in file
352 */
353struct gcov_iterator {
354 struct gcov_info *info;
355 void *buffer;
356 size_t size;
357 loff_t pos;
358};
359
360/**
361 * store_gcov_u32 - store 32 bit number in gcov format to buffer
362 * @buffer: target buffer or NULL
363 * @off: offset into the buffer
364 * @v: value to be stored
365 *
366 * Number format defined by gcc: numbers are recorded in the 32 bit
367 * unsigned binary form of the endianness of the machine generating the
368 * file. Returns the number of bytes stored. If @buffer is %NULL, doesn't
369 * store anything.
370 */
371static size_t store_gcov_u32(void *buffer, size_t off, u32 v)
372{
373 u32 *data;
374
375 if (buffer) {
376 data = buffer + off;
377 *data = v;
378 }
379
380 return sizeof(*data);
381}
382
383/**
384 * store_gcov_u64 - store 64 bit number in gcov format to buffer
385 * @buffer: target buffer or NULL
386 * @off: offset into the buffer
387 * @v: value to be stored
388 *
389 * Number format defined by gcc: numbers are recorded in the 32 bit
390 * unsigned binary form of the endianness of the machine generating the
391 * file. 64 bit numbers are stored as two 32 bit numbers, the low part
392 * first. Returns the number of bytes stored. If @buffer is %NULL, doesn't store
393 * anything.
394 */
395static size_t store_gcov_u64(void *buffer, size_t off, u64 v)
396{
397 u32 *data;
398
399 if (buffer) {
400 data = buffer + off;
401
402 data[0] = (v & 0xffffffffUL);
403 data[1] = (v >> 32);
404 }
405
406 return sizeof(*data) * 2;
407}
408
409/**
410 * convert_to_gcda - convert profiling data set to gcda file format
411 * @buffer: the buffer to store file data or %NULL if no data should be stored
412 * @info: profiling data set to be converted
413 *
414 * Returns the number of bytes that were/would have been stored into the buffer.
415 */
416static size_t convert_to_gcda(char *buffer, struct gcov_info *info)
417{
418 struct gcov_fn_info *fi_ptr;
419 struct gcov_ctr_info *ci_ptr;
420 unsigned int fi_idx;
421 unsigned int ct_idx;
422 unsigned int cv_idx;
423 size_t pos = 0;
424
425 /* File header. */
426 pos += store_gcov_u32(buffer, pos, GCOV_DATA_MAGIC);
427 pos += store_gcov_u32(buffer, pos, info->version);
428 pos += store_gcov_u32(buffer, pos, info->stamp);
429
430 for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
431 fi_ptr = info->functions[fi_idx];
432
433 /* Function record. */
434 pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION);
435 pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION_LENGTH);
436 pos += store_gcov_u32(buffer, pos, fi_ptr->ident);
437 pos += store_gcov_u32(buffer, pos, fi_ptr->lineno_checksum);
438 pos += store_gcov_u32(buffer, pos, fi_ptr->cfg_checksum);
439
440 ci_ptr = fi_ptr->ctrs;
441
442 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
443 if (!counter_active(info, ct_idx))
444 continue;
445
446 /* Counter record. */
447 pos += store_gcov_u32(buffer, pos,
448 GCOV_TAG_FOR_COUNTER(ct_idx));
449 pos += store_gcov_u32(buffer, pos, ci_ptr->num * 2);
450
451 for (cv_idx = 0; cv_idx < ci_ptr->num; cv_idx++) {
452 pos += store_gcov_u64(buffer, pos,
453 ci_ptr->values[cv_idx]);
454 }
455
456 ci_ptr++;
457 }
458 }
459
460 return pos;
461}
462
463/**
464 * gcov_iter_new - allocate and initialize profiling data iterator
465 * @info: profiling data set to be iterated
466 *
467 * Return file iterator on success, %NULL otherwise.
468 */
469struct gcov_iterator *gcov_iter_new(struct gcov_info *info)
470{
471 struct gcov_iterator *iter;
472
473 iter = kzalloc(sizeof(struct gcov_iterator), GFP_KERNEL);
474 if (!iter)
475 goto err_free;
476
477 iter->info = info;
478 /* Dry-run to get the actual buffer size. */
479 iter->size = convert_to_gcda(NULL, info);
480 iter->buffer = vmalloc(iter->size);
481 if (!iter->buffer)
482 goto err_free;
483
484 convert_to_gcda(iter->buffer, info);
485
486 return iter;
487
488err_free:
489 kfree(iter);
490 return NULL;
491}
492
493
494/**
495 * gcov_iter_get_info - return profiling data set for given file iterator
496 * @iter: file iterator
497 */
498void gcov_iter_free(struct gcov_iterator *iter)
499{
500 vfree(iter->buffer);
501 kfree(iter);
502}
503
504/**
505 * gcov_iter_get_info - return profiling data set for given file iterator
506 * @iter: file iterator
507 */
508struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)
509{
510 return iter->info;
511}
512
513/**
514 * gcov_iter_start - reset file iterator to starting position
515 * @iter: file iterator
516 */
517void gcov_iter_start(struct gcov_iterator *iter)
518{
519 iter->pos = 0;
520}
521
522/**
523 * gcov_iter_next - advance file iterator to next logical record
524 * @iter: file iterator
525 *
526 * Return zero if new position is valid, non-zero if iterator has reached end.
527 */
528int gcov_iter_next(struct gcov_iterator *iter)
529{
530 if (iter->pos < iter->size)
531 iter->pos += ITER_STRIDE;
532
533 if (iter->pos >= iter->size)
534 return -EINVAL;
535
536 return 0;
537}
538
539/**
540 * gcov_iter_write - write data for current pos to seq_file
541 * @iter: file iterator
542 * @seq: seq_file handle
543 *
544 * Return zero on success, non-zero otherwise.
545 */
546int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)
547{
548 size_t len;
549
550 if (iter->pos >= iter->size)
551 return -EINVAL;
552
553 len = ITER_STRIDE;
554 if (iter->pos + len > iter->size)
555 len = iter->size - iter->pos;
556
557 seq_write(seq, iter->buffer + iter->pos, len);
558
559 return 0;
560}
diff --git a/kernel/gcov/gcov.h b/kernel/gcov/gcov.h
index 060073ebf7a6..92c8e22a29ed 100644
--- a/kernel/gcov/gcov.h
+++ b/kernel/gcov/gcov.h
@@ -21,7 +21,6 @@
21 * gcc and need to be kept as close to the original definition as possible to 21 * gcc and need to be kept as close to the original definition as possible to
22 * remain compatible. 22 * remain compatible.
23 */ 23 */
24#define GCOV_COUNTERS 5
25#define GCOV_DATA_MAGIC ((unsigned int) 0x67636461) 24#define GCOV_DATA_MAGIC ((unsigned int) 0x67636461)
26#define GCOV_TAG_FUNCTION ((unsigned int) 0x01000000) 25#define GCOV_TAG_FUNCTION ((unsigned int) 0x01000000)
27#define GCOV_TAG_COUNTER_BASE ((unsigned int) 0x01a10000) 26#define GCOV_TAG_COUNTER_BASE ((unsigned int) 0x01a10000)
@@ -34,60 +33,18 @@ typedef long gcov_type;
34typedef long long gcov_type; 33typedef long long gcov_type;
35#endif 34#endif
36 35
37/** 36/* Opaque gcov_info. The gcov structures can change as for example in gcc 4.7 so
38 * struct gcov_fn_info - profiling meta data per function 37 * we cannot use full definition here and they need to be placed in gcc specific
39 * @ident: object file-unique function identifier 38 * implementation of gcov. This also means no direct access to the members in
40 * @checksum: function checksum 39 * generic code and usage of the interface below.*/
41 * @n_ctrs: number of values per counter type belonging to this function 40struct gcov_info;
42 *
43 * This data is generated by gcc during compilation and doesn't change
44 * at run-time.
45 */
46struct gcov_fn_info {
47 unsigned int ident;
48 unsigned int checksum;
49 unsigned int n_ctrs[0];
50};
51
52/**
53 * struct gcov_ctr_info - profiling data per counter type
54 * @num: number of counter values for this type
55 * @values: array of counter values for this type
56 * @merge: merge function for counter values of this type (unused)
57 *
58 * This data is generated by gcc during compilation and doesn't change
59 * at run-time with the exception of the values array.
60 */
61struct gcov_ctr_info {
62 unsigned int num;
63 gcov_type *values;
64 void (*merge)(gcov_type *, unsigned int);
65};
66 41
67/** 42/* Interface to access gcov_info data */
68 * struct gcov_info - profiling data per object file 43const char *gcov_info_filename(struct gcov_info *info);
69 * @version: gcov version magic indicating the gcc version used for compilation 44unsigned int gcov_info_version(struct gcov_info *info);
70 * @next: list head for a singly-linked list 45struct gcov_info *gcov_info_next(struct gcov_info *info);
71 * @stamp: time stamp 46void gcov_info_link(struct gcov_info *info);
72 * @filename: name of the associated gcov data file 47void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info);
73 * @n_functions: number of instrumented functions
74 * @functions: function data
75 * @ctr_mask: mask specifying which counter types are active
76 * @counts: counter data per counter type
77 *
78 * This data is generated by gcc during compilation and doesn't change
79 * at run-time with the exception of the next pointer.
80 */
81struct gcov_info {
82 unsigned int version;
83 struct gcov_info *next;
84 unsigned int stamp;
85 const char *filename;
86 unsigned int n_functions;
87 const struct gcov_fn_info *functions;
88 unsigned int ctr_mask;
89 struct gcov_ctr_info counts[0];
90};
91 48
92/* Base interface. */ 49/* Base interface. */
93enum gcov_action { 50enum gcov_action {
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index a0d367a49122..ceeadfcabb76 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -2066,7 +2066,7 @@ static int __init init_kprobes(void)
2066{ 2066{
2067 int i, err = 0; 2067 int i, err = 0;
2068 unsigned long offset = 0, size = 0; 2068 unsigned long offset = 0, size = 0;
2069 char *modname, namebuf[128]; 2069 char *modname, namebuf[KSYM_NAME_LEN];
2070 const char *symbol_name; 2070 const char *symbol_name;
2071 void *addr; 2071 void *addr;
2072 struct kprobe_blackpoint *kb; 2072 struct kprobe_blackpoint *kb;
@@ -2192,7 +2192,7 @@ static int __kprobes show_kprobe_addr(struct seq_file *pi, void *v)
2192 const char *sym = NULL; 2192 const char *sym = NULL;
2193 unsigned int i = *(loff_t *) v; 2193 unsigned int i = *(loff_t *) v;
2194 unsigned long offset = 0; 2194 unsigned long offset = 0;
2195 char *modname, namebuf[128]; 2195 char *modname, namebuf[KSYM_NAME_LEN];
2196 2196
2197 head = &kprobe_table[i]; 2197 head = &kprobe_table[i];
2198 preempt_disable(); 2198 preempt_disable();
diff --git a/kernel/kthread.c b/kernel/kthread.c
index 760e86df8c20..b5ae3ee860a9 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -33,7 +33,7 @@ struct kthread_create_info
33 33
34 /* Result passed back to kthread_create() from kthreadd. */ 34 /* Result passed back to kthread_create() from kthreadd. */
35 struct task_struct *result; 35 struct task_struct *result;
36 struct completion done; 36 struct completion *done;
37 37
38 struct list_head list; 38 struct list_head list;
39}; 39};
@@ -178,6 +178,7 @@ static int kthread(void *_create)
178 struct kthread_create_info *create = _create; 178 struct kthread_create_info *create = _create;
179 int (*threadfn)(void *data) = create->threadfn; 179 int (*threadfn)(void *data) = create->threadfn;
180 void *data = create->data; 180 void *data = create->data;
181 struct completion *done;
181 struct kthread self; 182 struct kthread self;
182 int ret; 183 int ret;
183 184
@@ -187,10 +188,16 @@ static int kthread(void *_create)
187 init_completion(&self.parked); 188 init_completion(&self.parked);
188 current->vfork_done = &self.exited; 189 current->vfork_done = &self.exited;
189 190
191 /* If user was SIGKILLed, I release the structure. */
192 done = xchg(&create->done, NULL);
193 if (!done) {
194 kfree(create);
195 do_exit(-EINTR);
196 }
190 /* OK, tell user we're spawned, wait for stop or wakeup */ 197 /* OK, tell user we're spawned, wait for stop or wakeup */
191 __set_current_state(TASK_UNINTERRUPTIBLE); 198 __set_current_state(TASK_UNINTERRUPTIBLE);
192 create->result = current; 199 create->result = current;
193 complete(&create->done); 200 complete(done);
194 schedule(); 201 schedule();
195 202
196 ret = -EINTR; 203 ret = -EINTR;
@@ -223,8 +230,15 @@ static void create_kthread(struct kthread_create_info *create)
223 /* We want our own signal handler (we take no signals by default). */ 230 /* We want our own signal handler (we take no signals by default). */
224 pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD); 231 pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
225 if (pid < 0) { 232 if (pid < 0) {
233 /* If user was SIGKILLed, I release the structure. */
234 struct completion *done = xchg(&create->done, NULL);
235
236 if (!done) {
237 kfree(create);
238 return;
239 }
226 create->result = ERR_PTR(pid); 240 create->result = ERR_PTR(pid);
227 complete(&create->done); 241 complete(done);
228 } 242 }
229} 243}
230 244
@@ -255,36 +269,59 @@ struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
255 const char namefmt[], 269 const char namefmt[],
256 ...) 270 ...)
257{ 271{
258 struct kthread_create_info create; 272 DECLARE_COMPLETION_ONSTACK(done);
259 273 struct task_struct *task;
260 create.threadfn = threadfn; 274 struct kthread_create_info *create = kmalloc(sizeof(*create),
261 create.data = data; 275 GFP_KERNEL);
262 create.node = node; 276
263 init_completion(&create.done); 277 if (!create)
278 return ERR_PTR(-ENOMEM);
279 create->threadfn = threadfn;
280 create->data = data;
281 create->node = node;
282 create->done = &done;
264 283
265 spin_lock(&kthread_create_lock); 284 spin_lock(&kthread_create_lock);
266 list_add_tail(&create.list, &kthread_create_list); 285 list_add_tail(&create->list, &kthread_create_list);
267 spin_unlock(&kthread_create_lock); 286 spin_unlock(&kthread_create_lock);
268 287
269 wake_up_process(kthreadd_task); 288 wake_up_process(kthreadd_task);
270 wait_for_completion(&create.done); 289 /*
271 290 * Wait for completion in killable state, for I might be chosen by
272 if (!IS_ERR(create.result)) { 291 * the OOM killer while kthreadd is trying to allocate memory for
292 * new kernel thread.
293 */
294 if (unlikely(wait_for_completion_killable(&done))) {
295 /*
296 * If I was SIGKILLed before kthreadd (or new kernel thread)
297 * calls complete(), leave the cleanup of this structure to
298 * that thread.
299 */
300 if (xchg(&create->done, NULL))
301 return ERR_PTR(-ENOMEM);
302 /*
303 * kthreadd (or new kernel thread) will call complete()
304 * shortly.
305 */
306 wait_for_completion(&done);
307 }
308 task = create->result;
309 if (!IS_ERR(task)) {
273 static const struct sched_param param = { .sched_priority = 0 }; 310 static const struct sched_param param = { .sched_priority = 0 };
274 va_list args; 311 va_list args;
275 312
276 va_start(args, namefmt); 313 va_start(args, namefmt);
277 vsnprintf(create.result->comm, sizeof(create.result->comm), 314 vsnprintf(task->comm, sizeof(task->comm), namefmt, args);
278 namefmt, args);
279 va_end(args); 315 va_end(args);
280 /* 316 /*
281 * root may have changed our (kthreadd's) priority or CPU mask. 317 * root may have changed our (kthreadd's) priority or CPU mask.
282 * The kernel thread should not inherit these properties. 318 * The kernel thread should not inherit these properties.
283 */ 319 */
284 sched_setscheduler_nocheck(create.result, SCHED_NORMAL, &param); 320 sched_setscheduler_nocheck(task, SCHED_NORMAL, &param);
285 set_cpus_allowed_ptr(create.result, cpu_all_mask); 321 set_cpus_allowed_ptr(task, cpu_all_mask);
286 } 322 }
287 return create.result; 323 kfree(create);
324 return task;
288} 325}
289EXPORT_SYMBOL(kthread_create_on_node); 326EXPORT_SYMBOL(kthread_create_on_node);
290 327
diff --git a/kernel/module.c b/kernel/module.c
index dc582749fa13..af5ebd21d77b 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -378,23 +378,21 @@ static bool check_symbol(const struct symsearch *syms,
378 if (syms->licence == GPL_ONLY) 378 if (syms->licence == GPL_ONLY)
379 return false; 379 return false;
380 if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) { 380 if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {
381 printk(KERN_WARNING "Symbol %s is being used " 381 pr_warn("Symbol %s is being used by a non-GPL module, "
382 "by a non-GPL module, which will not " 382 "which will not be allowed in the future\n",
383 "be allowed in the future\n", fsa->name); 383 fsa->name);
384 } 384 }
385 } 385 }
386 386
387#ifdef CONFIG_UNUSED_SYMBOLS 387#ifdef CONFIG_UNUSED_SYMBOLS
388 if (syms->unused && fsa->warn) { 388 if (syms->unused && fsa->warn) {
389 printk(KERN_WARNING "Symbol %s is marked as UNUSED, " 389 pr_warn("Symbol %s is marked as UNUSED, however this module is "
390 "however this module is using it.\n", fsa->name); 390 "using it.\n", fsa->name);
391 printk(KERN_WARNING 391 pr_warn("This symbol will go away in the future.\n");
392 "This symbol will go away in the future.\n"); 392 pr_warn("Please evalute if this is the right api to use and if "
393 printk(KERN_WARNING 393 "it really is, submit a report the linux kernel "
394 "Please evalute if this is the right api to use and if " 394 "mailinglist together with submitting your code for "
395 "it really is, submit a report the linux kernel " 395 "inclusion.\n");
396 "mailinglist together with submitting your code for "
397 "inclusion.\n");
398 } 396 }
399#endif 397#endif
400 398
@@ -492,16 +490,15 @@ static int percpu_modalloc(struct module *mod, struct load_info *info)
492 return 0; 490 return 0;
493 491
494 if (align > PAGE_SIZE) { 492 if (align > PAGE_SIZE) {
495 printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n", 493 pr_warn("%s: per-cpu alignment %li > %li\n",
496 mod->name, align, PAGE_SIZE); 494 mod->name, align, PAGE_SIZE);
497 align = PAGE_SIZE; 495 align = PAGE_SIZE;
498 } 496 }
499 497
500 mod->percpu = __alloc_reserved_percpu(pcpusec->sh_size, align); 498 mod->percpu = __alloc_reserved_percpu(pcpusec->sh_size, align);
501 if (!mod->percpu) { 499 if (!mod->percpu) {
502 printk(KERN_WARNING 500 pr_warn("%s: Could not allocate %lu bytes percpu data\n",
503 "%s: Could not allocate %lu bytes percpu data\n", 501 mod->name, (unsigned long)pcpusec->sh_size);
504 mod->name, (unsigned long)pcpusec->sh_size);
505 return -ENOMEM; 502 return -ENOMEM;
506 } 503 }
507 mod->percpu_size = pcpusec->sh_size; 504 mod->percpu_size = pcpusec->sh_size;
@@ -679,7 +676,7 @@ static int add_module_usage(struct module *a, struct module *b)
679 pr_debug("Allocating new usage for %s.\n", a->name); 676 pr_debug("Allocating new usage for %s.\n", a->name);
680 use = kmalloc(sizeof(*use), GFP_ATOMIC); 677 use = kmalloc(sizeof(*use), GFP_ATOMIC);
681 if (!use) { 678 if (!use) {
682 printk(KERN_WARNING "%s: out of memory loading\n", a->name); 679 pr_warn("%s: out of memory loading\n", a->name);
683 return -ENOMEM; 680 return -ENOMEM;
684 } 681 }
685 682
@@ -1145,8 +1142,7 @@ static int try_to_force_load(struct module *mod, const char *reason)
1145{ 1142{
1146#ifdef CONFIG_MODULE_FORCE_LOAD 1143#ifdef CONFIG_MODULE_FORCE_LOAD
1147 if (!test_taint(TAINT_FORCED_MODULE)) 1144 if (!test_taint(TAINT_FORCED_MODULE))
1148 printk(KERN_WARNING "%s: %s: kernel tainted.\n", 1145 pr_warn("%s: %s: kernel tainted.\n", mod->name, reason);
1149 mod->name, reason);
1150 add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_NOW_UNRELIABLE); 1146 add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_NOW_UNRELIABLE);
1151 return 0; 1147 return 0;
1152#else 1148#else
@@ -1199,8 +1195,7 @@ static int check_version(Elf_Shdr *sechdrs,
1199 goto bad_version; 1195 goto bad_version;
1200 } 1196 }
1201 1197
1202 printk(KERN_WARNING "%s: no symbol version for %s\n", 1198 pr_warn("%s: no symbol version for %s\n", mod->name, symname);
1203 mod->name, symname);
1204 return 0; 1199 return 0;
1205 1200
1206bad_version: 1201bad_version:
@@ -1309,8 +1304,8 @@ resolve_symbol_wait(struct module *mod,
1309 !IS_ERR(ksym = resolve_symbol(mod, info, name, owner)) 1304 !IS_ERR(ksym = resolve_symbol(mod, info, name, owner))
1310 || PTR_ERR(ksym) != -EBUSY, 1305 || PTR_ERR(ksym) != -EBUSY,
1311 30 * HZ) <= 0) { 1306 30 * HZ) <= 0) {
1312 printk(KERN_WARNING "%s: gave up waiting for init of module %s.\n", 1307 pr_warn("%s: gave up waiting for init of module %s.\n",
1313 mod->name, owner); 1308 mod->name, owner);
1314 } 1309 }
1315 return ksym; 1310 return ksym;
1316} 1311}
@@ -1626,15 +1621,14 @@ static int mod_sysfs_init(struct module *mod)
1626 struct kobject *kobj; 1621 struct kobject *kobj;
1627 1622
1628 if (!module_sysfs_initialized) { 1623 if (!module_sysfs_initialized) {
1629 printk(KERN_ERR "%s: module sysfs not initialized\n", 1624 pr_err("%s: module sysfs not initialized\n", mod->name);
1630 mod->name);
1631 err = -EINVAL; 1625 err = -EINVAL;
1632 goto out; 1626 goto out;
1633 } 1627 }
1634 1628
1635 kobj = kset_find_obj(module_kset, mod->name); 1629 kobj = kset_find_obj(module_kset, mod->name);
1636 if (kobj) { 1630 if (kobj) {
1637 printk(KERN_ERR "%s: module is already loaded\n", mod->name); 1631 pr_err("%s: module is already loaded\n", mod->name);
1638 kobject_put(kobj); 1632 kobject_put(kobj);
1639 err = -EINVAL; 1633 err = -EINVAL;
1640 goto out; 1634 goto out;
@@ -1961,8 +1955,7 @@ static int verify_export_symbols(struct module *mod)
1961 for (i = 0; i < ARRAY_SIZE(arr); i++) { 1955 for (i = 0; i < ARRAY_SIZE(arr); i++) {
1962 for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) { 1956 for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) {
1963 if (find_symbol(s->name, &owner, NULL, true, false)) { 1957 if (find_symbol(s->name, &owner, NULL, true, false)) {
1964 printk(KERN_ERR 1958 pr_err("%s: exports duplicate symbol %s"
1965 "%s: exports duplicate symbol %s"
1966 " (owned by %s)\n", 1959 " (owned by %s)\n",
1967 mod->name, s->name, module_name(owner)); 1960 mod->name, s->name, module_name(owner));
1968 return -ENOEXEC; 1961 return -ENOEXEC;
@@ -2013,8 +2006,8 @@ static int simplify_symbols(struct module *mod, const struct load_info *info)
2013 if (!ksym && ELF_ST_BIND(sym[i].st_info) == STB_WEAK) 2006 if (!ksym && ELF_ST_BIND(sym[i].st_info) == STB_WEAK)
2014 break; 2007 break;
2015 2008
2016 printk(KERN_WARNING "%s: Unknown symbol %s (err %li)\n", 2009 pr_warn("%s: Unknown symbol %s (err %li)\n",
2017 mod->name, name, PTR_ERR(ksym)); 2010 mod->name, name, PTR_ERR(ksym));
2018 ret = PTR_ERR(ksym) ?: -ENOENT; 2011 ret = PTR_ERR(ksym) ?: -ENOENT;
2019 break; 2012 break;
2020 2013
@@ -2168,8 +2161,8 @@ static void set_license(struct module *mod, const char *license)
2168 2161
2169 if (!license_is_gpl_compatible(license)) { 2162 if (!license_is_gpl_compatible(license)) {
2170 if (!test_taint(TAINT_PROPRIETARY_MODULE)) 2163 if (!test_taint(TAINT_PROPRIETARY_MODULE))
2171 printk(KERN_WARNING "%s: module license '%s' taints " 2164 pr_warn("%s: module license '%s' taints kernel.\n",
2172 "kernel.\n", mod->name, license); 2165 mod->name, license);
2173 add_taint_module(mod, TAINT_PROPRIETARY_MODULE, 2166 add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2174 LOCKDEP_NOW_UNRELIABLE); 2167 LOCKDEP_NOW_UNRELIABLE);
2175 } 2168 }
@@ -2405,8 +2398,8 @@ static void dynamic_debug_setup(struct _ddebug *debug, unsigned int num)
2405 return; 2398 return;
2406#ifdef CONFIG_DYNAMIC_DEBUG 2399#ifdef CONFIG_DYNAMIC_DEBUG
2407 if (ddebug_add_module(debug, num, debug->modname)) 2400 if (ddebug_add_module(debug, num, debug->modname))
2408 printk(KERN_ERR "dynamic debug error adding module: %s\n", 2401 pr_err("dynamic debug error adding module: %s\n",
2409 debug->modname); 2402 debug->modname);
2410#endif 2403#endif
2411} 2404}
2412 2405
@@ -2619,8 +2612,7 @@ static int rewrite_section_headers(struct load_info *info, int flags)
2619 Elf_Shdr *shdr = &info->sechdrs[i]; 2612 Elf_Shdr *shdr = &info->sechdrs[i];
2620 if (shdr->sh_type != SHT_NOBITS 2613 if (shdr->sh_type != SHT_NOBITS
2621 && info->len < shdr->sh_offset + shdr->sh_size) { 2614 && info->len < shdr->sh_offset + shdr->sh_size) {
2622 printk(KERN_ERR "Module len %lu truncated\n", 2615 pr_err("Module len %lu truncated\n", info->len);
2623 info->len);
2624 return -ENOEXEC; 2616 return -ENOEXEC;
2625 } 2617 }
2626 2618
@@ -2682,15 +2674,14 @@ static struct module *setup_load_info(struct load_info *info, int flags)
2682 2674
2683 info->index.mod = find_sec(info, ".gnu.linkonce.this_module"); 2675 info->index.mod = find_sec(info, ".gnu.linkonce.this_module");
2684 if (!info->index.mod) { 2676 if (!info->index.mod) {
2685 printk(KERN_WARNING "No module found in object\n"); 2677 pr_warn("No module found in object\n");
2686 return ERR_PTR(-ENOEXEC); 2678 return ERR_PTR(-ENOEXEC);
2687 } 2679 }
2688 /* This is temporary: point mod into copy of data. */ 2680 /* This is temporary: point mod into copy of data. */
2689 mod = (void *)info->sechdrs[info->index.mod].sh_addr; 2681 mod = (void *)info->sechdrs[info->index.mod].sh_addr;
2690 2682
2691 if (info->index.sym == 0) { 2683 if (info->index.sym == 0) {
2692 printk(KERN_WARNING "%s: module has no symbols (stripped?)\n", 2684 pr_warn("%s: module has no symbols (stripped?)\n", mod->name);
2693 mod->name);
2694 return ERR_PTR(-ENOEXEC); 2685 return ERR_PTR(-ENOEXEC);
2695 } 2686 }
2696 2687
@@ -2717,7 +2708,7 @@ static int check_modinfo(struct module *mod, struct load_info *info, int flags)
2717 if (err) 2708 if (err)
2718 return err; 2709 return err;
2719 } else if (!same_magic(modmagic, vermagic, info->index.vers)) { 2710 } else if (!same_magic(modmagic, vermagic, info->index.vers)) {
2720 printk(KERN_ERR "%s: version magic '%s' should be '%s'\n", 2711 pr_err("%s: version magic '%s' should be '%s'\n",
2721 mod->name, modmagic, vermagic); 2712 mod->name, modmagic, vermagic);
2722 return -ENOEXEC; 2713 return -ENOEXEC;
2723 } 2714 }
@@ -2727,9 +2718,8 @@ static int check_modinfo(struct module *mod, struct load_info *info, int flags)
2727 2718
2728 if (get_modinfo(info, "staging")) { 2719 if (get_modinfo(info, "staging")) {
2729 add_taint_module(mod, TAINT_CRAP, LOCKDEP_STILL_OK); 2720 add_taint_module(mod, TAINT_CRAP, LOCKDEP_STILL_OK);
2730 printk(KERN_WARNING "%s: module is from the staging directory," 2721 pr_warn("%s: module is from the staging directory, the quality "
2731 " the quality is unknown, you have been warned.\n", 2722 "is unknown, you have been warned.\n", mod->name);
2732 mod->name);
2733 } 2723 }
2734 2724
2735 /* Set up license info based on the info section */ 2725 /* Set up license info based on the info section */
@@ -2801,8 +2791,7 @@ static void find_module_sections(struct module *mod, struct load_info *info)
2801 sizeof(*mod->extable), &mod->num_exentries); 2791 sizeof(*mod->extable), &mod->num_exentries);
2802 2792
2803 if (section_addr(info, "__obsparm")) 2793 if (section_addr(info, "__obsparm"))
2804 printk(KERN_WARNING "%s: Ignoring obsolete parameters\n", 2794 pr_warn("%s: Ignoring obsolete parameters\n", mod->name);
2805 mod->name);
2806 2795
2807 info->debug = section_objs(info, "__verbose", 2796 info->debug = section_objs(info, "__verbose",
2808 sizeof(*info->debug), &info->num_debug); 2797 sizeof(*info->debug), &info->num_debug);
@@ -3078,11 +3067,10 @@ static int do_init_module(struct module *mod)
3078 return ret; 3067 return ret;
3079 } 3068 }
3080 if (ret > 0) { 3069 if (ret > 0) {
3081 printk(KERN_WARNING 3070 pr_warn("%s: '%s'->init suspiciously returned %d, it should "
3082"%s: '%s'->init suspiciously returned %d, it should follow 0/-E convention\n" 3071 "follow 0/-E convention\n"
3083"%s: loading module anyway...\n", 3072 "%s: loading module anyway...\n",
3084 __func__, mod->name, ret, 3073 __func__, mod->name, ret, __func__);
3085 __func__);
3086 dump_stack(); 3074 dump_stack();
3087 } 3075 }
3088 3076
@@ -3205,10 +3193,8 @@ static int unknown_module_param_cb(char *param, char *val, const char *modname)
3205{ 3193{
3206 /* Check for magic 'dyndbg' arg */ 3194 /* Check for magic 'dyndbg' arg */
3207 int ret = ddebug_dyndbg_module_param_cb(param, val, modname); 3195 int ret = ddebug_dyndbg_module_param_cb(param, val, modname);
3208 if (ret != 0) { 3196 if (ret != 0)
3209 printk(KERN_WARNING "%s: unknown parameter '%s' ignored\n", 3197 pr_warn("%s: unknown parameter '%s' ignored\n", modname, param);
3210 modname, param);
3211 }
3212 return 0; 3198 return 0;
3213} 3199}
3214 3200
@@ -3243,10 +3229,9 @@ static int load_module(struct load_info *info, const char __user *uargs,
3243#ifdef CONFIG_MODULE_SIG 3229#ifdef CONFIG_MODULE_SIG
3244 mod->sig_ok = info->sig_ok; 3230 mod->sig_ok = info->sig_ok;
3245 if (!mod->sig_ok) { 3231 if (!mod->sig_ok) {
3246 printk_once(KERN_NOTICE 3232 pr_notice_once("%s: module verification failed: signature "
3247 "%s: module verification failed: signature and/or" 3233 "and/or required key missing - tainting "
3248 " required key missing - tainting kernel\n", 3234 "kernel\n", mod->name);
3249 mod->name);
3250 add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_STILL_OK); 3235 add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_STILL_OK);
3251 } 3236 }
3252#endif 3237#endif
diff --git a/kernel/panic.c b/kernel/panic.c
index b6c482ccc5db..c00b4ceb39e8 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -233,7 +233,7 @@ static const struct tnt tnts[] = {
233 */ 233 */
234const char *print_tainted(void) 234const char *print_tainted(void)
235{ 235{
236 static char buf[ARRAY_SIZE(tnts) + sizeof("Tainted: ") + 1]; 236 static char buf[ARRAY_SIZE(tnts) + sizeof("Tainted: ")];
237 237
238 if (tainted_mask) { 238 if (tainted_mask) {
239 char *s; 239 char *s;
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index b4e8500afdb3..be7c86bae576 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -705,9 +705,9 @@ const struct file_operations kmsg_fops = {
705 705
706#ifdef CONFIG_KEXEC 706#ifdef CONFIG_KEXEC
707/* 707/*
708 * This appends the listed symbols to /proc/vmcoreinfo 708 * This appends the listed symbols to /proc/vmcore
709 * 709 *
710 * /proc/vmcoreinfo is used by various utiilties, like crash and makedumpfile to 710 * /proc/vmcore is used by various utilities, like crash and makedumpfile to
711 * obtain access to symbols that are otherwise very difficult to locate. These 711 * obtain access to symbols that are otherwise very difficult to locate. These
712 * symbols are specifically used so that utilities can access and extract the 712 * symbols are specifically used so that utilities can access and extract the
713 * dmesg log from a vmcore file after a crash. 713 * dmesg log from a vmcore file after a crash.
@@ -791,7 +791,7 @@ static bool __read_mostly ignore_loglevel;
791static int __init ignore_loglevel_setup(char *str) 791static int __init ignore_loglevel_setup(char *str)
792{ 792{
793 ignore_loglevel = 1; 793 ignore_loglevel = 1;
794 printk(KERN_INFO "debug: ignoring loglevel setting.\n"); 794 pr_info("debug: ignoring loglevel setting.\n");
795 795
796 return 0; 796 return 0;
797} 797}
@@ -820,9 +820,9 @@ static int __init boot_delay_setup(char *str)
820 pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, " 820 pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
821 "HZ: %d, loops_per_msec: %llu\n", 821 "HZ: %d, loops_per_msec: %llu\n",
822 boot_delay, preset_lpj, lpj, HZ, loops_per_msec); 822 boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
823 return 1; 823 return 0;
824} 824}
825__setup("boot_delay=", boot_delay_setup); 825early_param("boot_delay", boot_delay_setup);
826 826
827static void boot_delay_msec(int level) 827static void boot_delay_msec(int level)
828{ 828{
@@ -2193,7 +2193,7 @@ static int __read_mostly keep_bootcon;
2193static int __init keep_bootcon_setup(char *str) 2193static int __init keep_bootcon_setup(char *str)
2194{ 2194{
2195 keep_bootcon = 1; 2195 keep_bootcon = 1;
2196 printk(KERN_INFO "debug: skip boot console de-registration.\n"); 2196 pr_info("debug: skip boot console de-registration.\n");
2197 2197
2198 return 0; 2198 return 0;
2199} 2199}
@@ -2241,7 +2241,7 @@ void register_console(struct console *newcon)
2241 /* find the last or real console */ 2241 /* find the last or real console */
2242 for_each_console(bcon) { 2242 for_each_console(bcon) {
2243 if (!(bcon->flags & CON_BOOT)) { 2243 if (!(bcon->flags & CON_BOOT)) {
2244 printk(KERN_INFO "Too late to register bootconsole %s%d\n", 2244 pr_info("Too late to register bootconsole %s%d\n",
2245 newcon->name, newcon->index); 2245 newcon->name, newcon->index);
2246 return; 2246 return;
2247 } 2247 }
@@ -2358,21 +2358,18 @@ void register_console(struct console *newcon)
2358 * users know there might be something in the kernel's log buffer that 2358 * users know there might be something in the kernel's log buffer that
2359 * went to the bootconsole (that they do not see on the real console) 2359 * went to the bootconsole (that they do not see on the real console)
2360 */ 2360 */
2361 pr_info("%sconsole [%s%d] enabled\n",
2362 (newcon->flags & CON_BOOT) ? "boot" : "" ,
2363 newcon->name, newcon->index);
2361 if (bcon && 2364 if (bcon &&
2362 ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) && 2365 ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
2363 !keep_bootcon) { 2366 !keep_bootcon) {
2364 /* we need to iterate through twice, to make sure we print 2367 /* We need to iterate through all boot consoles, to make
2365 * everything out, before we unregister the console(s) 2368 * sure we print everything out, before we unregister them.
2366 */ 2369 */
2367 printk(KERN_INFO "console [%s%d] enabled, bootconsole disabled\n",
2368 newcon->name, newcon->index);
2369 for_each_console(bcon) 2370 for_each_console(bcon)
2370 if (bcon->flags & CON_BOOT) 2371 if (bcon->flags & CON_BOOT)
2371 unregister_console(bcon); 2372 unregister_console(bcon);
2372 } else {
2373 printk(KERN_INFO "%sconsole [%s%d] enabled\n",
2374 (newcon->flags & CON_BOOT) ? "boot" : "" ,
2375 newcon->name, newcon->index);
2376 } 2373 }
2377} 2374}
2378EXPORT_SYMBOL(register_console); 2375EXPORT_SYMBOL(register_console);
@@ -2382,6 +2379,10 @@ int unregister_console(struct console *console)
2382 struct console *a, *b; 2379 struct console *a, *b;
2383 int res; 2380 int res;
2384 2381
2382 pr_info("%sconsole [%s%d] disabled\n",
2383 (console->flags & CON_BOOT) ? "boot" : "" ,
2384 console->name, console->index);
2385
2385 res = _braille_unregister_console(console); 2386 res = _braille_unregister_console(console);
2386 if (res) 2387 if (res)
2387 return res; 2388 return res;
@@ -2421,8 +2422,6 @@ static int __init printk_late_init(void)
2421 2422
2422 for_each_console(con) { 2423 for_each_console(con) {
2423 if (!keep_bootcon && con->flags & CON_BOOT) { 2424 if (!keep_bootcon && con->flags & CON_BOOT) {
2424 printk(KERN_INFO "turn off boot console %s%d\n",
2425 con->name, con->index);
2426 unregister_console(con); 2425 unregister_console(con);
2427 } 2426 }
2428 } 2427 }
@@ -2449,7 +2448,7 @@ static void wake_up_klogd_work_func(struct irq_work *irq_work)
2449 2448
2450 if (pending & PRINTK_PENDING_SCHED) { 2449 if (pending & PRINTK_PENDING_SCHED) {
2451 char *buf = __get_cpu_var(printk_sched_buf); 2450 char *buf = __get_cpu_var(printk_sched_buf);
2452 printk(KERN_WARNING "[sched_delayed] %s", buf); 2451 pr_warn("[sched_delayed] %s", buf);
2453 } 2452 }
2454 2453
2455 if (pending & PRINTK_PENDING_WAKEUP) 2454 if (pending & PRINTK_PENDING_WAKEUP)
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index dd562e9aa2c8..1f4bcb3cc21c 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -257,7 +257,8 @@ ok:
257 if (task->mm) 257 if (task->mm)
258 dumpable = get_dumpable(task->mm); 258 dumpable = get_dumpable(task->mm);
259 rcu_read_lock(); 259 rcu_read_lock();
260 if (!dumpable && !ptrace_has_cap(__task_cred(task)->user_ns, mode)) { 260 if (dumpable != SUID_DUMP_USER &&
261 !ptrace_has_cap(__task_cred(task)->user_ns, mode)) {
261 rcu_read_unlock(); 262 rcu_read_unlock();
262 return -EPERM; 263 return -EPERM;
263 } 264 }
diff --git a/kernel/sys.c b/kernel/sys.c
index c18ecca575b4..c72311324ea7 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -16,7 +16,6 @@
16#include <linux/perf_event.h> 16#include <linux/perf_event.h>
17#include <linux/resource.h> 17#include <linux/resource.h>
18#include <linux/kernel.h> 18#include <linux/kernel.h>
19#include <linux/kexec.h>
20#include <linux/workqueue.h> 19#include <linux/workqueue.h>
21#include <linux/capability.h> 20#include <linux/capability.h>
22#include <linux/device.h> 21#include <linux/device.h>
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 36547dddcdb8..d37d9dd8f463 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -2222,8 +2222,11 @@ static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int
2222 *i = val; 2222 *i = val;
2223 } else { 2223 } else {
2224 val = convdiv * (*i) / convmul; 2224 val = convdiv * (*i) / convmul;
2225 if (!first) 2225 if (!first) {
2226 err = proc_put_char(&buffer, &left, '\t'); 2226 err = proc_put_char(&buffer, &left, '\t');
2227 if (err)
2228 break;
2229 }
2227 err = proc_put_long(&buffer, &left, val, false); 2230 err = proc_put_long(&buffer, &left, val, false);
2228 if (err) 2231 if (err)
2229 break; 2232 break;
diff --git a/kernel/sysctl_binary.c b/kernel/sysctl_binary.c
index b609213ca9a2..653cbbd9e7ad 100644
--- a/kernel/sysctl_binary.c
+++ b/kernel/sysctl_binary.c
@@ -1024,7 +1024,7 @@ static ssize_t bin_intvec(struct file *file,
1024 if (get_user(value, vec + i)) 1024 if (get_user(value, vec + i))
1025 goto out_kfree; 1025 goto out_kfree;
1026 1026
1027 str += snprintf(str, end - str, "%lu\t", value); 1027 str += scnprintf(str, end - str, "%lu\t", value);
1028 } 1028 }
1029 1029
1030 result = kernel_write(file, buffer, str - buffer, 0); 1030 result = kernel_write(file, buffer, str - buffer, 0);
@@ -1095,7 +1095,7 @@ static ssize_t bin_ulongvec(struct file *file,
1095 if (get_user(value, vec + i)) 1095 if (get_user(value, vec + i))
1096 goto out_kfree; 1096 goto out_kfree;
1097 1097
1098 str += snprintf(str, end - str, "%lu\t", value); 1098 str += scnprintf(str, end - str, "%lu\t", value);
1099 } 1099 }
1100 1100
1101 result = kernel_write(file, buffer, str - buffer, 0); 1101 result = kernel_write(file, buffer, str - buffer, 0);
@@ -1205,7 +1205,7 @@ static ssize_t bin_dn_node_address(struct file *file,
1205 if (get_user(dnaddr, (__le16 __user *)newval)) 1205 if (get_user(dnaddr, (__le16 __user *)newval))
1206 goto out; 1206 goto out;
1207 1207
1208 len = snprintf(buf, sizeof(buf), "%hu.%hu", 1208 len = scnprintf(buf, sizeof(buf), "%hu.%hu",
1209 le16_to_cpu(dnaddr) >> 10, 1209 le16_to_cpu(dnaddr) >> 10,
1210 le16_to_cpu(dnaddr) & 0x3ff); 1210 le16_to_cpu(dnaddr) & 0x3ff);
1211 1211
diff --git a/kernel/taskstats.c b/kernel/taskstats.c
index 145bb4d3bd4d..9f4618eb51c8 100644
--- a/kernel/taskstats.c
+++ b/kernel/taskstats.c
@@ -290,6 +290,7 @@ static int add_del_listener(pid_t pid, const struct cpumask *mask, int isadd)
290 struct listener_list *listeners; 290 struct listener_list *listeners;
291 struct listener *s, *tmp, *s2; 291 struct listener *s, *tmp, *s2;
292 unsigned int cpu; 292 unsigned int cpu;
293 int ret = 0;
293 294
294 if (!cpumask_subset(mask, cpu_possible_mask)) 295 if (!cpumask_subset(mask, cpu_possible_mask))
295 return -EINVAL; 296 return -EINVAL;
@@ -304,9 +305,10 @@ static int add_del_listener(pid_t pid, const struct cpumask *mask, int isadd)
304 for_each_cpu(cpu, mask) { 305 for_each_cpu(cpu, mask) {
305 s = kmalloc_node(sizeof(struct listener), 306 s = kmalloc_node(sizeof(struct listener),
306 GFP_KERNEL, cpu_to_node(cpu)); 307 GFP_KERNEL, cpu_to_node(cpu));
307 if (!s) 308 if (!s) {
309 ret = -ENOMEM;
308 goto cleanup; 310 goto cleanup;
309 311 }
310 s->pid = pid; 312 s->pid = pid;
311 s->valid = 1; 313 s->valid = 1;
312 314
@@ -339,7 +341,7 @@ cleanup:
339 } 341 }
340 up_write(&listeners->sem); 342 up_write(&listeners->sem);
341 } 343 }
342 return 0; 344 return ret;
343} 345}
344 346
345static int parse(struct nlattr *na, struct cpumask *mask) 347static int parse(struct nlattr *na, struct cpumask *mask)
@@ -404,11 +406,15 @@ static struct taskstats *mk_reply(struct sk_buff *skb, int type, u32 pid)
404 if (!na) 406 if (!na)
405 goto err; 407 goto err;
406 408
407 if (nla_put(skb, type, sizeof(pid), &pid) < 0) 409 if (nla_put(skb, type, sizeof(pid), &pid) < 0) {
410 nla_nest_cancel(skb, na);
408 goto err; 411 goto err;
412 }
409 ret = nla_reserve(skb, TASKSTATS_TYPE_STATS, sizeof(struct taskstats)); 413 ret = nla_reserve(skb, TASKSTATS_TYPE_STATS, sizeof(struct taskstats));
410 if (!ret) 414 if (!ret) {
415 nla_nest_cancel(skb, na);
411 goto err; 416 goto err;
417 }
412 nla_nest_end(skb, na); 418 nla_nest_end(skb, na);
413 419
414 return nla_data(ret); 420 return nla_data(ret);
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-17 01:00:45 -0500