aboutsummaryrefslogtreecommitdiffstats
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/Kconfig.debug23
-rw-r--r--lib/bust_spinlocks.c2
-rw-r--r--lib/dynamic_printk.c58
-rw-r--r--lib/fault-inject.c1
-rw-r--r--lib/klist.c43
-rw-r--r--lib/kobject_uevent.c8
-rw-r--r--lib/percpu_counter.c18
-rw-r--r--lib/prio_heap.c2
-rw-r--r--lib/proportions.c2
-rw-r--r--lib/radix-tree.c13
-rw-r--r--lib/rbtree.c12
-rw-r--r--lib/sort.c30
-rw-r--r--lib/swiotlb.c2
-rw-r--r--lib/vsprintf.c4
14 files changed, 139 insertions, 79 deletions
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 2e75478e9c69..4c9ae6085c75 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -512,6 +512,13 @@ config DEBUG_VIRTUAL
512 512
513 If unsure, say N. 513 If unsure, say N.
514 514
515config DEBUG_NOMMU_REGIONS
516 bool "Debug the global anon/private NOMMU mapping region tree"
517 depends on DEBUG_KERNEL && !MMU
518 help
519 This option causes the global tree of anonymous and private mapping
520 regions to be regularly checked for invalid topology.
521
515config DEBUG_WRITECOUNT 522config DEBUG_WRITECOUNT
516 bool "Debug filesystem writers count" 523 bool "Debug filesystem writers count"
517 depends on DEBUG_KERNEL 524 depends on DEBUG_KERNEL
@@ -566,14 +573,14 @@ config DEBUG_NOTIFIERS
566config FRAME_POINTER 573config FRAME_POINTER
567 bool "Compile the kernel with frame pointers" 574 bool "Compile the kernel with frame pointers"
568 depends on DEBUG_KERNEL && \ 575 depends on DEBUG_KERNEL && \
569 (X86 || CRIS || M68K || M68KNOMMU || FRV || UML || S390 || \ 576 (CRIS || M68K || M68KNOMMU || FRV || UML || S390 || \
570 AVR32 || SUPERH || BLACKFIN || MN10300) 577 AVR32 || SUPERH || BLACKFIN || MN10300) || \
571 default y if DEBUG_INFO && UML 578 ARCH_WANT_FRAME_POINTERS
572 help 579 default y if (DEBUG_INFO && UML) || ARCH_WANT_FRAME_POINTERS
573 If you say Y here the resulting kernel image will be slightly larger 580 help
574 and slower, but it might give very useful debugging information on 581 If you say Y here the resulting kernel image will be slightly
575 some architectures or if you use external debuggers. 582 larger and slower, but it gives very useful debugging information
576 If you don't debug the kernel, you can say N. 583 in case of kernel bugs. (precise oopses/stacktraces/warnings)
577 584
578config BOOT_PRINTK_DELAY 585config BOOT_PRINTK_DELAY
579 bool "Delay each boot printk message by N milliseconds" 586 bool "Delay each boot printk message by N milliseconds"
diff --git a/lib/bust_spinlocks.c b/lib/bust_spinlocks.c
index 486da62b2b07..9681d54b95d1 100644
--- a/lib/bust_spinlocks.c
+++ b/lib/bust_spinlocks.c
@@ -12,6 +12,7 @@
12#include <linux/tty.h> 12#include <linux/tty.h>
13#include <linux/wait.h> 13#include <linux/wait.h>
14#include <linux/vt_kern.h> 14#include <linux/vt_kern.h>
15#include <linux/console.h>
15 16
16 17
17void __attribute__((weak)) bust_spinlocks(int yes) 18void __attribute__((weak)) bust_spinlocks(int yes)
@@ -22,6 +23,7 @@ void __attribute__((weak)) bust_spinlocks(int yes)
22#ifdef CONFIG_VT 23#ifdef CONFIG_VT
23 unblank_screen(); 24 unblank_screen();
24#endif 25#endif
26 console_unblank();
25 if (--oops_in_progress == 0) 27 if (--oops_in_progress == 0)
26 wake_up_klogd(); 28 wake_up_klogd();
27 } 29 }
diff --git a/lib/dynamic_printk.c b/lib/dynamic_printk.c
index 8e30295e8566..165a19763dc9 100644
--- a/lib/dynamic_printk.c
+++ b/lib/dynamic_printk.c
@@ -277,40 +277,34 @@ static ssize_t pr_debug_write(struct file *file, const char __user *buf,
277 dynamic_enabled = DYNAMIC_ENABLED_NONE; 277 dynamic_enabled = DYNAMIC_ENABLED_NONE;
278 } 278 }
279 err = 0; 279 err = 0;
280 } else { 280 } else if (elem) {
281 if (elem) { 281 if (value && (elem->enable == 0)) {
282 if (value && (elem->enable == 0)) { 282 dynamic_printk_enabled |= (1LL << elem->hash1);
283 dynamic_printk_enabled |= 283 dynamic_printk_enabled2 |= (1LL << elem->hash2);
284 (1LL << elem->hash1); 284 elem->enable = 1;
285 dynamic_printk_enabled2 |= 285 num_enabled++;
286 (1LL << elem->hash2); 286 dynamic_enabled = DYNAMIC_ENABLED_SOME;
287 elem->enable = 1; 287 err = 0;
288 num_enabled++; 288 printk(KERN_DEBUG
289 dynamic_enabled = DYNAMIC_ENABLED_SOME; 289 "debugging enabled for module %s\n",
290 err = 0; 290 elem->name);
291 printk(KERN_DEBUG 291 } else if (!value && (elem->enable == 1)) {
292 "debugging enabled for module %s\n", 292 elem->enable = 0;
293 elem->name); 293 num_enabled--;
294 } else if (!value && (elem->enable == 1)) { 294 if (disabled_hash(elem->hash1, true))
295 elem->enable = 0; 295 dynamic_printk_enabled &=
296 num_enabled--;
297 if (disabled_hash(elem->hash1, true))
298 dynamic_printk_enabled &=
299 ~(1LL << elem->hash1); 296 ~(1LL << elem->hash1);
300 if (disabled_hash(elem->hash2, false)) 297 if (disabled_hash(elem->hash2, false))
301 dynamic_printk_enabled2 &= 298 dynamic_printk_enabled2 &=
302 ~(1LL << elem->hash2); 299 ~(1LL << elem->hash2);
303 if (num_enabled) 300 if (num_enabled)
304 dynamic_enabled = 301 dynamic_enabled = DYNAMIC_ENABLED_SOME;
305 DYNAMIC_ENABLED_SOME; 302 else
306 else 303 dynamic_enabled = DYNAMIC_ENABLED_NONE;
307 dynamic_enabled = 304 err = 0;
308 DYNAMIC_ENABLED_NONE; 305 printk(KERN_DEBUG
309 err = 0; 306 "debugging disabled for module %s\n",
310 printk(KERN_DEBUG 307 elem->name);
311 "debugging disabled for module "
312 "%s\n", elem->name);
313 }
314 } 308 }
315 } 309 }
316 } 310 }
diff --git a/lib/fault-inject.c b/lib/fault-inject.c
index a50a311554cc..f97af55bdd96 100644
--- a/lib/fault-inject.c
+++ b/lib/fault-inject.c
@@ -6,7 +6,6 @@
6#include <linux/fs.h> 6#include <linux/fs.h>
7#include <linux/module.h> 7#include <linux/module.h>
8#include <linux/interrupt.h> 8#include <linux/interrupt.h>
9#include <linux/unwind.h>
10#include <linux/stacktrace.h> 9#include <linux/stacktrace.h>
11#include <linux/kallsyms.h> 10#include <linux/kallsyms.h>
12#include <linux/fault-inject.h> 11#include <linux/fault-inject.h>
diff --git a/lib/klist.c b/lib/klist.c
index bbdd3015c2c7..573d6068a42e 100644
--- a/lib/klist.c
+++ b/lib/klist.c
@@ -36,6 +36,7 @@
36 36
37#include <linux/klist.h> 37#include <linux/klist.h>
38#include <linux/module.h> 38#include <linux/module.h>
39#include <linux/sched.h>
39 40
40/* 41/*
41 * Use the lowest bit of n_klist to mark deleted nodes and exclude 42 * Use the lowest bit of n_klist to mark deleted nodes and exclude
@@ -108,7 +109,6 @@ static void add_tail(struct klist *k, struct klist_node *n)
108static void klist_node_init(struct klist *k, struct klist_node *n) 109static void klist_node_init(struct klist *k, struct klist_node *n)
109{ 110{
110 INIT_LIST_HEAD(&n->n_node); 111 INIT_LIST_HEAD(&n->n_node);
111 init_completion(&n->n_removed);
112 kref_init(&n->n_ref); 112 kref_init(&n->n_ref);
113 knode_set_klist(n, k); 113 knode_set_klist(n, k);
114 if (k->get) 114 if (k->get)
@@ -171,13 +171,34 @@ void klist_add_before(struct klist_node *n, struct klist_node *pos)
171} 171}
172EXPORT_SYMBOL_GPL(klist_add_before); 172EXPORT_SYMBOL_GPL(klist_add_before);
173 173
174struct klist_waiter {
175 struct list_head list;
176 struct klist_node *node;
177 struct task_struct *process;
178 int woken;
179};
180
181static DEFINE_SPINLOCK(klist_remove_lock);
182static LIST_HEAD(klist_remove_waiters);
183
174static void klist_release(struct kref *kref) 184static void klist_release(struct kref *kref)
175{ 185{
186 struct klist_waiter *waiter, *tmp;
176 struct klist_node *n = container_of(kref, struct klist_node, n_ref); 187 struct klist_node *n = container_of(kref, struct klist_node, n_ref);
177 188
178 WARN_ON(!knode_dead(n)); 189 WARN_ON(!knode_dead(n));
179 list_del(&n->n_node); 190 list_del(&n->n_node);
180 complete(&n->n_removed); 191 spin_lock(&klist_remove_lock);
192 list_for_each_entry_safe(waiter, tmp, &klist_remove_waiters, list) {
193 if (waiter->node != n)
194 continue;
195
196 waiter->woken = 1;
197 mb();
198 wake_up_process(waiter->process);
199 list_del(&waiter->list);
200 }
201 spin_unlock(&klist_remove_lock);
181 knode_set_klist(n, NULL); 202 knode_set_klist(n, NULL);
182} 203}
183 204
@@ -217,8 +238,24 @@ EXPORT_SYMBOL_GPL(klist_del);
217 */ 238 */
218void klist_remove(struct klist_node *n) 239void klist_remove(struct klist_node *n)
219{ 240{
241 struct klist_waiter waiter;
242
243 waiter.node = n;
244 waiter.process = current;
245 waiter.woken = 0;
246 spin_lock(&klist_remove_lock);
247 list_add(&waiter.list, &klist_remove_waiters);
248 spin_unlock(&klist_remove_lock);
249
220 klist_del(n); 250 klist_del(n);
221 wait_for_completion(&n->n_removed); 251
252 for (;;) {
253 set_current_state(TASK_UNINTERRUPTIBLE);
254 if (waiter.woken)
255 break;
256 schedule();
257 }
258 __set_current_state(TASK_RUNNING);
222} 259}
223EXPORT_SYMBOL_GPL(klist_remove); 260EXPORT_SYMBOL_GPL(klist_remove);
224 261
diff --git a/lib/kobject_uevent.c b/lib/kobject_uevent.c
index 3f914725bda8..318328ddbd1c 100644
--- a/lib/kobject_uevent.c
+++ b/lib/kobject_uevent.c
@@ -165,7 +165,7 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
165 /* keys passed in from the caller */ 165 /* keys passed in from the caller */
166 if (envp_ext) { 166 if (envp_ext) {
167 for (i = 0; envp_ext[i]; i++) { 167 for (i = 0; envp_ext[i]; i++) {
168 retval = add_uevent_var(env, envp_ext[i]); 168 retval = add_uevent_var(env, "%s", envp_ext[i]);
169 if (retval) 169 if (retval)
170 goto exit; 170 goto exit;
171 } 171 }
@@ -225,8 +225,10 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
225 } 225 }
226 226
227 NETLINK_CB(skb).dst_group = 1; 227 NETLINK_CB(skb).dst_group = 1;
228 netlink_broadcast(uevent_sock, skb, 0, 1, GFP_KERNEL); 228 retval = netlink_broadcast(uevent_sock, skb, 0, 1,
229 } 229 GFP_KERNEL);
230 } else
231 retval = -ENOMEM;
230 } 232 }
231#endif 233#endif
232 234
diff --git a/lib/percpu_counter.c b/lib/percpu_counter.c
index 4bb0ed350e73..aeaa6d734447 100644
--- a/lib/percpu_counter.c
+++ b/lib/percpu_counter.c
@@ -9,10 +9,8 @@
9#include <linux/cpu.h> 9#include <linux/cpu.h>
10#include <linux/module.h> 10#include <linux/module.h>
11 11
12#ifdef CONFIG_HOTPLUG_CPU
13static LIST_HEAD(percpu_counters); 12static LIST_HEAD(percpu_counters);
14static DEFINE_MUTEX(percpu_counters_lock); 13static DEFINE_MUTEX(percpu_counters_lock);
15#endif
16 14
17void percpu_counter_set(struct percpu_counter *fbc, s64 amount) 15void percpu_counter_set(struct percpu_counter *fbc, s64 amount)
18{ 16{
@@ -101,13 +99,24 @@ void percpu_counter_destroy(struct percpu_counter *fbc)
101} 99}
102EXPORT_SYMBOL(percpu_counter_destroy); 100EXPORT_SYMBOL(percpu_counter_destroy);
103 101
104#ifdef CONFIG_HOTPLUG_CPU 102int percpu_counter_batch __read_mostly = 32;
103EXPORT_SYMBOL(percpu_counter_batch);
104
105static void compute_batch_value(void)
106{
107 int nr = num_online_cpus();
108
109 percpu_counter_batch = max(32, nr*2);
110}
111
105static int __cpuinit percpu_counter_hotcpu_callback(struct notifier_block *nb, 112static int __cpuinit percpu_counter_hotcpu_callback(struct notifier_block *nb,
106 unsigned long action, void *hcpu) 113 unsigned long action, void *hcpu)
107{ 114{
115#ifdef CONFIG_HOTPLUG_CPU
108 unsigned int cpu; 116 unsigned int cpu;
109 struct percpu_counter *fbc; 117 struct percpu_counter *fbc;
110 118
119 compute_batch_value();
111 if (action != CPU_DEAD) 120 if (action != CPU_DEAD)
112 return NOTIFY_OK; 121 return NOTIFY_OK;
113 122
@@ -124,13 +133,14 @@ static int __cpuinit percpu_counter_hotcpu_callback(struct notifier_block *nb,
124 spin_unlock_irqrestore(&fbc->lock, flags); 133 spin_unlock_irqrestore(&fbc->lock, flags);
125 } 134 }
126 mutex_unlock(&percpu_counters_lock); 135 mutex_unlock(&percpu_counters_lock);
136#endif
127 return NOTIFY_OK; 137 return NOTIFY_OK;
128} 138}
129 139
130static int __init percpu_counter_startup(void) 140static int __init percpu_counter_startup(void)
131{ 141{
142 compute_batch_value();
132 hotcpu_notifier(percpu_counter_hotcpu_callback, 0); 143 hotcpu_notifier(percpu_counter_hotcpu_callback, 0);
133 return 0; 144 return 0;
134} 145}
135module_init(percpu_counter_startup); 146module_init(percpu_counter_startup);
136#endif
diff --git a/lib/prio_heap.c b/lib/prio_heap.c
index 471944a54e23..a7af6f85eca8 100644
--- a/lib/prio_heap.c
+++ b/lib/prio_heap.c
@@ -31,7 +31,7 @@ void *heap_insert(struct ptr_heap *heap, void *p)
31 31
32 if (heap->size < heap->max) { 32 if (heap->size < heap->max) {
33 /* Heap insertion */ 33 /* Heap insertion */
34 int pos = heap->size++; 34 pos = heap->size++;
35 while (pos > 0 && heap->gt(p, ptrs[(pos-1)/2])) { 35 while (pos > 0 && heap->gt(p, ptrs[(pos-1)/2])) {
36 ptrs[pos] = ptrs[(pos-1)/2]; 36 ptrs[pos] = ptrs[(pos-1)/2];
37 pos = (pos-1)/2; 37 pos = (pos-1)/2;
diff --git a/lib/proportions.c b/lib/proportions.c
index 7367f2b727d0..d50746a79de2 100644
--- a/lib/proportions.c
+++ b/lib/proportions.c
@@ -147,6 +147,7 @@ out:
147 * this is used to track the active references. 147 * this is used to track the active references.
148 */ 148 */
149static struct prop_global *prop_get_global(struct prop_descriptor *pd) 149static struct prop_global *prop_get_global(struct prop_descriptor *pd)
150__acquires(RCU)
150{ 151{
151 int index; 152 int index;
152 153
@@ -160,6 +161,7 @@ static struct prop_global *prop_get_global(struct prop_descriptor *pd)
160} 161}
161 162
162static void prop_put_global(struct prop_descriptor *pd, struct prop_global *pg) 163static void prop_put_global(struct prop_descriptor *pd, struct prop_global *pg)
164__releases(RCU)
163{ 165{
164 rcu_read_unlock(); 166 rcu_read_unlock();
165} 167}
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index be86b32bc874..4bb42a0344ec 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -81,7 +81,7 @@ struct radix_tree_preload {
81 int nr; 81 int nr;
82 struct radix_tree_node *nodes[RADIX_TREE_MAX_PATH]; 82 struct radix_tree_node *nodes[RADIX_TREE_MAX_PATH];
83}; 83};
84DEFINE_PER_CPU(struct radix_tree_preload, radix_tree_preloads) = { 0, }; 84static DEFINE_PER_CPU(struct radix_tree_preload, radix_tree_preloads) = { 0, };
85 85
86static inline gfp_t root_gfp_mask(struct radix_tree_root *root) 86static inline gfp_t root_gfp_mask(struct radix_tree_root *root)
87{ 87{
@@ -640,13 +640,14 @@ EXPORT_SYMBOL(radix_tree_tag_get);
640 * 640 *
641 * Returns: the index of the hole if found, otherwise returns an index 641 * Returns: the index of the hole if found, otherwise returns an index
642 * outside of the set specified (in which case 'return - index >= max_scan' 642 * outside of the set specified (in which case 'return - index >= max_scan'
643 * will be true). 643 * will be true). In rare cases of index wrap-around, 0 will be returned.
644 * 644 *
645 * radix_tree_next_hole may be called under rcu_read_lock. However, like 645 * radix_tree_next_hole may be called under rcu_read_lock. However, like
646 * radix_tree_gang_lookup, this will not atomically search a snapshot of the 646 * radix_tree_gang_lookup, this will not atomically search a snapshot of
647 * tree at a single point in time. For example, if a hole is created at index 647 * the tree at a single point in time. For example, if a hole is created
648 * 5, then subsequently a hole is created at index 10, radix_tree_next_hole 648 * at index 5, then subsequently a hole is created at index 10,
649 * covering both indexes may return 10 if called under rcu_read_lock. 649 * radix_tree_next_hole covering both indexes may return 10 if called
650 * under rcu_read_lock.
650 */ 651 */
651unsigned long radix_tree_next_hole(struct radix_tree_root *root, 652unsigned long radix_tree_next_hole(struct radix_tree_root *root,
652 unsigned long index, unsigned long max_scan) 653 unsigned long index, unsigned long max_scan)
diff --git a/lib/rbtree.c b/lib/rbtree.c
index 48499c2d88cc..9956b99649f0 100644
--- a/lib/rbtree.c
+++ b/lib/rbtree.c
@@ -292,7 +292,7 @@ EXPORT_SYMBOL(rb_erase);
292/* 292/*
293 * This function returns the first node (in sort order) of the tree. 293 * This function returns the first node (in sort order) of the tree.
294 */ 294 */
295struct rb_node *rb_first(struct rb_root *root) 295struct rb_node *rb_first(const struct rb_root *root)
296{ 296{
297 struct rb_node *n; 297 struct rb_node *n;
298 298
@@ -305,7 +305,7 @@ struct rb_node *rb_first(struct rb_root *root)
305} 305}
306EXPORT_SYMBOL(rb_first); 306EXPORT_SYMBOL(rb_first);
307 307
308struct rb_node *rb_last(struct rb_root *root) 308struct rb_node *rb_last(const struct rb_root *root)
309{ 309{
310 struct rb_node *n; 310 struct rb_node *n;
311 311
@@ -318,7 +318,7 @@ struct rb_node *rb_last(struct rb_root *root)
318} 318}
319EXPORT_SYMBOL(rb_last); 319EXPORT_SYMBOL(rb_last);
320 320
321struct rb_node *rb_next(struct rb_node *node) 321struct rb_node *rb_next(const struct rb_node *node)
322{ 322{
323 struct rb_node *parent; 323 struct rb_node *parent;
324 324
@@ -331,7 +331,7 @@ struct rb_node *rb_next(struct rb_node *node)
331 node = node->rb_right; 331 node = node->rb_right;
332 while (node->rb_left) 332 while (node->rb_left)
333 node=node->rb_left; 333 node=node->rb_left;
334 return node; 334 return (struct rb_node *)node;
335 } 335 }
336 336
337 /* No right-hand children. Everything down and left is 337 /* No right-hand children. Everything down and left is
@@ -347,7 +347,7 @@ struct rb_node *rb_next(struct rb_node *node)
347} 347}
348EXPORT_SYMBOL(rb_next); 348EXPORT_SYMBOL(rb_next);
349 349
350struct rb_node *rb_prev(struct rb_node *node) 350struct rb_node *rb_prev(const struct rb_node *node)
351{ 351{
352 struct rb_node *parent; 352 struct rb_node *parent;
353 353
@@ -360,7 +360,7 @@ struct rb_node *rb_prev(struct rb_node *node)
360 node = node->rb_left; 360 node = node->rb_left;
361 while (node->rb_right) 361 while (node->rb_right)
362 node=node->rb_right; 362 node=node->rb_right;
363 return node; 363 return (struct rb_node *)node;
364 } 364 }
365 365
366 /* No left-hand children. Go up till we find an ancestor which 366 /* No left-hand children. Go up till we find an ancestor which
diff --git a/lib/sort.c b/lib/sort.c
index 6abbaf3d5858..926d00429ed2 100644
--- a/lib/sort.c
+++ b/lib/sort.c
@@ -32,11 +32,11 @@ static void generic_swap(void *a, void *b, int size)
32 * @base: pointer to data to sort 32 * @base: pointer to data to sort
33 * @num: number of elements 33 * @num: number of elements
34 * @size: size of each element 34 * @size: size of each element
35 * @cmp: pointer to comparison function 35 * @cmp_func: pointer to comparison function
36 * @swap: pointer to swap function or NULL 36 * @swap_func: pointer to swap function or NULL
37 * 37 *
38 * This function does a heapsort on the given array. You may provide a 38 * This function does a heapsort on the given array. You may provide a
39 * swap function optimized to your element type. 39 * swap_func function optimized to your element type.
40 * 40 *
41 * Sorting time is O(n log n) both on average and worst-case. While 41 * Sorting time is O(n log n) both on average and worst-case. While
42 * qsort is about 20% faster on average, it suffers from exploitable 42 * qsort is about 20% faster on average, it suffers from exploitable
@@ -45,37 +45,39 @@ static void generic_swap(void *a, void *b, int size)
45 */ 45 */
46 46
47void sort(void *base, size_t num, size_t size, 47void sort(void *base, size_t num, size_t size,
48 int (*cmp)(const void *, const void *), 48 int (*cmp_func)(const void *, const void *),
49 void (*swap)(void *, void *, int size)) 49 void (*swap_func)(void *, void *, int size))
50{ 50{
51 /* pre-scale counters for performance */ 51 /* pre-scale counters for performance */
52 int i = (num/2 - 1) * size, n = num * size, c, r; 52 int i = (num/2 - 1) * size, n = num * size, c, r;
53 53
54 if (!swap) 54 if (!swap_func)
55 swap = (size == 4 ? u32_swap : generic_swap); 55 swap_func = (size == 4 ? u32_swap : generic_swap);
56 56
57 /* heapify */ 57 /* heapify */
58 for ( ; i >= 0; i -= size) { 58 for ( ; i >= 0; i -= size) {
59 for (r = i; r * 2 + size < n; r = c) { 59 for (r = i; r * 2 + size < n; r = c) {
60 c = r * 2 + size; 60 c = r * 2 + size;
61 if (c < n - size && cmp(base + c, base + c + size) < 0) 61 if (c < n - size &&
62 cmp_func(base + c, base + c + size) < 0)
62 c += size; 63 c += size;
63 if (cmp(base + r, base + c) >= 0) 64 if (cmp_func(base + r, base + c) >= 0)
64 break; 65 break;
65 swap(base + r, base + c, size); 66 swap_func(base + r, base + c, size);
66 } 67 }
67 } 68 }
68 69
69 /* sort */ 70 /* sort */
70 for (i = n - size; i > 0; i -= size) { 71 for (i = n - size; i > 0; i -= size) {
71 swap(base, base + i, size); 72 swap_func(base, base + i, size);
72 for (r = 0; r * 2 + size < i; r = c) { 73 for (r = 0; r * 2 + size < i; r = c) {
73 c = r * 2 + size; 74 c = r * 2 + size;
74 if (c < i - size && cmp(base + c, base + c + size) < 0) 75 if (c < i - size &&
76 cmp_func(base + c, base + c + size) < 0)
75 c += size; 77 c += size;
76 if (cmp(base + r, base + c) >= 0) 78 if (cmp_func(base + r, base + c) >= 0)
77 break; 79 break;
78 swap(base + r, base + c, size); 80 swap_func(base + r, base + c, size);
79 } 81 }
80 } 82 }
81} 83}
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index ec7922bd0d61..30fe65ede2bb 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -619,7 +619,7 @@ swiotlb_full(struct device *dev, size_t size, int dir, int do_panic)
619 * the damage, or panic when the transfer is too big. 619 * the damage, or panic when the transfer is too big.
620 */ 620 */
621 printk(KERN_ERR "DMA: Out of SW-IOMMU space for %zu bytes at " 621 printk(KERN_ERR "DMA: Out of SW-IOMMU space for %zu bytes at "
622 "device %s\n", size, dev ? dev->bus_id : "?"); 622 "device %s\n", size, dev ? dev_name(dev) : "?");
623 623
624 if (size > io_tlb_overflow && do_panic) { 624 if (size > io_tlb_overflow && do_panic) {
625 if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL) 625 if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL)
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 98d632277ca8..0fbd0121d91d 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -170,6 +170,8 @@ int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
170 return -EINVAL; 170 return -EINVAL;
171 171
172 val = simple_strtoul(cp, &tail, base); 172 val = simple_strtoul(cp, &tail, base);
173 if (tail == cp)
174 return -EINVAL;
173 if ((*tail == '\0') || 175 if ((*tail == '\0') ||
174 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) { 176 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
175 *res = val; 177 *res = val;
@@ -241,6 +243,8 @@ int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res)
241 return -EINVAL; 243 return -EINVAL;
242 244
243 val = simple_strtoull(cp, &tail, base); 245 val = simple_strtoull(cp, &tail, base);
246 if (tail == cp)
247 return -EINVAL;
244 if ((*tail == '\0') || 248 if ((*tail == '\0') ||
245 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) { 249 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
246 *res = val; 250 *res = val;