Annotation of /trunk/kernel26-alx/patches-3.10/0142-3.10.43-all-fixes.patch
Parent Directory | Revision Log
Revision 2672 -
(hide annotations)
(download)
Tue Jul 21 16:46:35 2015 UTC (9 years, 2 months ago) by niro
File size: 47477 byte(s)
Tue Jul 21 16:46:35 2015 UTC (9 years, 2 months ago) by niro
File size: 47477 byte(s)
-3.10.84-alx-r1
1 | niro | 2672 | diff --git a/Documentation/DocBook/media/Makefile b/Documentation/DocBook/media/Makefile |
2 | index f9fd615427fb..1d27f0a1abd1 100644 | ||
3 | --- a/Documentation/DocBook/media/Makefile | ||
4 | +++ b/Documentation/DocBook/media/Makefile | ||
5 | @@ -195,7 +195,7 @@ DVB_DOCUMENTED = \ | ||
6 | # | ||
7 | |||
8 | install_media_images = \ | ||
9 | - $(Q)cp $(OBJIMGFILES) $(MEDIA_SRC_DIR)/v4l/*.svg $(MEDIA_OBJ_DIR)/media_api | ||
10 | + $(Q)-cp $(OBJIMGFILES) $(MEDIA_SRC_DIR)/v4l/*.svg $(MEDIA_OBJ_DIR)/media_api | ||
11 | |||
12 | $(MEDIA_OBJ_DIR)/%: $(MEDIA_SRC_DIR)/%.b64 | ||
13 | $(Q)base64 -d $< >$@ | ||
14 | diff --git a/Documentation/sysctl/kernel.txt b/Documentation/sysctl/kernel.txt | ||
15 | index 9b34b1685078..8d90c42e5db6 100644 | ||
16 | --- a/Documentation/sysctl/kernel.txt | ||
17 | +++ b/Documentation/sysctl/kernel.txt | ||
18 | @@ -438,6 +438,32 @@ This file shows up if CONFIG_DEBUG_STACKOVERFLOW is enabled. | ||
19 | |||
20 | ============================================================== | ||
21 | |||
22 | +perf_cpu_time_max_percent: | ||
23 | + | ||
24 | +Hints to the kernel how much CPU time it should be allowed to | ||
25 | +use to handle perf sampling events. If the perf subsystem | ||
26 | +is informed that its samples are exceeding this limit, it | ||
27 | +will drop its sampling frequency to attempt to reduce its CPU | ||
28 | +usage. | ||
29 | + | ||
30 | +Some perf sampling happens in NMIs. If these samples | ||
31 | +unexpectedly take too long to execute, the NMIs can become | ||
32 | +stacked up next to each other so much that nothing else is | ||
33 | +allowed to execute. | ||
34 | + | ||
35 | +0: disable the mechanism. Do not monitor or correct perf's | ||
36 | + sampling rate no matter how CPU time it takes. | ||
37 | + | ||
38 | +1-100: attempt to throttle perf's sample rate to this | ||
39 | + percentage of CPU. Note: the kernel calculates an | ||
40 | + "expected" length of each sample event. 100 here means | ||
41 | + 100% of that expected length. Even if this is set to | ||
42 | + 100, you may still see sample throttling if this | ||
43 | + length is exceeded. Set to 0 if you truly do not care | ||
44 | + how much CPU is consumed. | ||
45 | + | ||
46 | +============================================================== | ||
47 | + | ||
48 | |||
49 | pid_max: | ||
50 | |||
51 | diff --git a/Makefile b/Makefile | ||
52 | index 4634015fed68..9cf513828341 100644 | ||
53 | --- a/Makefile | ||
54 | +++ b/Makefile | ||
55 | @@ -1,6 +1,6 @@ | ||
56 | VERSION = 3 | ||
57 | PATCHLEVEL = 10 | ||
58 | -SUBLEVEL = 42 | ||
59 | +SUBLEVEL = 43 | ||
60 | EXTRAVERSION = | ||
61 | NAME = TOSSUG Baby Fish | ||
62 | |||
63 | diff --git a/arch/arm/include/asm/uaccess.h b/arch/arm/include/asm/uaccess.h | ||
64 | index 7e1f76027f66..20e1c994669e 100644 | ||
65 | --- a/arch/arm/include/asm/uaccess.h | ||
66 | +++ b/arch/arm/include/asm/uaccess.h | ||
67 | @@ -164,8 +164,9 @@ extern int __put_user_8(void *, unsigned long long); | ||
68 | #define __put_user_check(x,p) \ | ||
69 | ({ \ | ||
70 | unsigned long __limit = current_thread_info()->addr_limit - 1; \ | ||
71 | + const typeof(*(p)) __user *__tmp_p = (p); \ | ||
72 | register const typeof(*(p)) __r2 asm("r2") = (x); \ | ||
73 | - register const typeof(*(p)) __user *__p asm("r0") = (p);\ | ||
74 | + register const typeof(*(p)) __user *__p asm("r0") = __tmp_p; \ | ||
75 | register unsigned long __l asm("r1") = __limit; \ | ||
76 | register int __e asm("r0"); \ | ||
77 | switch (sizeof(*(__p))) { \ | ||
78 | diff --git a/arch/arm/kernel/perf_event.c b/arch/arm/kernel/perf_event.c | ||
79 | index e19edc6f2d15..ace0ce8f6641 100644 | ||
80 | --- a/arch/arm/kernel/perf_event.c | ||
81 | +++ b/arch/arm/kernel/perf_event.c | ||
82 | @@ -303,11 +303,18 @@ static irqreturn_t armpmu_dispatch_irq(int irq, void *dev) | ||
83 | struct arm_pmu *armpmu = (struct arm_pmu *) dev; | ||
84 | struct platform_device *plat_device = armpmu->plat_device; | ||
85 | struct arm_pmu_platdata *plat = dev_get_platdata(&plat_device->dev); | ||
86 | + int ret; | ||
87 | + u64 start_clock, finish_clock; | ||
88 | |||
89 | + start_clock = sched_clock(); | ||
90 | if (plat && plat->handle_irq) | ||
91 | - return plat->handle_irq(irq, dev, armpmu->handle_irq); | ||
92 | + ret = plat->handle_irq(irq, dev, armpmu->handle_irq); | ||
93 | else | ||
94 | - return armpmu->handle_irq(irq, dev); | ||
95 | + ret = armpmu->handle_irq(irq, dev); | ||
96 | + finish_clock = sched_clock(); | ||
97 | + | ||
98 | + perf_sample_event_took(finish_clock - start_clock); | ||
99 | + return ret; | ||
100 | } | ||
101 | |||
102 | static void | ||
103 | diff --git a/arch/arm/mach-imx/devices/platform-ipu-core.c b/arch/arm/mach-imx/devices/platform-ipu-core.c | ||
104 | index fc4dd7cedc11..6bd7c3f37ac0 100644 | ||
105 | --- a/arch/arm/mach-imx/devices/platform-ipu-core.c | ||
106 | +++ b/arch/arm/mach-imx/devices/platform-ipu-core.c | ||
107 | @@ -77,7 +77,7 @@ struct platform_device *__init imx_alloc_mx3_camera( | ||
108 | |||
109 | pdev = platform_device_alloc("mx3-camera", 0); | ||
110 | if (!pdev) | ||
111 | - goto err; | ||
112 | + return ERR_PTR(-ENOMEM); | ||
113 | |||
114 | pdev->dev.dma_mask = kmalloc(sizeof(*pdev->dev.dma_mask), GFP_KERNEL); | ||
115 | if (!pdev->dev.dma_mask) | ||
116 | diff --git a/arch/arm/mach-omap2/cclock3xxx_data.c b/arch/arm/mach-omap2/cclock3xxx_data.c | ||
117 | index 45cd26430d1f..da6d407c21cd 100644 | ||
118 | --- a/arch/arm/mach-omap2/cclock3xxx_data.c | ||
119 | +++ b/arch/arm/mach-omap2/cclock3xxx_data.c | ||
120 | @@ -418,7 +418,8 @@ static struct clk_hw_omap dpll4_m5x2_ck_hw = { | ||
121 | .clkdm_name = "dpll4_clkdm", | ||
122 | }; | ||
123 | |||
124 | -DEFINE_STRUCT_CLK(dpll4_m5x2_ck, dpll4_m5x2_ck_parent_names, dpll4_m5x2_ck_ops); | ||
125 | +DEFINE_STRUCT_CLK_FLAGS(dpll4_m5x2_ck, dpll4_m5x2_ck_parent_names, | ||
126 | + dpll4_m5x2_ck_ops, CLK_SET_RATE_PARENT); | ||
127 | |||
128 | static struct clk dpll4_m5x2_ck_3630 = { | ||
129 | .name = "dpll4_m5x2_ck", | ||
130 | diff --git a/arch/arm/mach-omap2/cpuidle44xx.c b/arch/arm/mach-omap2/cpuidle44xx.c | ||
131 | index c443f2e97e10..f98410a257e3 100644 | ||
132 | --- a/arch/arm/mach-omap2/cpuidle44xx.c | ||
133 | +++ b/arch/arm/mach-omap2/cpuidle44xx.c | ||
134 | @@ -14,6 +14,7 @@ | ||
135 | #include <linux/cpuidle.h> | ||
136 | #include <linux/cpu_pm.h> | ||
137 | #include <linux/export.h> | ||
138 | +#include <linux/clockchips.h> | ||
139 | |||
140 | #include <asm/cpuidle.h> | ||
141 | #include <asm/proc-fns.h> | ||
142 | @@ -80,6 +81,7 @@ static int omap_enter_idle_coupled(struct cpuidle_device *dev, | ||
143 | int index) | ||
144 | { | ||
145 | struct idle_statedata *cx = state_ptr + index; | ||
146 | + int cpu_id = smp_processor_id(); | ||
147 | |||
148 | /* | ||
149 | * CPU0 has to wait and stay ON until CPU1 is OFF state. | ||
150 | @@ -104,6 +106,8 @@ static int omap_enter_idle_coupled(struct cpuidle_device *dev, | ||
151 | } | ||
152 | } | ||
153 | |||
154 | + clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &cpu_id); | ||
155 | + | ||
156 | /* | ||
157 | * Call idle CPU PM enter notifier chain so that | ||
158 | * VFP and per CPU interrupt context is saved. | ||
159 | @@ -147,6 +151,8 @@ static int omap_enter_idle_coupled(struct cpuidle_device *dev, | ||
160 | (cx->mpu_logic_state == PWRDM_POWER_OFF)) | ||
161 | cpu_cluster_pm_exit(); | ||
162 | |||
163 | + clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &cpu_id); | ||
164 | + | ||
165 | fail: | ||
166 | cpuidle_coupled_parallel_barrier(dev, &abort_barrier); | ||
167 | cpu_done[dev->cpu] = false; | ||
168 | @@ -154,6 +160,16 @@ fail: | ||
169 | return index; | ||
170 | } | ||
171 | |||
172 | +/* | ||
173 | + * For each cpu, setup the broadcast timer because local timers | ||
174 | + * stops for the states above C1. | ||
175 | + */ | ||
176 | +static void omap_setup_broadcast_timer(void *arg) | ||
177 | +{ | ||
178 | + int cpu = smp_processor_id(); | ||
179 | + clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ON, &cpu); | ||
180 | +} | ||
181 | + | ||
182 | static struct cpuidle_driver omap4_idle_driver = { | ||
183 | .name = "omap4_idle", | ||
184 | .owner = THIS_MODULE, | ||
185 | @@ -171,8 +187,7 @@ static struct cpuidle_driver omap4_idle_driver = { | ||
186 | /* C2 - CPU0 OFF + CPU1 OFF + MPU CSWR */ | ||
187 | .exit_latency = 328 + 440, | ||
188 | .target_residency = 960, | ||
189 | - .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_COUPLED | | ||
190 | - CPUIDLE_FLAG_TIMER_STOP, | ||
191 | + .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_COUPLED, | ||
192 | .enter = omap_enter_idle_coupled, | ||
193 | .name = "C2", | ||
194 | .desc = "CPUx OFF, MPUSS CSWR", | ||
195 | @@ -181,8 +196,7 @@ static struct cpuidle_driver omap4_idle_driver = { | ||
196 | /* C3 - CPU0 OFF + CPU1 OFF + MPU OSWR */ | ||
197 | .exit_latency = 460 + 518, | ||
198 | .target_residency = 1100, | ||
199 | - .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_COUPLED | | ||
200 | - CPUIDLE_FLAG_TIMER_STOP, | ||
201 | + .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_COUPLED, | ||
202 | .enter = omap_enter_idle_coupled, | ||
203 | .name = "C3", | ||
204 | .desc = "CPUx OFF, MPUSS OSWR", | ||
205 | @@ -213,5 +227,8 @@ int __init omap4_idle_init(void) | ||
206 | if (!cpu_clkdm[0] || !cpu_clkdm[1]) | ||
207 | return -ENODEV; | ||
208 | |||
209 | + /* Configure the broadcast timer on each cpu */ | ||
210 | + on_each_cpu(omap_setup_broadcast_timer, NULL, 1); | ||
211 | + | ||
212 | return cpuidle_register(&omap4_idle_driver, cpu_online_mask); | ||
213 | } | ||
214 | diff --git a/arch/x86/kernel/cpu/perf_event.c b/arch/x86/kernel/cpu/perf_event.c | ||
215 | index a69b67d968d4..123d9e2271dc 100644 | ||
216 | --- a/arch/x86/kernel/cpu/perf_event.c | ||
217 | +++ b/arch/x86/kernel/cpu/perf_event.c | ||
218 | @@ -1252,10 +1252,20 @@ void perf_events_lapic_init(void) | ||
219 | static int __kprobes | ||
220 | perf_event_nmi_handler(unsigned int cmd, struct pt_regs *regs) | ||
221 | { | ||
222 | + int ret; | ||
223 | + u64 start_clock; | ||
224 | + u64 finish_clock; | ||
225 | + | ||
226 | if (!atomic_read(&active_events)) | ||
227 | return NMI_DONE; | ||
228 | |||
229 | - return x86_pmu.handle_irq(regs); | ||
230 | + start_clock = local_clock(); | ||
231 | + ret = x86_pmu.handle_irq(regs); | ||
232 | + finish_clock = local_clock(); | ||
233 | + | ||
234 | + perf_sample_event_took(finish_clock - start_clock); | ||
235 | + | ||
236 | + return ret; | ||
237 | } | ||
238 | |||
239 | struct event_constraint emptyconstraint; | ||
240 | diff --git a/drivers/gpu/drm/i915/i915_gem_execbuffer.c b/drivers/gpu/drm/i915/i915_gem_execbuffer.c | ||
241 | index 117ce3813681..6416d0d07394 100644 | ||
242 | --- a/drivers/gpu/drm/i915/i915_gem_execbuffer.c | ||
243 | +++ b/drivers/gpu/drm/i915/i915_gem_execbuffer.c | ||
244 | @@ -635,9 +635,9 @@ i915_gem_execbuffer_relocate_slow(struct drm_device *dev, | ||
245 | * relocations were valid. | ||
246 | */ | ||
247 | for (j = 0; j < exec[i].relocation_count; j++) { | ||
248 | - if (copy_to_user(&user_relocs[j].presumed_offset, | ||
249 | - &invalid_offset, | ||
250 | - sizeof(invalid_offset))) { | ||
251 | + if (__copy_to_user(&user_relocs[j].presumed_offset, | ||
252 | + &invalid_offset, | ||
253 | + sizeof(invalid_offset))) { | ||
254 | ret = -EFAULT; | ||
255 | mutex_lock(&dev->struct_mutex); | ||
256 | goto err; | ||
257 | @@ -1151,18 +1151,21 @@ i915_gem_execbuffer(struct drm_device *dev, void *data, | ||
258 | |||
259 | ret = i915_gem_do_execbuffer(dev, data, file, &exec2, exec2_list); | ||
260 | if (!ret) { | ||
261 | + struct drm_i915_gem_exec_object __user *user_exec_list = | ||
262 | + to_user_ptr(args->buffers_ptr); | ||
263 | + | ||
264 | /* Copy the new buffer offsets back to the user's exec list. */ | ||
265 | - for (i = 0; i < args->buffer_count; i++) | ||
266 | - exec_list[i].offset = exec2_list[i].offset; | ||
267 | - /* ... and back out to userspace */ | ||
268 | - ret = copy_to_user(to_user_ptr(args->buffers_ptr), | ||
269 | - exec_list, | ||
270 | - sizeof(*exec_list) * args->buffer_count); | ||
271 | - if (ret) { | ||
272 | - ret = -EFAULT; | ||
273 | - DRM_DEBUG("failed to copy %d exec entries " | ||
274 | - "back to user (%d)\n", | ||
275 | - args->buffer_count, ret); | ||
276 | + for (i = 0; i < args->buffer_count; i++) { | ||
277 | + ret = __copy_to_user(&user_exec_list[i].offset, | ||
278 | + &exec2_list[i].offset, | ||
279 | + sizeof(user_exec_list[i].offset)); | ||
280 | + if (ret) { | ||
281 | + ret = -EFAULT; | ||
282 | + DRM_DEBUG("failed to copy %d exec entries " | ||
283 | + "back to user (%d)\n", | ||
284 | + args->buffer_count, ret); | ||
285 | + break; | ||
286 | + } | ||
287 | } | ||
288 | } | ||
289 | |||
290 | @@ -1208,14 +1211,21 @@ i915_gem_execbuffer2(struct drm_device *dev, void *data, | ||
291 | ret = i915_gem_do_execbuffer(dev, data, file, args, exec2_list); | ||
292 | if (!ret) { | ||
293 | /* Copy the new buffer offsets back to the user's exec list. */ | ||
294 | - ret = copy_to_user(to_user_ptr(args->buffers_ptr), | ||
295 | - exec2_list, | ||
296 | - sizeof(*exec2_list) * args->buffer_count); | ||
297 | - if (ret) { | ||
298 | - ret = -EFAULT; | ||
299 | - DRM_DEBUG("failed to copy %d exec entries " | ||
300 | - "back to user (%d)\n", | ||
301 | - args->buffer_count, ret); | ||
302 | + struct drm_i915_gem_exec_object2 *user_exec_list = | ||
303 | + to_user_ptr(args->buffers_ptr); | ||
304 | + int i; | ||
305 | + | ||
306 | + for (i = 0; i < args->buffer_count; i++) { | ||
307 | + ret = __copy_to_user(&user_exec_list[i].offset, | ||
308 | + &exec2_list[i].offset, | ||
309 | + sizeof(user_exec_list[i].offset)); | ||
310 | + if (ret) { | ||
311 | + ret = -EFAULT; | ||
312 | + DRM_DEBUG("failed to copy %d exec entries " | ||
313 | + "back to user\n", | ||
314 | + args->buffer_count); | ||
315 | + break; | ||
316 | + } | ||
317 | } | ||
318 | } | ||
319 | |||
320 | diff --git a/drivers/gpu/drm/nouveau/core/engine/disp/nvd0.c b/drivers/gpu/drm/nouveau/core/engine/disp/nvd0.c | ||
321 | index 019eacd8a68f..9ee40042fa3a 100644 | ||
322 | --- a/drivers/gpu/drm/nouveau/core/engine/disp/nvd0.c | ||
323 | +++ b/drivers/gpu/drm/nouveau/core/engine/disp/nvd0.c | ||
324 | @@ -679,7 +679,7 @@ exec_clkcmp(struct nv50_disp_priv *priv, int head, int id, | ||
325 | } | ||
326 | |||
327 | if (outp == 8) | ||
328 | - return false; | ||
329 | + return conf; | ||
330 | |||
331 | data = exec_lookup(priv, head, outp, ctrl, dcb, &ver, &hdr, &cnt, &len, &info1); | ||
332 | if (data == 0x0000) | ||
333 | diff --git a/drivers/gpu/drm/radeon/radeon_bios.c b/drivers/gpu/drm/radeon/radeon_bios.c | ||
334 | index 061b227dae0c..b131520521e4 100644 | ||
335 | --- a/drivers/gpu/drm/radeon/radeon_bios.c | ||
336 | +++ b/drivers/gpu/drm/radeon/radeon_bios.c | ||
337 | @@ -196,6 +196,20 @@ static bool radeon_atrm_get_bios(struct radeon_device *rdev) | ||
338 | } | ||
339 | } | ||
340 | |||
341 | + if (!found) { | ||
342 | + while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_OTHER << 8, pdev)) != NULL) { | ||
343 | + dhandle = ACPI_HANDLE(&pdev->dev); | ||
344 | + if (!dhandle) | ||
345 | + continue; | ||
346 | + | ||
347 | + status = acpi_get_handle(dhandle, "ATRM", &atrm_handle); | ||
348 | + if (!ACPI_FAILURE(status)) { | ||
349 | + found = true; | ||
350 | + break; | ||
351 | + } | ||
352 | + } | ||
353 | + } | ||
354 | + | ||
355 | if (!found) | ||
356 | return false; | ||
357 | |||
358 | diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c | ||
359 | index 1424ccde2377..f83727915787 100644 | ||
360 | --- a/drivers/gpu/drm/radeon/radeon_object.c | ||
361 | +++ b/drivers/gpu/drm/radeon/radeon_object.c | ||
362 | @@ -582,22 +582,30 @@ int radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo) | ||
363 | rbo = container_of(bo, struct radeon_bo, tbo); | ||
364 | radeon_bo_check_tiling(rbo, 0, 0); | ||
365 | rdev = rbo->rdev; | ||
366 | - if (bo->mem.mem_type == TTM_PL_VRAM) { | ||
367 | - size = bo->mem.num_pages << PAGE_SHIFT; | ||
368 | - offset = bo->mem.start << PAGE_SHIFT; | ||
369 | - if ((offset + size) > rdev->mc.visible_vram_size) { | ||
370 | - /* hurrah the memory is not visible ! */ | ||
371 | - radeon_ttm_placement_from_domain(rbo, RADEON_GEM_DOMAIN_VRAM); | ||
372 | - rbo->placement.lpfn = rdev->mc.visible_vram_size >> PAGE_SHIFT; | ||
373 | - r = ttm_bo_validate(bo, &rbo->placement, false, false); | ||
374 | - if (unlikely(r != 0)) | ||
375 | - return r; | ||
376 | - offset = bo->mem.start << PAGE_SHIFT; | ||
377 | - /* this should not happen */ | ||
378 | - if ((offset + size) > rdev->mc.visible_vram_size) | ||
379 | - return -EINVAL; | ||
380 | - } | ||
381 | + if (bo->mem.mem_type != TTM_PL_VRAM) | ||
382 | + return 0; | ||
383 | + | ||
384 | + size = bo->mem.num_pages << PAGE_SHIFT; | ||
385 | + offset = bo->mem.start << PAGE_SHIFT; | ||
386 | + if ((offset + size) <= rdev->mc.visible_vram_size) | ||
387 | + return 0; | ||
388 | + | ||
389 | + /* hurrah the memory is not visible ! */ | ||
390 | + radeon_ttm_placement_from_domain(rbo, RADEON_GEM_DOMAIN_VRAM); | ||
391 | + rbo->placement.lpfn = rdev->mc.visible_vram_size >> PAGE_SHIFT; | ||
392 | + r = ttm_bo_validate(bo, &rbo->placement, false, false); | ||
393 | + if (unlikely(r == -ENOMEM)) { | ||
394 | + radeon_ttm_placement_from_domain(rbo, RADEON_GEM_DOMAIN_GTT); | ||
395 | + return ttm_bo_validate(bo, &rbo->placement, false, false); | ||
396 | + } else if (unlikely(r != 0)) { | ||
397 | + return r; | ||
398 | } | ||
399 | + | ||
400 | + offset = bo->mem.start << PAGE_SHIFT; | ||
401 | + /* this should never happen */ | ||
402 | + if ((offset + size) > rdev->mc.visible_vram_size) | ||
403 | + return -EINVAL; | ||
404 | + | ||
405 | return 0; | ||
406 | } | ||
407 | |||
408 | diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig | ||
409 | index df064e8cd9dc..f25f29835b3e 100644 | ||
410 | --- a/drivers/hwmon/Kconfig | ||
411 | +++ b/drivers/hwmon/Kconfig | ||
412 | @@ -944,7 +944,7 @@ config SENSORS_NCT6775 | ||
413 | |||
414 | config SENSORS_NTC_THERMISTOR | ||
415 | tristate "NTC thermistor support" | ||
416 | - depends on (!OF && !IIO) || (OF && IIO) | ||
417 | + depends on !OF || IIO=n || IIO | ||
418 | help | ||
419 | This driver supports NTC thermistors sensor reading and its | ||
420 | interpretation. The driver can also monitor the temperature and | ||
421 | diff --git a/drivers/hwmon/ntc_thermistor.c b/drivers/hwmon/ntc_thermistor.c | ||
422 | index 9297164a23a5..c64d3d497c50 100644 | ||
423 | --- a/drivers/hwmon/ntc_thermistor.c | ||
424 | +++ b/drivers/hwmon/ntc_thermistor.c | ||
425 | @@ -44,6 +44,7 @@ struct ntc_compensation { | ||
426 | unsigned int ohm; | ||
427 | }; | ||
428 | |||
429 | +/* Order matters, ntc_match references the entries by index */ | ||
430 | static const struct platform_device_id ntc_thermistor_id[] = { | ||
431 | { "ncp15wb473", TYPE_NCPXXWB473 }, | ||
432 | { "ncp18wb473", TYPE_NCPXXWB473 }, | ||
433 | @@ -141,7 +142,7 @@ struct ntc_data { | ||
434 | char name[PLATFORM_NAME_SIZE]; | ||
435 | }; | ||
436 | |||
437 | -#ifdef CONFIG_OF | ||
438 | +#if defined(CONFIG_OF) && IS_ENABLED(CONFIG_IIO) | ||
439 | static int ntc_adc_iio_read(struct ntc_thermistor_platform_data *pdata) | ||
440 | { | ||
441 | struct iio_channel *channel = pdata->chan; | ||
442 | @@ -163,15 +164,15 @@ static int ntc_adc_iio_read(struct ntc_thermistor_platform_data *pdata) | ||
443 | |||
444 | static const struct of_device_id ntc_match[] = { | ||
445 | { .compatible = "ntc,ncp15wb473", | ||
446 | - .data = &ntc_thermistor_id[TYPE_NCPXXWB473] }, | ||
447 | + .data = &ntc_thermistor_id[0] }, | ||
448 | { .compatible = "ntc,ncp18wb473", | ||
449 | - .data = &ntc_thermistor_id[TYPE_NCPXXWB473] }, | ||
450 | + .data = &ntc_thermistor_id[1] }, | ||
451 | { .compatible = "ntc,ncp21wb473", | ||
452 | - .data = &ntc_thermistor_id[TYPE_NCPXXWB473] }, | ||
453 | + .data = &ntc_thermistor_id[2] }, | ||
454 | { .compatible = "ntc,ncp03wb473", | ||
455 | - .data = &ntc_thermistor_id[TYPE_NCPXXWB473] }, | ||
456 | + .data = &ntc_thermistor_id[3] }, | ||
457 | { .compatible = "ntc,ncp15wl333", | ||
458 | - .data = &ntc_thermistor_id[TYPE_NCPXXWL333] }, | ||
459 | + .data = &ntc_thermistor_id[4] }, | ||
460 | { }, | ||
461 | }; | ||
462 | MODULE_DEVICE_TABLE(of, ntc_match); | ||
463 | @@ -223,6 +224,8 @@ ntc_thermistor_parse_dt(struct platform_device *pdev) | ||
464 | return NULL; | ||
465 | } | ||
466 | |||
467 | +#define ntc_match NULL | ||
468 | + | ||
469 | static void ntc_iio_channel_release(struct ntc_thermistor_platform_data *pdata) | ||
470 | { } | ||
471 | #endif | ||
472 | diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c | ||
473 | index 988e29d18bb4..bae20f8bb034 100644 | ||
474 | --- a/drivers/infiniband/ulp/isert/ib_isert.c | ||
475 | +++ b/drivers/infiniband/ulp/isert/ib_isert.c | ||
476 | @@ -965,6 +965,8 @@ sequence_cmd: | ||
477 | |||
478 | if (!rc && dump_payload == false && unsol_data) | ||
479 | iscsit_set_unsoliticed_dataout(cmd); | ||
480 | + else if (dump_payload && imm_data) | ||
481 | + target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd); | ||
482 | |||
483 | return 0; | ||
484 | } | ||
485 | diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c | ||
486 | index 1a75869d3a82..677973641d2b 100644 | ||
487 | --- a/drivers/md/dm-cache-target.c | ||
488 | +++ b/drivers/md/dm-cache-target.c | ||
489 | @@ -1954,6 +1954,8 @@ static int cache_create(struct cache_args *ca, struct cache **result) | ||
490 | ti->num_discard_bios = 1; | ||
491 | ti->discards_supported = true; | ||
492 | ti->discard_zeroes_data_unsupported = true; | ||
493 | + /* Discard bios must be split on a block boundary */ | ||
494 | + ti->split_discard_bios = true; | ||
495 | |||
496 | cache->features = ca->features; | ||
497 | ti->per_bio_data_size = get_per_bio_data_size(cache); | ||
498 | diff --git a/drivers/md/md.c b/drivers/md/md.c | ||
499 | index 00a99fe797d4..963fa59be9b3 100644 | ||
500 | --- a/drivers/md/md.c | ||
501 | +++ b/drivers/md/md.c | ||
502 | @@ -7338,8 +7338,10 @@ void md_do_sync(struct md_thread *thread) | ||
503 | /* just incase thread restarts... */ | ||
504 | if (test_bit(MD_RECOVERY_DONE, &mddev->recovery)) | ||
505 | return; | ||
506 | - if (mddev->ro) /* never try to sync a read-only array */ | ||
507 | + if (mddev->ro) {/* never try to sync a read-only array */ | ||
508 | + set_bit(MD_RECOVERY_INTR, &mddev->recovery); | ||
509 | return; | ||
510 | + } | ||
511 | |||
512 | if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { | ||
513 | if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) | ||
514 | @@ -7788,6 +7790,7 @@ void md_check_recovery(struct mddev *mddev) | ||
515 | /* There is no thread, but we need to call | ||
516 | * ->spare_active and clear saved_raid_disk | ||
517 | */ | ||
518 | + set_bit(MD_RECOVERY_INTR, &mddev->recovery); | ||
519 | md_reap_sync_thread(mddev); | ||
520 | clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery); | ||
521 | goto unlock; | ||
522 | diff --git a/drivers/staging/comedi/drivers/ni_daq_700.c b/drivers/staging/comedi/drivers/ni_daq_700.c | ||
523 | index d067ef70e194..5e80d428e544 100644 | ||
524 | --- a/drivers/staging/comedi/drivers/ni_daq_700.c | ||
525 | +++ b/drivers/staging/comedi/drivers/ni_daq_700.c | ||
526 | @@ -127,6 +127,8 @@ static int daq700_ai_rinsn(struct comedi_device *dev, | ||
527 | /* write channel to multiplexer */ | ||
528 | /* set mask scan bit high to disable scanning */ | ||
529 | outb(chan | 0x80, dev->iobase + CMD_R1); | ||
530 | + /* mux needs 2us to really settle [Fred Brooks]. */ | ||
531 | + udelay(2); | ||
532 | |||
533 | /* convert n samples */ | ||
534 | for (n = 0; n < insn->n; n++) { | ||
535 | diff --git a/drivers/staging/speakup/main.c b/drivers/staging/speakup/main.c | ||
536 | index 6c7b55c2947d..e70a48e3b376 100644 | ||
537 | --- a/drivers/staging/speakup/main.c | ||
538 | +++ b/drivers/staging/speakup/main.c | ||
539 | @@ -2219,6 +2219,7 @@ static void __exit speakup_exit(void) | ||
540 | unregister_keyboard_notifier(&keyboard_notifier_block); | ||
541 | unregister_vt_notifier(&vt_notifier_block); | ||
542 | speakup_unregister_devsynth(); | ||
543 | + speakup_cancel_paste(); | ||
544 | del_timer(&cursor_timer); | ||
545 | kthread_stop(speakup_task); | ||
546 | speakup_task = NULL; | ||
547 | diff --git a/drivers/staging/speakup/selection.c b/drivers/staging/speakup/selection.c | ||
548 | index f0fb00392d6b..f67941e78e4a 100644 | ||
549 | --- a/drivers/staging/speakup/selection.c | ||
550 | +++ b/drivers/staging/speakup/selection.c | ||
551 | @@ -4,6 +4,8 @@ | ||
552 | #include <linux/sched.h> | ||
553 | #include <linux/device.h> /* for dev_warn */ | ||
554 | #include <linux/selection.h> | ||
555 | +#include <linux/workqueue.h> | ||
556 | +#include <asm/cmpxchg.h> | ||
557 | |||
558 | #include "speakup.h" | ||
559 | |||
560 | @@ -121,20 +123,24 @@ int speakup_set_selection(struct tty_struct *tty) | ||
561 | return 0; | ||
562 | } | ||
563 | |||
564 | -/* TODO: move to some helper thread, probably. That'd fix having to check for | ||
565 | - * in_atomic(). */ | ||
566 | -int speakup_paste_selection(struct tty_struct *tty) | ||
567 | +struct speakup_paste_work { | ||
568 | + struct work_struct work; | ||
569 | + struct tty_struct *tty; | ||
570 | +}; | ||
571 | + | ||
572 | +static void __speakup_paste_selection(struct work_struct *work) | ||
573 | { | ||
574 | + struct speakup_paste_work *spw = | ||
575 | + container_of(work, struct speakup_paste_work, work); | ||
576 | + struct tty_struct *tty = xchg(&spw->tty, NULL); | ||
577 | struct vc_data *vc = (struct vc_data *) tty->driver_data; | ||
578 | int pasted = 0, count; | ||
579 | DECLARE_WAITQUEUE(wait, current); | ||
580 | + | ||
581 | add_wait_queue(&vc->paste_wait, &wait); | ||
582 | while (sel_buffer && sel_buffer_lth > pasted) { | ||
583 | set_current_state(TASK_INTERRUPTIBLE); | ||
584 | if (test_bit(TTY_THROTTLED, &tty->flags)) { | ||
585 | - if (in_atomic()) | ||
586 | - /* if we are in an interrupt handler, abort */ | ||
587 | - break; | ||
588 | schedule(); | ||
589 | continue; | ||
590 | } | ||
591 | @@ -146,6 +152,26 @@ int speakup_paste_selection(struct tty_struct *tty) | ||
592 | } | ||
593 | remove_wait_queue(&vc->paste_wait, &wait); | ||
594 | current->state = TASK_RUNNING; | ||
595 | + tty_kref_put(tty); | ||
596 | +} | ||
597 | + | ||
598 | +static struct speakup_paste_work speakup_paste_work = { | ||
599 | + .work = __WORK_INITIALIZER(speakup_paste_work.work, | ||
600 | + __speakup_paste_selection) | ||
601 | +}; | ||
602 | + | ||
603 | +int speakup_paste_selection(struct tty_struct *tty) | ||
604 | +{ | ||
605 | + if (cmpxchg(&speakup_paste_work.tty, NULL, tty) != NULL) | ||
606 | + return -EBUSY; | ||
607 | + | ||
608 | + tty_kref_get(tty); | ||
609 | + schedule_work_on(WORK_CPU_UNBOUND, &speakup_paste_work.work); | ||
610 | return 0; | ||
611 | } | ||
612 | |||
613 | +void speakup_cancel_paste(void) | ||
614 | +{ | ||
615 | + cancel_work_sync(&speakup_paste_work.work); | ||
616 | + tty_kref_put(speakup_paste_work.tty); | ||
617 | +} | ||
618 | diff --git a/drivers/staging/speakup/speakup.h b/drivers/staging/speakup/speakup.h | ||
619 | index 0126f714821a..74fe72429b2d 100644 | ||
620 | --- a/drivers/staging/speakup/speakup.h | ||
621 | +++ b/drivers/staging/speakup/speakup.h | ||
622 | @@ -77,6 +77,7 @@ extern void synth_buffer_clear(void); | ||
623 | extern void speakup_clear_selection(void); | ||
624 | extern int speakup_set_selection(struct tty_struct *tty); | ||
625 | extern int speakup_paste_selection(struct tty_struct *tty); | ||
626 | +extern void speakup_cancel_paste(void); | ||
627 | extern void speakup_register_devsynth(void); | ||
628 | extern void speakup_unregister_devsynth(void); | ||
629 | extern void synth_write(const char *buf, size_t count); | ||
630 | diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c | ||
631 | index 4ed35231e552..2cdd5079ae78 100644 | ||
632 | --- a/drivers/usb/core/driver.c | ||
633 | +++ b/drivers/usb/core/driver.c | ||
634 | @@ -1754,10 +1754,13 @@ int usb_runtime_suspend(struct device *dev) | ||
635 | if (status == -EAGAIN || status == -EBUSY) | ||
636 | usb_mark_last_busy(udev); | ||
637 | |||
638 | - /* The PM core reacts badly unless the return code is 0, | ||
639 | - * -EAGAIN, or -EBUSY, so always return -EBUSY on an error. | ||
640 | + /* | ||
641 | + * The PM core reacts badly unless the return code is 0, | ||
642 | + * -EAGAIN, or -EBUSY, so always return -EBUSY on an error | ||
643 | + * (except for root hubs, because they don't suspend through | ||
644 | + * an upstream port like other USB devices). | ||
645 | */ | ||
646 | - if (status != 0) | ||
647 | + if (status != 0 && udev->parent) | ||
648 | return -EBUSY; | ||
649 | return status; | ||
650 | } | ||
651 | diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c | ||
652 | index a036e03ae1b3..46efdca96952 100644 | ||
653 | --- a/drivers/usb/core/hub.c | ||
654 | +++ b/drivers/usb/core/hub.c | ||
655 | @@ -1683,8 +1683,19 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id) | ||
656 | */ | ||
657 | pm_runtime_set_autosuspend_delay(&hdev->dev, 0); | ||
658 | |||
659 | - /* Hubs have proper suspend/resume support. */ | ||
660 | - usb_enable_autosuspend(hdev); | ||
661 | + /* | ||
662 | + * Hubs have proper suspend/resume support, except for root hubs | ||
663 | + * where the controller driver doesn't have bus_suspend and | ||
664 | + * bus_resume methods. | ||
665 | + */ | ||
666 | + if (hdev->parent) { /* normal device */ | ||
667 | + usb_enable_autosuspend(hdev); | ||
668 | + } else { /* root hub */ | ||
669 | + const struct hc_driver *drv = bus_to_hcd(hdev->bus)->driver; | ||
670 | + | ||
671 | + if (drv->bus_suspend && drv->bus_resume) | ||
672 | + usb_enable_autosuspend(hdev); | ||
673 | + } | ||
674 | |||
675 | if (hdev->level == MAX_TOPO_LEVEL) { | ||
676 | dev_err(&intf->dev, | ||
677 | diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c | ||
678 | index f2e57a1112c9..d007f0920126 100644 | ||
679 | --- a/drivers/usb/host/xhci-mem.c | ||
680 | +++ b/drivers/usb/host/xhci-mem.c | ||
681 | @@ -1794,6 +1794,16 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci) | ||
682 | kfree(cur_cd); | ||
683 | } | ||
684 | |||
685 | + num_ports = HCS_MAX_PORTS(xhci->hcs_params1); | ||
686 | + for (i = 0; i < num_ports; i++) { | ||
687 | + struct xhci_interval_bw_table *bwt = &xhci->rh_bw[i].bw_table; | ||
688 | + for (j = 0; j < XHCI_MAX_INTERVAL; j++) { | ||
689 | + struct list_head *ep = &bwt->interval_bw[j].endpoints; | ||
690 | + while (!list_empty(ep)) | ||
691 | + list_del_init(ep->next); | ||
692 | + } | ||
693 | + } | ||
694 | + | ||
695 | for (i = 1; i < MAX_HC_SLOTS; ++i) | ||
696 | xhci_free_virt_device(xhci, i); | ||
697 | |||
698 | @@ -1834,16 +1844,6 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci) | ||
699 | if (!xhci->rh_bw) | ||
700 | goto no_bw; | ||
701 | |||
702 | - num_ports = HCS_MAX_PORTS(xhci->hcs_params1); | ||
703 | - for (i = 0; i < num_ports; i++) { | ||
704 | - struct xhci_interval_bw_table *bwt = &xhci->rh_bw[i].bw_table; | ||
705 | - for (j = 0; j < XHCI_MAX_INTERVAL; j++) { | ||
706 | - struct list_head *ep = &bwt->interval_bw[j].endpoints; | ||
707 | - while (!list_empty(ep)) | ||
708 | - list_del_init(ep->next); | ||
709 | - } | ||
710 | - } | ||
711 | - | ||
712 | for (i = 0; i < num_ports; i++) { | ||
713 | struct xhci_tt_bw_info *tt, *n; | ||
714 | list_for_each_entry_safe(tt, n, &xhci->rh_bw[i].tts, tt_list) { | ||
715 | diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c | ||
716 | index 2c635bd9c185..b9e663ac9a35 100644 | ||
717 | --- a/drivers/usb/serial/ftdi_sio.c | ||
718 | +++ b/drivers/usb/serial/ftdi_sio.c | ||
719 | @@ -583,6 +583,8 @@ static struct usb_device_id id_table_combined [] = { | ||
720 | { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) }, | ||
721 | { USB_DEVICE(FTDI_VID, FTDI_TIAO_UMPA_PID), | ||
722 | .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk }, | ||
723 | + { USB_DEVICE(FTDI_VID, FTDI_NT_ORIONLXM_PID), | ||
724 | + .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk }, | ||
725 | /* | ||
726 | * ELV devices: | ||
727 | */ | ||
728 | diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h | ||
729 | index 993c93df6874..500474c48f4b 100644 | ||
730 | --- a/drivers/usb/serial/ftdi_sio_ids.h | ||
731 | +++ b/drivers/usb/serial/ftdi_sio_ids.h | ||
732 | @@ -538,6 +538,11 @@ | ||
733 | */ | ||
734 | #define FTDI_TIAO_UMPA_PID 0x8a98 /* TIAO/DIYGADGET USB Multi-Protocol Adapter */ | ||
735 | |||
736 | +/* | ||
737 | + * NovaTech product ids (FTDI_VID) | ||
738 | + */ | ||
739 | +#define FTDI_NT_ORIONLXM_PID 0x7c90 /* OrionLXm Substation Automation Platform */ | ||
740 | + | ||
741 | |||
742 | /********************************/ | ||
743 | /** third-party VID/PID combos **/ | ||
744 | diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c | ||
745 | index c5c9cbf107d1..8cd6479a8b43 100644 | ||
746 | --- a/drivers/usb/serial/io_ti.c | ||
747 | +++ b/drivers/usb/serial/io_ti.c | ||
748 | @@ -835,7 +835,7 @@ static int build_i2c_fw_hdr(__u8 *header, struct device *dev) | ||
749 | firmware_rec = (struct ti_i2c_firmware_rec*)i2c_header->Data; | ||
750 | |||
751 | i2c_header->Type = I2C_DESC_TYPE_FIRMWARE_BLANK; | ||
752 | - i2c_header->Size = (__u16)buffer_size; | ||
753 | + i2c_header->Size = cpu_to_le16(buffer_size); | ||
754 | i2c_header->CheckSum = cs; | ||
755 | firmware_rec->Ver_Major = OperationalMajorVersion; | ||
756 | firmware_rec->Ver_Minor = OperationalMinorVersion; | ||
757 | diff --git a/drivers/usb/serial/io_usbvend.h b/drivers/usb/serial/io_usbvend.h | ||
758 | index 51f83fbb73bb..6f6a856bc37c 100644 | ||
759 | --- a/drivers/usb/serial/io_usbvend.h | ||
760 | +++ b/drivers/usb/serial/io_usbvend.h | ||
761 | @@ -594,7 +594,7 @@ struct edge_boot_descriptor { | ||
762 | |||
763 | struct ti_i2c_desc { | ||
764 | __u8 Type; // Type of descriptor | ||
765 | - __u16 Size; // Size of data only not including header | ||
766 | + __le16 Size; // Size of data only not including header | ||
767 | __u8 CheckSum; // Checksum (8 bit sum of data only) | ||
768 | __u8 Data[0]; // Data starts here | ||
769 | } __attribute__((packed)); | ||
770 | diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c | ||
771 | index f213ee978516..948a19f0cdf7 100644 | ||
772 | --- a/drivers/usb/serial/option.c | ||
773 | +++ b/drivers/usb/serial/option.c | ||
774 | @@ -161,6 +161,7 @@ static void option_instat_callback(struct urb *urb); | ||
775 | #define NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_FULLSPEED 0x9000 | ||
776 | #define NOVATELWIRELESS_PRODUCT_HSPA_EMBEDDED_HIGHSPEED 0x9001 | ||
777 | #define NOVATELWIRELESS_PRODUCT_E362 0x9010 | ||
778 | +#define NOVATELWIRELESS_PRODUCT_E371 0x9011 | ||
779 | #define NOVATELWIRELESS_PRODUCT_G2 0xA010 | ||
780 | #define NOVATELWIRELESS_PRODUCT_MC551 0xB001 | ||
781 | |||
782 | @@ -1012,6 +1013,7 @@ static const struct usb_device_id option_ids[] = { | ||
783 | /* Novatel Ovation MC551 a.k.a. Verizon USB551L */ | ||
784 | { USB_DEVICE_AND_INTERFACE_INFO(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_MC551, 0xff, 0xff, 0xff) }, | ||
785 | { USB_DEVICE_AND_INTERFACE_INFO(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_E362, 0xff, 0xff, 0xff) }, | ||
786 | + { USB_DEVICE_AND_INTERFACE_INFO(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_E371, 0xff, 0xff, 0xff) }, | ||
787 | |||
788 | { USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_H01) }, | ||
789 | { USB_DEVICE(AMOI_VENDOR_ID, AMOI_PRODUCT_H01A) }, | ||
790 | diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h | ||
791 | index c5b6dbf9c2fc..229a757e1c13 100644 | ||
792 | --- a/include/linux/perf_event.h | ||
793 | +++ b/include/linux/perf_event.h | ||
794 | @@ -695,10 +695,17 @@ static inline void perf_callchain_store(struct perf_callchain_entry *entry, u64 | ||
795 | extern int sysctl_perf_event_paranoid; | ||
796 | extern int sysctl_perf_event_mlock; | ||
797 | extern int sysctl_perf_event_sample_rate; | ||
798 | +extern int sysctl_perf_cpu_time_max_percent; | ||
799 | + | ||
800 | +extern void perf_sample_event_took(u64 sample_len_ns); | ||
801 | |||
802 | extern int perf_proc_update_handler(struct ctl_table *table, int write, | ||
803 | void __user *buffer, size_t *lenp, | ||
804 | loff_t *ppos); | ||
805 | +extern int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write, | ||
806 | + void __user *buffer, size_t *lenp, | ||
807 | + loff_t *ppos); | ||
808 | + | ||
809 | |||
810 | static inline bool perf_paranoid_tracepoint_raw(void) | ||
811 | { | ||
812 | diff --git a/include/uapi/linux/usb/Kbuild b/include/uapi/linux/usb/Kbuild | ||
813 | index 6cb4ea826834..4cc4d6e7e523 100644 | ||
814 | --- a/include/uapi/linux/usb/Kbuild | ||
815 | +++ b/include/uapi/linux/usb/Kbuild | ||
816 | @@ -1,6 +1,7 @@ | ||
817 | # UAPI Header export list | ||
818 | header-y += audio.h | ||
819 | header-y += cdc.h | ||
820 | +header-y += cdc-wdm.h | ||
821 | header-y += ch11.h | ||
822 | header-y += ch9.h | ||
823 | header-y += functionfs.h | ||
824 | diff --git a/include/uapi/linux/usb/cdc-wdm.h b/include/uapi/linux/usb/cdc-wdm.h | ||
825 | index f03134feebd6..0dc132e75030 100644 | ||
826 | --- a/include/uapi/linux/usb/cdc-wdm.h | ||
827 | +++ b/include/uapi/linux/usb/cdc-wdm.h | ||
828 | @@ -9,6 +9,8 @@ | ||
829 | #ifndef _UAPI__LINUX_USB_CDC_WDM_H | ||
830 | #define _UAPI__LINUX_USB_CDC_WDM_H | ||
831 | |||
832 | +#include <linux/types.h> | ||
833 | + | ||
834 | /* | ||
835 | * This IOCTL is used to retrieve the wMaxCommand for the device, | ||
836 | * defining the message limit for both reading and writing. | ||
837 | diff --git a/kernel/cpu.c b/kernel/cpu.c | ||
838 | index 198a38883e64..bc255e25d5dd 100644 | ||
839 | --- a/kernel/cpu.c | ||
840 | +++ b/kernel/cpu.c | ||
841 | @@ -698,10 +698,12 @@ void set_cpu_present(unsigned int cpu, bool present) | ||
842 | |||
843 | void set_cpu_online(unsigned int cpu, bool online) | ||
844 | { | ||
845 | - if (online) | ||
846 | + if (online) { | ||
847 | cpumask_set_cpu(cpu, to_cpumask(cpu_online_bits)); | ||
848 | - else | ||
849 | + cpumask_set_cpu(cpu, to_cpumask(cpu_active_bits)); | ||
850 | + } else { | ||
851 | cpumask_clear_cpu(cpu, to_cpumask(cpu_online_bits)); | ||
852 | + } | ||
853 | } | ||
854 | |||
855 | void set_cpu_active(unsigned int cpu, bool active) | ||
856 | diff --git a/kernel/events/core.c b/kernel/events/core.c | ||
857 | index ac9b8cce3df2..459b94c94721 100644 | ||
858 | --- a/kernel/events/core.c | ||
859 | +++ b/kernel/events/core.c | ||
860 | @@ -165,25 +165,109 @@ int sysctl_perf_event_mlock __read_mostly = 512 + (PAGE_SIZE / 1024); /* 'free' | ||
861 | /* | ||
862 | * max perf event sample rate | ||
863 | */ | ||
864 | -#define DEFAULT_MAX_SAMPLE_RATE 100000 | ||
865 | -int sysctl_perf_event_sample_rate __read_mostly = DEFAULT_MAX_SAMPLE_RATE; | ||
866 | -static int max_samples_per_tick __read_mostly = | ||
867 | - DIV_ROUND_UP(DEFAULT_MAX_SAMPLE_RATE, HZ); | ||
868 | +#define DEFAULT_MAX_SAMPLE_RATE 100000 | ||
869 | +#define DEFAULT_SAMPLE_PERIOD_NS (NSEC_PER_SEC / DEFAULT_MAX_SAMPLE_RATE) | ||
870 | +#define DEFAULT_CPU_TIME_MAX_PERCENT 25 | ||
871 | + | ||
872 | +int sysctl_perf_event_sample_rate __read_mostly = DEFAULT_MAX_SAMPLE_RATE; | ||
873 | + | ||
874 | +static int max_samples_per_tick __read_mostly = DIV_ROUND_UP(DEFAULT_MAX_SAMPLE_RATE, HZ); | ||
875 | +static int perf_sample_period_ns __read_mostly = DEFAULT_SAMPLE_PERIOD_NS; | ||
876 | + | ||
877 | +static atomic_t perf_sample_allowed_ns __read_mostly = | ||
878 | + ATOMIC_INIT( DEFAULT_SAMPLE_PERIOD_NS * DEFAULT_CPU_TIME_MAX_PERCENT / 100); | ||
879 | + | ||
880 | +void update_perf_cpu_limits(void) | ||
881 | +{ | ||
882 | + u64 tmp = perf_sample_period_ns; | ||
883 | + | ||
884 | + tmp *= sysctl_perf_cpu_time_max_percent; | ||
885 | + do_div(tmp, 100); | ||
886 | + atomic_set(&perf_sample_allowed_ns, tmp); | ||
887 | +} | ||
888 | |||
889 | int perf_proc_update_handler(struct ctl_table *table, int write, | ||
890 | void __user *buffer, size_t *lenp, | ||
891 | loff_t *ppos) | ||
892 | { | ||
893 | - int ret = proc_dointvec(table, write, buffer, lenp, ppos); | ||
894 | + int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); | ||
895 | |||
896 | if (ret || !write) | ||
897 | return ret; | ||
898 | |||
899 | max_samples_per_tick = DIV_ROUND_UP(sysctl_perf_event_sample_rate, HZ); | ||
900 | + perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate; | ||
901 | + update_perf_cpu_limits(); | ||
902 | + | ||
903 | + return 0; | ||
904 | +} | ||
905 | + | ||
906 | +int sysctl_perf_cpu_time_max_percent __read_mostly = DEFAULT_CPU_TIME_MAX_PERCENT; | ||
907 | + | ||
908 | +int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write, | ||
909 | + void __user *buffer, size_t *lenp, | ||
910 | + loff_t *ppos) | ||
911 | +{ | ||
912 | + int ret = proc_dointvec(table, write, buffer, lenp, ppos); | ||
913 | + | ||
914 | + if (ret || !write) | ||
915 | + return ret; | ||
916 | + | ||
917 | + update_perf_cpu_limits(); | ||
918 | |||
919 | return 0; | ||
920 | } | ||
921 | |||
922 | +/* | ||
923 | + * perf samples are done in some very critical code paths (NMIs). | ||
924 | + * If they take too much CPU time, the system can lock up and not | ||
925 | + * get any real work done. This will drop the sample rate when | ||
926 | + * we detect that events are taking too long. | ||
927 | + */ | ||
928 | +#define NR_ACCUMULATED_SAMPLES 128 | ||
929 | +DEFINE_PER_CPU(u64, running_sample_length); | ||
930 | + | ||
931 | +void perf_sample_event_took(u64 sample_len_ns) | ||
932 | +{ | ||
933 | + u64 avg_local_sample_len; | ||
934 | + u64 local_samples_len; | ||
935 | + | ||
936 | + if (atomic_read(&perf_sample_allowed_ns) == 0) | ||
937 | + return; | ||
938 | + | ||
939 | + /* decay the counter by 1 average sample */ | ||
940 | + local_samples_len = __get_cpu_var(running_sample_length); | ||
941 | + local_samples_len -= local_samples_len/NR_ACCUMULATED_SAMPLES; | ||
942 | + local_samples_len += sample_len_ns; | ||
943 | + __get_cpu_var(running_sample_length) = local_samples_len; | ||
944 | + | ||
945 | + /* | ||
946 | + * note: this will be biased artifically low until we have | ||
947 | + * seen NR_ACCUMULATED_SAMPLES. Doing it this way keeps us | ||
948 | + * from having to maintain a count. | ||
949 | + */ | ||
950 | + avg_local_sample_len = local_samples_len/NR_ACCUMULATED_SAMPLES; | ||
951 | + | ||
952 | + if (avg_local_sample_len <= atomic_read(&perf_sample_allowed_ns)) | ||
953 | + return; | ||
954 | + | ||
955 | + if (max_samples_per_tick <= 1) | ||
956 | + return; | ||
957 | + | ||
958 | + max_samples_per_tick = DIV_ROUND_UP(max_samples_per_tick, 2); | ||
959 | + sysctl_perf_event_sample_rate = max_samples_per_tick * HZ; | ||
960 | + perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate; | ||
961 | + | ||
962 | + printk_ratelimited(KERN_WARNING | ||
963 | + "perf samples too long (%lld > %d), lowering " | ||
964 | + "kernel.perf_event_max_sample_rate to %d\n", | ||
965 | + avg_local_sample_len, | ||
966 | + atomic_read(&perf_sample_allowed_ns), | ||
967 | + sysctl_perf_event_sample_rate); | ||
968 | + | ||
969 | + update_perf_cpu_limits(); | ||
970 | +} | ||
971 | + | ||
972 | static atomic64_t perf_event_id; | ||
973 | |||
974 | static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx, | ||
975 | @@ -1237,6 +1321,11 @@ group_sched_out(struct perf_event *group_event, | ||
976 | cpuctx->exclusive = 0; | ||
977 | } | ||
978 | |||
979 | +struct remove_event { | ||
980 | + struct perf_event *event; | ||
981 | + bool detach_group; | ||
982 | +}; | ||
983 | + | ||
984 | /* | ||
985 | * Cross CPU call to remove a performance event | ||
986 | * | ||
987 | @@ -1245,12 +1334,15 @@ group_sched_out(struct perf_event *group_event, | ||
988 | */ | ||
989 | static int __perf_remove_from_context(void *info) | ||
990 | { | ||
991 | - struct perf_event *event = info; | ||
992 | + struct remove_event *re = info; | ||
993 | + struct perf_event *event = re->event; | ||
994 | struct perf_event_context *ctx = event->ctx; | ||
995 | struct perf_cpu_context *cpuctx = __get_cpu_context(ctx); | ||
996 | |||
997 | raw_spin_lock(&ctx->lock); | ||
998 | event_sched_out(event, cpuctx, ctx); | ||
999 | + if (re->detach_group) | ||
1000 | + perf_group_detach(event); | ||
1001 | list_del_event(event, ctx); | ||
1002 | if (!ctx->nr_events && cpuctx->task_ctx == ctx) { | ||
1003 | ctx->is_active = 0; | ||
1004 | @@ -1275,10 +1367,14 @@ static int __perf_remove_from_context(void *info) | ||
1005 | * When called from perf_event_exit_task, it's OK because the | ||
1006 | * context has been detached from its task. | ||
1007 | */ | ||
1008 | -static void perf_remove_from_context(struct perf_event *event) | ||
1009 | +static void perf_remove_from_context(struct perf_event *event, bool detach_group) | ||
1010 | { | ||
1011 | struct perf_event_context *ctx = event->ctx; | ||
1012 | struct task_struct *task = ctx->task; | ||
1013 | + struct remove_event re = { | ||
1014 | + .event = event, | ||
1015 | + .detach_group = detach_group, | ||
1016 | + }; | ||
1017 | |||
1018 | lockdep_assert_held(&ctx->mutex); | ||
1019 | |||
1020 | @@ -1287,12 +1383,12 @@ static void perf_remove_from_context(struct perf_event *event) | ||
1021 | * Per cpu events are removed via an smp call and | ||
1022 | * the removal is always successful. | ||
1023 | */ | ||
1024 | - cpu_function_call(event->cpu, __perf_remove_from_context, event); | ||
1025 | + cpu_function_call(event->cpu, __perf_remove_from_context, &re); | ||
1026 | return; | ||
1027 | } | ||
1028 | |||
1029 | retry: | ||
1030 | - if (!task_function_call(task, __perf_remove_from_context, event)) | ||
1031 | + if (!task_function_call(task, __perf_remove_from_context, &re)) | ||
1032 | return; | ||
1033 | |||
1034 | raw_spin_lock_irq(&ctx->lock); | ||
1035 | @@ -1309,6 +1405,8 @@ retry: | ||
1036 | * Since the task isn't running, its safe to remove the event, us | ||
1037 | * holding the ctx->lock ensures the task won't get scheduled in. | ||
1038 | */ | ||
1039 | + if (detach_group) | ||
1040 | + perf_group_detach(event); | ||
1041 | list_del_event(event, ctx); | ||
1042 | raw_spin_unlock_irq(&ctx->lock); | ||
1043 | } | ||
1044 | @@ -3015,10 +3113,7 @@ int perf_event_release_kernel(struct perf_event *event) | ||
1045 | * to trigger the AB-BA case. | ||
1046 | */ | ||
1047 | mutex_lock_nested(&ctx->mutex, SINGLE_DEPTH_NESTING); | ||
1048 | - raw_spin_lock_irq(&ctx->lock); | ||
1049 | - perf_group_detach(event); | ||
1050 | - raw_spin_unlock_irq(&ctx->lock); | ||
1051 | - perf_remove_from_context(event); | ||
1052 | + perf_remove_from_context(event, true); | ||
1053 | mutex_unlock(&ctx->mutex); | ||
1054 | |||
1055 | free_event(event); | ||
1056 | @@ -5044,6 +5139,9 @@ struct swevent_htable { | ||
1057 | |||
1058 | /* Recursion avoidance in each contexts */ | ||
1059 | int recursion[PERF_NR_CONTEXTS]; | ||
1060 | + | ||
1061 | + /* Keeps track of cpu being initialized/exited */ | ||
1062 | + bool online; | ||
1063 | }; | ||
1064 | |||
1065 | static DEFINE_PER_CPU(struct swevent_htable, swevent_htable); | ||
1066 | @@ -5290,8 +5388,14 @@ static int perf_swevent_add(struct perf_event *event, int flags) | ||
1067 | hwc->state = !(flags & PERF_EF_START); | ||
1068 | |||
1069 | head = find_swevent_head(swhash, event); | ||
1070 | - if (WARN_ON_ONCE(!head)) | ||
1071 | + if (!head) { | ||
1072 | + /* | ||
1073 | + * We can race with cpu hotplug code. Do not | ||
1074 | + * WARN if the cpu just got unplugged. | ||
1075 | + */ | ||
1076 | + WARN_ON_ONCE(swhash->online); | ||
1077 | return -EINVAL; | ||
1078 | + } | ||
1079 | |||
1080 | hlist_add_head_rcu(&event->hlist_entry, head); | ||
1081 | |||
1082 | @@ -6581,6 +6685,9 @@ SYSCALL_DEFINE5(perf_event_open, | ||
1083 | if (attr.freq) { | ||
1084 | if (attr.sample_freq > sysctl_perf_event_sample_rate) | ||
1085 | return -EINVAL; | ||
1086 | + } else { | ||
1087 | + if (attr.sample_period & (1ULL << 63)) | ||
1088 | + return -EINVAL; | ||
1089 | } | ||
1090 | |||
1091 | /* | ||
1092 | @@ -6727,7 +6834,7 @@ SYSCALL_DEFINE5(perf_event_open, | ||
1093 | struct perf_event_context *gctx = group_leader->ctx; | ||
1094 | |||
1095 | mutex_lock(&gctx->mutex); | ||
1096 | - perf_remove_from_context(group_leader); | ||
1097 | + perf_remove_from_context(group_leader, false); | ||
1098 | |||
1099 | /* | ||
1100 | * Removing from the context ends up with disabled | ||
1101 | @@ -6737,7 +6844,7 @@ SYSCALL_DEFINE5(perf_event_open, | ||
1102 | perf_event__state_init(group_leader); | ||
1103 | list_for_each_entry(sibling, &group_leader->sibling_list, | ||
1104 | group_entry) { | ||
1105 | - perf_remove_from_context(sibling); | ||
1106 | + perf_remove_from_context(sibling, false); | ||
1107 | perf_event__state_init(sibling); | ||
1108 | put_ctx(gctx); | ||
1109 | } | ||
1110 | @@ -6867,7 +6974,7 @@ void perf_pmu_migrate_context(struct pmu *pmu, int src_cpu, int dst_cpu) | ||
1111 | mutex_lock(&src_ctx->mutex); | ||
1112 | list_for_each_entry_safe(event, tmp, &src_ctx->event_list, | ||
1113 | event_entry) { | ||
1114 | - perf_remove_from_context(event); | ||
1115 | + perf_remove_from_context(event, false); | ||
1116 | put_ctx(src_ctx); | ||
1117 | list_add(&event->event_entry, &events); | ||
1118 | } | ||
1119 | @@ -6927,13 +7034,7 @@ __perf_event_exit_task(struct perf_event *child_event, | ||
1120 | struct perf_event_context *child_ctx, | ||
1121 | struct task_struct *child) | ||
1122 | { | ||
1123 | - if (child_event->parent) { | ||
1124 | - raw_spin_lock_irq(&child_ctx->lock); | ||
1125 | - perf_group_detach(child_event); | ||
1126 | - raw_spin_unlock_irq(&child_ctx->lock); | ||
1127 | - } | ||
1128 | - | ||
1129 | - perf_remove_from_context(child_event); | ||
1130 | + perf_remove_from_context(child_event, !!child_event->parent); | ||
1131 | |||
1132 | /* | ||
1133 | * It can happen that the parent exits first, and has events | ||
1134 | @@ -7395,6 +7496,7 @@ static void __cpuinit perf_event_init_cpu(int cpu) | ||
1135 | struct swevent_htable *swhash = &per_cpu(swevent_htable, cpu); | ||
1136 | |||
1137 | mutex_lock(&swhash->hlist_mutex); | ||
1138 | + swhash->online = true; | ||
1139 | if (swhash->hlist_refcount > 0) { | ||
1140 | struct swevent_hlist *hlist; | ||
1141 | |||
1142 | @@ -7417,14 +7519,14 @@ static void perf_pmu_rotate_stop(struct pmu *pmu) | ||
1143 | |||
1144 | static void __perf_event_exit_context(void *__info) | ||
1145 | { | ||
1146 | + struct remove_event re = { .detach_group = false }; | ||
1147 | struct perf_event_context *ctx = __info; | ||
1148 | - struct perf_event *event; | ||
1149 | |||
1150 | perf_pmu_rotate_stop(ctx->pmu); | ||
1151 | |||
1152 | rcu_read_lock(); | ||
1153 | - list_for_each_entry_rcu(event, &ctx->event_list, event_entry) | ||
1154 | - __perf_remove_from_context(event); | ||
1155 | + list_for_each_entry_rcu(re.event, &ctx->event_list, event_entry) | ||
1156 | + __perf_remove_from_context(&re); | ||
1157 | rcu_read_unlock(); | ||
1158 | } | ||
1159 | |||
1160 | @@ -7452,6 +7554,7 @@ static void perf_event_exit_cpu(int cpu) | ||
1161 | perf_event_exit_cpu_context(cpu); | ||
1162 | |||
1163 | mutex_lock(&swhash->hlist_mutex); | ||
1164 | + swhash->online = false; | ||
1165 | swevent_hlist_release(swhash); | ||
1166 | mutex_unlock(&swhash->hlist_mutex); | ||
1167 | } | ||
1168 | diff --git a/kernel/sched/core.c b/kernel/sched/core.c | ||
1169 | index b4308d7da339..2672eca82a2b 100644 | ||
1170 | --- a/kernel/sched/core.c | ||
1171 | +++ b/kernel/sched/core.c | ||
1172 | @@ -5270,7 +5270,6 @@ static int __cpuinit sched_cpu_active(struct notifier_block *nfb, | ||
1173 | unsigned long action, void *hcpu) | ||
1174 | { | ||
1175 | switch (action & ~CPU_TASKS_FROZEN) { | ||
1176 | - case CPU_STARTING: | ||
1177 | case CPU_DOWN_FAILED: | ||
1178 | set_cpu_active((long)hcpu, true); | ||
1179 | return NOTIFY_OK; | ||
1180 | diff --git a/kernel/sched/cpupri.c b/kernel/sched/cpupri.c | ||
1181 | index 1095e878a46f..b3f0a2783369 100644 | ||
1182 | --- a/kernel/sched/cpupri.c | ||
1183 | +++ b/kernel/sched/cpupri.c | ||
1184 | @@ -70,8 +70,7 @@ int cpupri_find(struct cpupri *cp, struct task_struct *p, | ||
1185 | int idx = 0; | ||
1186 | int task_pri = convert_prio(p->prio); | ||
1187 | |||
1188 | - if (task_pri >= MAX_RT_PRIO) | ||
1189 | - return 0; | ||
1190 | + BUG_ON(task_pri >= CPUPRI_NR_PRIORITIES); | ||
1191 | |||
1192 | for (idx = 0; idx < task_pri; idx++) { | ||
1193 | struct cpupri_vec *vec = &cp->pri_to_cpu[idx]; | ||
1194 | diff --git a/kernel/sched/cputime.c b/kernel/sched/cputime.c | ||
1195 | index 1101d92635c3..c23a8fd36149 100644 | ||
1196 | --- a/kernel/sched/cputime.c | ||
1197 | +++ b/kernel/sched/cputime.c | ||
1198 | @@ -326,50 +326,50 @@ out: | ||
1199 | * softirq as those do not count in task exec_runtime any more. | ||
1200 | */ | ||
1201 | static void irqtime_account_process_tick(struct task_struct *p, int user_tick, | ||
1202 | - struct rq *rq) | ||
1203 | + struct rq *rq, int ticks) | ||
1204 | { | ||
1205 | - cputime_t one_jiffy_scaled = cputime_to_scaled(cputime_one_jiffy); | ||
1206 | + cputime_t scaled = cputime_to_scaled(cputime_one_jiffy); | ||
1207 | + u64 cputime = (__force u64) cputime_one_jiffy; | ||
1208 | u64 *cpustat = kcpustat_this_cpu->cpustat; | ||
1209 | |||
1210 | if (steal_account_process_tick()) | ||
1211 | return; | ||
1212 | |||
1213 | + cputime *= ticks; | ||
1214 | + scaled *= ticks; | ||
1215 | + | ||
1216 | if (irqtime_account_hi_update()) { | ||
1217 | - cpustat[CPUTIME_IRQ] += (__force u64) cputime_one_jiffy; | ||
1218 | + cpustat[CPUTIME_IRQ] += cputime; | ||
1219 | } else if (irqtime_account_si_update()) { | ||
1220 | - cpustat[CPUTIME_SOFTIRQ] += (__force u64) cputime_one_jiffy; | ||
1221 | + cpustat[CPUTIME_SOFTIRQ] += cputime; | ||
1222 | } else if (this_cpu_ksoftirqd() == p) { | ||
1223 | /* | ||
1224 | * ksoftirqd time do not get accounted in cpu_softirq_time. | ||
1225 | * So, we have to handle it separately here. | ||
1226 | * Also, p->stime needs to be updated for ksoftirqd. | ||
1227 | */ | ||
1228 | - __account_system_time(p, cputime_one_jiffy, one_jiffy_scaled, | ||
1229 | - CPUTIME_SOFTIRQ); | ||
1230 | + __account_system_time(p, cputime, scaled, CPUTIME_SOFTIRQ); | ||
1231 | } else if (user_tick) { | ||
1232 | - account_user_time(p, cputime_one_jiffy, one_jiffy_scaled); | ||
1233 | + account_user_time(p, cputime, scaled); | ||
1234 | } else if (p == rq->idle) { | ||
1235 | - account_idle_time(cputime_one_jiffy); | ||
1236 | + account_idle_time(cputime); | ||
1237 | } else if (p->flags & PF_VCPU) { /* System time or guest time */ | ||
1238 | - account_guest_time(p, cputime_one_jiffy, one_jiffy_scaled); | ||
1239 | + account_guest_time(p, cputime, scaled); | ||
1240 | } else { | ||
1241 | - __account_system_time(p, cputime_one_jiffy, one_jiffy_scaled, | ||
1242 | - CPUTIME_SYSTEM); | ||
1243 | + __account_system_time(p, cputime, scaled, CPUTIME_SYSTEM); | ||
1244 | } | ||
1245 | } | ||
1246 | |||
1247 | static void irqtime_account_idle_ticks(int ticks) | ||
1248 | { | ||
1249 | - int i; | ||
1250 | struct rq *rq = this_rq(); | ||
1251 | |||
1252 | - for (i = 0; i < ticks; i++) | ||
1253 | - irqtime_account_process_tick(current, 0, rq); | ||
1254 | + irqtime_account_process_tick(current, 0, rq, ticks); | ||
1255 | } | ||
1256 | #else /* CONFIG_IRQ_TIME_ACCOUNTING */ | ||
1257 | static inline void irqtime_account_idle_ticks(int ticks) {} | ||
1258 | static inline void irqtime_account_process_tick(struct task_struct *p, int user_tick, | ||
1259 | - struct rq *rq) {} | ||
1260 | + struct rq *rq, int nr_ticks) {} | ||
1261 | #endif /* CONFIG_IRQ_TIME_ACCOUNTING */ | ||
1262 | |||
1263 | /* | ||
1264 | @@ -464,7 +464,7 @@ void account_process_tick(struct task_struct *p, int user_tick) | ||
1265 | return; | ||
1266 | |||
1267 | if (sched_clock_irqtime) { | ||
1268 | - irqtime_account_process_tick(p, user_tick, rq); | ||
1269 | + irqtime_account_process_tick(p, user_tick, rq, 1); | ||
1270 | return; | ||
1271 | } | ||
1272 | |||
1273 | diff --git a/kernel/sysctl.c b/kernel/sysctl.c | ||
1274 | index ed6c01626acd..9469f4c61a30 100644 | ||
1275 | --- a/kernel/sysctl.c | ||
1276 | +++ b/kernel/sysctl.c | ||
1277 | @@ -1049,6 +1049,16 @@ static struct ctl_table kern_table[] = { | ||
1278 | .maxlen = sizeof(sysctl_perf_event_sample_rate), | ||
1279 | .mode = 0644, | ||
1280 | .proc_handler = perf_proc_update_handler, | ||
1281 | + .extra1 = &one, | ||
1282 | + }, | ||
1283 | + { | ||
1284 | + .procname = "perf_cpu_time_max_percent", | ||
1285 | + .data = &sysctl_perf_cpu_time_max_percent, | ||
1286 | + .maxlen = sizeof(sysctl_perf_cpu_time_max_percent), | ||
1287 | + .mode = 0644, | ||
1288 | + .proc_handler = perf_cpu_time_max_percent_handler, | ||
1289 | + .extra1 = &zero, | ||
1290 | + .extra2 = &one_hundred, | ||
1291 | }, | ||
1292 | #endif | ||
1293 | #ifdef CONFIG_KMEMCHECK | ||
1294 | diff --git a/mm/memory-failure.c b/mm/memory-failure.c | ||
1295 | index 4254eb021583..4f8548abd6ee 100644 | ||
1296 | --- a/mm/memory-failure.c | ||
1297 | +++ b/mm/memory-failure.c | ||
1298 | @@ -1153,6 +1153,8 @@ int memory_failure(unsigned long pfn, int trapno, int flags) | ||
1299 | */ | ||
1300 | if (!PageHWPoison(p)) { | ||
1301 | printk(KERN_ERR "MCE %#lx: just unpoisoned\n", pfn); | ||
1302 | + atomic_long_sub(nr_pages, &num_poisoned_pages); | ||
1303 | + put_page(hpage); | ||
1304 | res = 0; | ||
1305 | goto out; | ||
1306 | } | ||
1307 | diff --git a/mm/rmap.c b/mm/rmap.c | ||
1308 | index fbf0040a7342..b730a4409be6 100644 | ||
1309 | --- a/mm/rmap.c | ||
1310 | +++ b/mm/rmap.c | ||
1311 | @@ -1675,10 +1675,9 @@ void __put_anon_vma(struct anon_vma *anon_vma) | ||
1312 | { | ||
1313 | struct anon_vma *root = anon_vma->root; | ||
1314 | |||
1315 | + anon_vma_free(anon_vma); | ||
1316 | if (root != anon_vma && atomic_dec_and_test(&root->refcount)) | ||
1317 | anon_vma_free(root); | ||
1318 | - | ||
1319 | - anon_vma_free(anon_vma); | ||
1320 | } | ||
1321 | |||
1322 | #ifdef CONFIG_MIGRATION | ||
1323 | diff --git a/net/ipv6/netfilter.c b/net/ipv6/netfilter.c | ||
1324 | index 95f3f1da0d7f..d38e6a8d8b9f 100644 | ||
1325 | --- a/net/ipv6/netfilter.c | ||
1326 | +++ b/net/ipv6/netfilter.c | ||
1327 | @@ -30,13 +30,15 @@ int ip6_route_me_harder(struct sk_buff *skb) | ||
1328 | .daddr = iph->daddr, | ||
1329 | .saddr = iph->saddr, | ||
1330 | }; | ||
1331 | + int err; | ||
1332 | |||
1333 | dst = ip6_route_output(net, skb->sk, &fl6); | ||
1334 | - if (dst->error) { | ||
1335 | + err = dst->error; | ||
1336 | + if (err) { | ||
1337 | IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES); | ||
1338 | LIMIT_NETDEBUG(KERN_DEBUG "ip6_route_me_harder: No more route.\n"); | ||
1339 | dst_release(dst); | ||
1340 | - return dst->error; | ||
1341 | + return err; | ||
1342 | } | ||
1343 | |||
1344 | /* Drop old route. */ | ||
1345 | diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c | ||
1346 | index 7de7cf1ec852..0923f09df503 100644 | ||
1347 | --- a/sound/pci/hda/patch_realtek.c | ||
1348 | +++ b/sound/pci/hda/patch_realtek.c | ||
1349 | @@ -1590,12 +1590,10 @@ static const struct hda_fixup alc260_fixups[] = { | ||
1350 | [ALC260_FIXUP_COEF] = { | ||
1351 | .type = HDA_FIXUP_VERBS, | ||
1352 | .v.verbs = (const struct hda_verb[]) { | ||
1353 | - { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, | ||
1354 | - { 0x20, AC_VERB_SET_PROC_COEF, 0x3040 }, | ||
1355 | + { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, | ||
1356 | + { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 }, | ||
1357 | { } | ||
1358 | }, | ||
1359 | - .chained = true, | ||
1360 | - .chain_id = ALC260_FIXUP_HP_PIN_0F, | ||
1361 | }, | ||
1362 | [ALC260_FIXUP_GPIO1] = { | ||
1363 | .type = HDA_FIXUP_VERBS, | ||
1364 | @@ -1610,8 +1608,8 @@ static const struct hda_fixup alc260_fixups[] = { | ||
1365 | [ALC260_FIXUP_REPLACER] = { | ||
1366 | .type = HDA_FIXUP_VERBS, | ||
1367 | .v.verbs = (const struct hda_verb[]) { | ||
1368 | - { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 }, | ||
1369 | - { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 }, | ||
1370 | + { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 }, | ||
1371 | + { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 }, | ||
1372 | { } | ||
1373 | }, | ||
1374 | .chained = true, | ||
1375 | diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c | ||
1376 | index 07b1a3ad3e24..63b6f8c8edf2 100644 | ||
1377 | --- a/tools/perf/util/evsel.c | ||
1378 | +++ b/tools/perf/util/evsel.c | ||
1379 | @@ -1514,7 +1514,7 @@ int perf_evsel__open_strerror(struct perf_evsel *evsel, | ||
1380 | switch (err) { | ||
1381 | case EPERM: | ||
1382 | case EACCES: | ||
1383 | - return scnprintf(msg, size, "%s", | ||
1384 | + return scnprintf(msg, size, | ||
1385 | "You may not have permission to collect %sstats.\n" | ||
1386 | "Consider tweaking /proc/sys/kernel/perf_event_paranoid:\n" | ||
1387 | " -1 - Not paranoid at all\n" |