Annotation of /trunk/kernel-alx/patches-4.9/0234-4.9.135-all-fixes.patch
Parent Directory | Revision Log
Revision 3240 -
(hide annotations)
(download)
Fri Nov 9 13:47:01 2018 UTC (5 years, 10 months ago) by niro
File size: 54580 byte(s)
Fri Nov 9 13:47:01 2018 UTC (5 years, 10 months ago) by niro
File size: 54580 byte(s)
-linux-4.9.135
1 | niro | 3240 | diff --git a/Makefile b/Makefile |
2 | index 46135e4333e6..3678e4d19ebc 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,6 +1,6 @@ | ||
6 | VERSION = 4 | ||
7 | PATCHLEVEL = 9 | ||
8 | -SUBLEVEL = 134 | ||
9 | +SUBLEVEL = 135 | ||
10 | EXTRAVERSION = | ||
11 | NAME = Roaring Lionus | ||
12 | |||
13 | diff --git a/arch/arc/Makefile b/arch/arc/Makefile | ||
14 | index 8447eed836ef..a3b456008201 100644 | ||
15 | --- a/arch/arc/Makefile | ||
16 | +++ b/arch/arc/Makefile | ||
17 | @@ -8,34 +8,12 @@ | ||
18 | |||
19 | UTS_MACHINE := arc | ||
20 | |||
21 | -ifeq ($(CROSS_COMPILE),) | ||
22 | -ifndef CONFIG_CPU_BIG_ENDIAN | ||
23 | -CROSS_COMPILE := arc-linux- | ||
24 | -else | ||
25 | -CROSS_COMPILE := arceb-linux- | ||
26 | -endif | ||
27 | -endif | ||
28 | - | ||
29 | KBUILD_DEFCONFIG := nsim_700_defconfig | ||
30 | |||
31 | cflags-y += -fno-common -pipe -fno-builtin -mmedium-calls -D__linux__ | ||
32 | cflags-$(CONFIG_ISA_ARCOMPACT) += -mA7 | ||
33 | cflags-$(CONFIG_ISA_ARCV2) += -mcpu=archs | ||
34 | |||
35 | -is_700 = $(shell $(CC) -dM -E - < /dev/null | grep -q "ARC700" && echo 1 || echo 0) | ||
36 | - | ||
37 | -ifdef CONFIG_ISA_ARCOMPACT | ||
38 | -ifeq ($(is_700), 0) | ||
39 | - $(error Toolchain not configured for ARCompact builds) | ||
40 | -endif | ||
41 | -endif | ||
42 | - | ||
43 | -ifdef CONFIG_ISA_ARCV2 | ||
44 | -ifeq ($(is_700), 1) | ||
45 | - $(error Toolchain not configured for ARCv2 builds) | ||
46 | -endif | ||
47 | -endif | ||
48 | - | ||
49 | ifdef CONFIG_ARC_CURR_IN_REG | ||
50 | # For a global register defintion, make sure it gets passed to every file | ||
51 | # We had a customer reported bug where some code built in kernel was NOT using | ||
52 | @@ -89,7 +67,7 @@ ldflags-$(CONFIG_CPU_BIG_ENDIAN) += -EB | ||
53 | # --build-id w/o "-marclinux". Default arc-elf32-ld is OK | ||
54 | ldflags-$(upto_gcc44) += -marclinux | ||
55 | |||
56 | -LIBGCC := $(shell $(CC) $(cflags-y) --print-libgcc-file-name) | ||
57 | +LIBGCC = $(shell $(CC) $(cflags-y) --print-libgcc-file-name) | ||
58 | |||
59 | # Modules with short calls might break for calls into builtin-kernel | ||
60 | KBUILD_CFLAGS_MODULE += -mlong-calls -mno-millicode | ||
61 | diff --git a/arch/powerpc/kernel/tm.S b/arch/powerpc/kernel/tm.S | ||
62 | index 3a2d04134da9..f59b73810630 100644 | ||
63 | --- a/arch/powerpc/kernel/tm.S | ||
64 | +++ b/arch/powerpc/kernel/tm.S | ||
65 | @@ -166,13 +166,27 @@ _GLOBAL(tm_reclaim) | ||
66 | std r1, PACATMSCRATCH(r13) | ||
67 | ld r1, PACAR1(r13) | ||
68 | |||
69 | - /* Store the PPR in r11 and reset to decent value */ | ||
70 | std r11, GPR11(r1) /* Temporary stash */ | ||
71 | |||
72 | + /* | ||
73 | + * Move the saved user r1 to the kernel stack in case PACATMSCRATCH is | ||
74 | + * clobbered by an exception once we turn on MSR_RI below. | ||
75 | + */ | ||
76 | + ld r11, PACATMSCRATCH(r13) | ||
77 | + std r11, GPR1(r1) | ||
78 | + | ||
79 | + /* | ||
80 | + * Store r13 away so we can free up the scratch SPR for the SLB fault | ||
81 | + * handler (needed once we start accessing the thread_struct). | ||
82 | + */ | ||
83 | + GET_SCRATCH0(r11) | ||
84 | + std r11, GPR13(r1) | ||
85 | + | ||
86 | /* Reset MSR RI so we can take SLB faults again */ | ||
87 | li r11, MSR_RI | ||
88 | mtmsrd r11, 1 | ||
89 | |||
90 | + /* Store the PPR in r11 and reset to decent value */ | ||
91 | mfspr r11, SPRN_PPR | ||
92 | HMT_MEDIUM | ||
93 | |||
94 | @@ -197,11 +211,11 @@ _GLOBAL(tm_reclaim) | ||
95 | SAVE_GPR(8, r7) /* user r8 */ | ||
96 | SAVE_GPR(9, r7) /* user r9 */ | ||
97 | SAVE_GPR(10, r7) /* user r10 */ | ||
98 | - ld r3, PACATMSCRATCH(r13) /* user r1 */ | ||
99 | + ld r3, GPR1(r1) /* user r1 */ | ||
100 | ld r4, GPR7(r1) /* user r7 */ | ||
101 | ld r5, GPR11(r1) /* user r11 */ | ||
102 | ld r6, GPR12(r1) /* user r12 */ | ||
103 | - GET_SCRATCH0(8) /* user r13 */ | ||
104 | + ld r8, GPR13(r1) /* user r13 */ | ||
105 | std r3, GPR1(r7) | ||
106 | std r4, GPR7(r7) | ||
107 | std r5, GPR11(r7) | ||
108 | diff --git a/arch/s390/appldata/appldata_os.c b/arch/s390/appldata/appldata_os.c | ||
109 | index 69b23b25ac34..08b9e942a262 100644 | ||
110 | --- a/arch/s390/appldata/appldata_os.c | ||
111 | +++ b/arch/s390/appldata/appldata_os.c | ||
112 | @@ -113,21 +113,21 @@ static void appldata_get_os_data(void *data) | ||
113 | j = 0; | ||
114 | for_each_online_cpu(i) { | ||
115 | os_data->os_cpu[j].per_cpu_user = | ||
116 | - cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_USER]); | ||
117 | + nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_USER]); | ||
118 | os_data->os_cpu[j].per_cpu_nice = | ||
119 | - cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_NICE]); | ||
120 | + nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_NICE]); | ||
121 | os_data->os_cpu[j].per_cpu_system = | ||
122 | - cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM]); | ||
123 | + nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM]); | ||
124 | os_data->os_cpu[j].per_cpu_idle = | ||
125 | - cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IDLE]); | ||
126 | + nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IDLE]); | ||
127 | os_data->os_cpu[j].per_cpu_irq = | ||
128 | - cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IRQ]); | ||
129 | + nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IRQ]); | ||
130 | os_data->os_cpu[j].per_cpu_softirq = | ||
131 | - cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ]); | ||
132 | + nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ]); | ||
133 | os_data->os_cpu[j].per_cpu_iowait = | ||
134 | - cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IOWAIT]); | ||
135 | + nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IOWAIT]); | ||
136 | os_data->os_cpu[j].per_cpu_steal = | ||
137 | - cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_STEAL]); | ||
138 | + nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_STEAL]); | ||
139 | os_data->os_cpu[j].cpu_id = i; | ||
140 | j++; | ||
141 | } | ||
142 | diff --git a/arch/x86/include/asm/pgtable_types.h b/arch/x86/include/asm/pgtable_types.h | ||
143 | index dfdb7e21ba56..93d089c9509a 100644 | ||
144 | --- a/arch/x86/include/asm/pgtable_types.h | ||
145 | +++ b/arch/x86/include/asm/pgtable_types.h | ||
146 | @@ -134,7 +134,7 @@ | ||
147 | */ | ||
148 | #define _PAGE_CHG_MASK (PTE_PFN_MASK | _PAGE_PCD | _PAGE_PWT | \ | ||
149 | _PAGE_SPECIAL | _PAGE_ACCESSED | _PAGE_DIRTY | \ | ||
150 | - _PAGE_SOFT_DIRTY) | ||
151 | + _PAGE_SOFT_DIRTY | _PAGE_DEVMAP) | ||
152 | #define _HPAGE_CHG_MASK (_PAGE_CHG_MASK | _PAGE_PSE) | ||
153 | |||
154 | /* The ASID is the lower 12 bits of CR3 */ | ||
155 | diff --git a/drivers/clocksource/timer-ti-32k.c b/drivers/clocksource/timer-ti-32k.c | ||
156 | index cf5b14e442e4..e9ab92d0c358 100644 | ||
157 | --- a/drivers/clocksource/timer-ti-32k.c | ||
158 | +++ b/drivers/clocksource/timer-ti-32k.c | ||
159 | @@ -98,6 +98,9 @@ static int __init ti_32k_timer_init(struct device_node *np) | ||
160 | return -ENXIO; | ||
161 | } | ||
162 | |||
163 | + if (!of_machine_is_compatible("ti,am43")) | ||
164 | + ti_32k_timer.cs.flags |= CLOCK_SOURCE_SUSPEND_NONSTOP; | ||
165 | + | ||
166 | ti_32k_timer.counter = ti_32k_timer.base; | ||
167 | |||
168 | /* | ||
169 | diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c | ||
170 | index af5eff6835a8..d6d91e8afa9e 100644 | ||
171 | --- a/drivers/cpufreq/cpufreq.c | ||
172 | +++ b/drivers/cpufreq/cpufreq.c | ||
173 | @@ -132,7 +132,7 @@ static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall) | ||
174 | u64 cur_wall_time; | ||
175 | u64 busy_time; | ||
176 | |||
177 | - cur_wall_time = jiffies64_to_cputime64(get_jiffies_64()); | ||
178 | + cur_wall_time = jiffies64_to_nsecs(get_jiffies_64()); | ||
179 | |||
180 | busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER]; | ||
181 | busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM]; | ||
182 | @@ -143,9 +143,9 @@ static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall) | ||
183 | |||
184 | idle_time = cur_wall_time - busy_time; | ||
185 | if (wall) | ||
186 | - *wall = cputime_to_usecs(cur_wall_time); | ||
187 | + *wall = div_u64(cur_wall_time, NSEC_PER_USEC); | ||
188 | |||
189 | - return cputime_to_usecs(idle_time); | ||
190 | + return div_u64(idle_time, NSEC_PER_USEC); | ||
191 | } | ||
192 | |||
193 | u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy) | ||
194 | diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c | ||
195 | index 642dd0f183a8..38d1a8216084 100644 | ||
196 | --- a/drivers/cpufreq/cpufreq_governor.c | ||
197 | +++ b/drivers/cpufreq/cpufreq_governor.c | ||
198 | @@ -152,7 +152,7 @@ unsigned int dbs_update(struct cpufreq_policy *policy) | ||
199 | if (ignore_nice) { | ||
200 | u64 cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE]; | ||
201 | |||
202 | - idle_time += cputime_to_usecs(cur_nice - j_cdbs->prev_cpu_nice); | ||
203 | + idle_time += div_u64(cur_nice - j_cdbs->prev_cpu_nice, NSEC_PER_USEC); | ||
204 | j_cdbs->prev_cpu_nice = cur_nice; | ||
205 | } | ||
206 | |||
207 | diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c | ||
208 | index 06d3abdffd3a..b084708fd113 100644 | ||
209 | --- a/drivers/cpufreq/cpufreq_stats.c | ||
210 | +++ b/drivers/cpufreq/cpufreq_stats.c | ||
211 | @@ -13,7 +13,6 @@ | ||
212 | #include <linux/cpufreq.h> | ||
213 | #include <linux/module.h> | ||
214 | #include <linux/slab.h> | ||
215 | -#include <linux/cputime.h> | ||
216 | |||
217 | static DEFINE_SPINLOCK(cpufreq_stats_lock); | ||
218 | |||
219 | diff --git a/drivers/gpu/drm/arm/malidp_drv.c b/drivers/gpu/drm/arm/malidp_drv.c | ||
220 | index 9280358b8f15..59d484736b4e 100644 | ||
221 | --- a/drivers/gpu/drm/arm/malidp_drv.c | ||
222 | +++ b/drivers/gpu/drm/arm/malidp_drv.c | ||
223 | @@ -378,6 +378,7 @@ static int malidp_bind(struct device *dev) | ||
224 | goto irq_init_fail; | ||
225 | |||
226 | ret = drm_vblank_init(drm, drm->mode_config.num_crtc); | ||
227 | + drm_crtc_vblank_reset(&malidp->crtc); | ||
228 | if (ret < 0) { | ||
229 | DRM_ERROR("failed to initialise vblank\n"); | ||
230 | goto vblank_fail; | ||
231 | diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c | ||
232 | index 2248b330c047..70597854397f 100644 | ||
233 | --- a/drivers/hid/hid-core.c | ||
234 | +++ b/drivers/hid/hid-core.c | ||
235 | @@ -1853,6 +1853,9 @@ static const struct hid_device_id hid_have_special_driver[] = { | ||
236 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) }, | ||
237 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS) }, | ||
238 | { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_ANSI) }, | ||
239 | + { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_ANSI) }, | ||
240 | + { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_ANSI) }, | ||
241 | + { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_ANSI) }, | ||
242 | { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) }, | ||
243 | { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) }, | ||
244 | { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_NOTEBOOK_KEYBOARD) }, | ||
245 | diff --git a/drivers/hv/hv_kvp.c b/drivers/hv/hv_kvp.c | ||
246 | index 5e1fdc8d32ab..2fd0f119a67b 100644 | ||
247 | --- a/drivers/hv/hv_kvp.c | ||
248 | +++ b/drivers/hv/hv_kvp.c | ||
249 | @@ -616,21 +616,22 @@ void hv_kvp_onchannelcallback(void *context) | ||
250 | NEGO_IN_PROGRESS, | ||
251 | NEGO_FINISHED} host_negotiatied = NEGO_NOT_STARTED; | ||
252 | |||
253 | - if (host_negotiatied == NEGO_NOT_STARTED && | ||
254 | - kvp_transaction.state < HVUTIL_READY) { | ||
255 | + if (kvp_transaction.state < HVUTIL_READY) { | ||
256 | /* | ||
257 | * If userspace daemon is not connected and host is asking | ||
258 | * us to negotiate we need to delay to not lose messages. | ||
259 | * This is important for Failover IP setting. | ||
260 | */ | ||
261 | - host_negotiatied = NEGO_IN_PROGRESS; | ||
262 | - schedule_delayed_work(&kvp_host_handshake_work, | ||
263 | + if (host_negotiatied == NEGO_NOT_STARTED) { | ||
264 | + host_negotiatied = NEGO_IN_PROGRESS; | ||
265 | + schedule_delayed_work(&kvp_host_handshake_work, | ||
266 | HV_UTIL_NEGO_TIMEOUT * HZ); | ||
267 | + } | ||
268 | return; | ||
269 | } | ||
270 | if (kvp_transaction.state > HVUTIL_READY) | ||
271 | return; | ||
272 | - | ||
273 | +recheck: | ||
274 | vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 4, &recvlen, | ||
275 | &requestid); | ||
276 | |||
277 | @@ -707,6 +708,8 @@ void hv_kvp_onchannelcallback(void *context) | ||
278 | VM_PKT_DATA_INBAND, 0); | ||
279 | |||
280 | host_negotiatied = NEGO_FINISHED; | ||
281 | + | ||
282 | + goto recheck; | ||
283 | } | ||
284 | |||
285 | } | ||
286 | diff --git a/drivers/input/keyboard/atakbd.c b/drivers/input/keyboard/atakbd.c | ||
287 | index f1235831283d..fdeda0b0fbd6 100644 | ||
288 | --- a/drivers/input/keyboard/atakbd.c | ||
289 | +++ b/drivers/input/keyboard/atakbd.c | ||
290 | @@ -79,8 +79,7 @@ MODULE_LICENSE("GPL"); | ||
291 | */ | ||
292 | |||
293 | |||
294 | -static unsigned char atakbd_keycode[0x72] = { /* American layout */ | ||
295 | - [0] = KEY_GRAVE, | ||
296 | +static unsigned char atakbd_keycode[0x73] = { /* American layout */ | ||
297 | [1] = KEY_ESC, | ||
298 | [2] = KEY_1, | ||
299 | [3] = KEY_2, | ||
300 | @@ -121,9 +120,9 @@ static unsigned char atakbd_keycode[0x72] = { /* American layout */ | ||
301 | [38] = KEY_L, | ||
302 | [39] = KEY_SEMICOLON, | ||
303 | [40] = KEY_APOSTROPHE, | ||
304 | - [41] = KEY_BACKSLASH, /* FIXME, '#' */ | ||
305 | + [41] = KEY_GRAVE, | ||
306 | [42] = KEY_LEFTSHIFT, | ||
307 | - [43] = KEY_GRAVE, /* FIXME: '~' */ | ||
308 | + [43] = KEY_BACKSLASH, | ||
309 | [44] = KEY_Z, | ||
310 | [45] = KEY_X, | ||
311 | [46] = KEY_C, | ||
312 | @@ -149,45 +148,34 @@ static unsigned char atakbd_keycode[0x72] = { /* American layout */ | ||
313 | [66] = KEY_F8, | ||
314 | [67] = KEY_F9, | ||
315 | [68] = KEY_F10, | ||
316 | - [69] = KEY_ESC, | ||
317 | - [70] = KEY_DELETE, | ||
318 | - [71] = KEY_KP7, | ||
319 | - [72] = KEY_KP8, | ||
320 | - [73] = KEY_KP9, | ||
321 | + [71] = KEY_HOME, | ||
322 | + [72] = KEY_UP, | ||
323 | [74] = KEY_KPMINUS, | ||
324 | - [75] = KEY_KP4, | ||
325 | - [76] = KEY_KP5, | ||
326 | - [77] = KEY_KP6, | ||
327 | + [75] = KEY_LEFT, | ||
328 | + [77] = KEY_RIGHT, | ||
329 | [78] = KEY_KPPLUS, | ||
330 | - [79] = KEY_KP1, | ||
331 | - [80] = KEY_KP2, | ||
332 | - [81] = KEY_KP3, | ||
333 | - [82] = KEY_KP0, | ||
334 | - [83] = KEY_KPDOT, | ||
335 | - [90] = KEY_KPLEFTPAREN, | ||
336 | - [91] = KEY_KPRIGHTPAREN, | ||
337 | - [92] = KEY_KPASTERISK, /* FIXME */ | ||
338 | - [93] = KEY_KPASTERISK, | ||
339 | - [94] = KEY_KPPLUS, | ||
340 | - [95] = KEY_HELP, | ||
341 | + [80] = KEY_DOWN, | ||
342 | + [82] = KEY_INSERT, | ||
343 | + [83] = KEY_DELETE, | ||
344 | [96] = KEY_102ND, | ||
345 | - [97] = KEY_KPASTERISK, /* FIXME */ | ||
346 | - [98] = KEY_KPSLASH, | ||
347 | + [97] = KEY_UNDO, | ||
348 | + [98] = KEY_HELP, | ||
349 | [99] = KEY_KPLEFTPAREN, | ||
350 | [100] = KEY_KPRIGHTPAREN, | ||
351 | [101] = KEY_KPSLASH, | ||
352 | [102] = KEY_KPASTERISK, | ||
353 | - [103] = KEY_UP, | ||
354 | - [104] = KEY_KPASTERISK, /* FIXME */ | ||
355 | - [105] = KEY_LEFT, | ||
356 | - [106] = KEY_RIGHT, | ||
357 | - [107] = KEY_KPASTERISK, /* FIXME */ | ||
358 | - [108] = KEY_DOWN, | ||
359 | - [109] = KEY_KPASTERISK, /* FIXME */ | ||
360 | - [110] = KEY_KPASTERISK, /* FIXME */ | ||
361 | - [111] = KEY_KPASTERISK, /* FIXME */ | ||
362 | - [112] = KEY_KPASTERISK, /* FIXME */ | ||
363 | - [113] = KEY_KPASTERISK /* FIXME */ | ||
364 | + [103] = KEY_KP7, | ||
365 | + [104] = KEY_KP8, | ||
366 | + [105] = KEY_KP9, | ||
367 | + [106] = KEY_KP4, | ||
368 | + [107] = KEY_KP5, | ||
369 | + [108] = KEY_KP6, | ||
370 | + [109] = KEY_KP1, | ||
371 | + [110] = KEY_KP2, | ||
372 | + [111] = KEY_KP3, | ||
373 | + [112] = KEY_KP0, | ||
374 | + [113] = KEY_KPDOT, | ||
375 | + [114] = KEY_KPENTER, | ||
376 | }; | ||
377 | |||
378 | static struct input_dev *atakbd_dev; | ||
379 | @@ -195,21 +183,15 @@ static struct input_dev *atakbd_dev; | ||
380 | static void atakbd_interrupt(unsigned char scancode, char down) | ||
381 | { | ||
382 | |||
383 | - if (scancode < 0x72) { /* scancodes < 0xf2 are keys */ | ||
384 | + if (scancode < 0x73) { /* scancodes < 0xf3 are keys */ | ||
385 | |||
386 | // report raw events here? | ||
387 | |||
388 | scancode = atakbd_keycode[scancode]; | ||
389 | |||
390 | - if (scancode == KEY_CAPSLOCK) { /* CapsLock is a toggle switch key on Amiga */ | ||
391 | - input_report_key(atakbd_dev, scancode, 1); | ||
392 | - input_report_key(atakbd_dev, scancode, 0); | ||
393 | - input_sync(atakbd_dev); | ||
394 | - } else { | ||
395 | - input_report_key(atakbd_dev, scancode, down); | ||
396 | - input_sync(atakbd_dev); | ||
397 | - } | ||
398 | - } else /* scancodes >= 0xf2 are mouse data, most likely */ | ||
399 | + input_report_key(atakbd_dev, scancode, down); | ||
400 | + input_sync(atakbd_dev); | ||
401 | + } else /* scancodes >= 0xf3 are mouse data, most likely */ | ||
402 | printk(KERN_INFO "atakbd: unhandled scancode %x\n", scancode); | ||
403 | |||
404 | return; | ||
405 | diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c | ||
406 | index 16199b36a11e..bba1b9f2f782 100644 | ||
407 | --- a/drivers/iommu/amd_iommu.c | ||
408 | +++ b/drivers/iommu/amd_iommu.c | ||
409 | @@ -288,7 +288,13 @@ static u16 get_alias(struct device *dev) | ||
410 | |||
411 | /* The callers make sure that get_device_id() does not fail here */ | ||
412 | devid = get_device_id(dev); | ||
413 | + | ||
414 | + /* For ACPI HID devices, we simply return the devid as such */ | ||
415 | + if (!dev_is_pci(dev)) | ||
416 | + return devid; | ||
417 | + | ||
418 | ivrs_alias = amd_iommu_alias_table[devid]; | ||
419 | + | ||
420 | pci_for_each_dma_alias(pdev, __last_alias, &pci_alias); | ||
421 | |||
422 | if (ivrs_alias == pci_alias) | ||
423 | diff --git a/drivers/macintosh/rack-meter.c b/drivers/macintosh/rack-meter.c | ||
424 | index 25852e399ab2..c5aba26c604a 100644 | ||
425 | --- a/drivers/macintosh/rack-meter.c | ||
426 | +++ b/drivers/macintosh/rack-meter.c | ||
427 | @@ -52,8 +52,8 @@ struct rackmeter_dma { | ||
428 | struct rackmeter_cpu { | ||
429 | struct delayed_work sniffer; | ||
430 | struct rackmeter *rm; | ||
431 | - cputime64_t prev_wall; | ||
432 | - cputime64_t prev_idle; | ||
433 | + u64 prev_wall; | ||
434 | + u64 prev_idle; | ||
435 | int zero; | ||
436 | } ____cacheline_aligned; | ||
437 | |||
438 | @@ -81,7 +81,7 @@ static int rackmeter_ignore_nice; | ||
439 | /* This is copied from cpufreq_ondemand, maybe we should put it in | ||
440 | * a common header somewhere | ||
441 | */ | ||
442 | -static inline cputime64_t get_cpu_idle_time(unsigned int cpu) | ||
443 | +static inline u64 get_cpu_idle_time(unsigned int cpu) | ||
444 | { | ||
445 | u64 retval; | ||
446 | |||
447 | @@ -217,23 +217,23 @@ static void rackmeter_do_timer(struct work_struct *work) | ||
448 | container_of(work, struct rackmeter_cpu, sniffer.work); | ||
449 | struct rackmeter *rm = rcpu->rm; | ||
450 | unsigned int cpu = smp_processor_id(); | ||
451 | - cputime64_t cur_jiffies, total_idle_ticks; | ||
452 | - unsigned int total_ticks, idle_ticks; | ||
453 | + u64 cur_nsecs, total_idle_nsecs; | ||
454 | + u64 total_nsecs, idle_nsecs; | ||
455 | int i, offset, load, cumm, pause; | ||
456 | |||
457 | - cur_jiffies = jiffies64_to_cputime64(get_jiffies_64()); | ||
458 | - total_ticks = (unsigned int) (cur_jiffies - rcpu->prev_wall); | ||
459 | - rcpu->prev_wall = cur_jiffies; | ||
460 | + cur_nsecs = jiffies64_to_nsecs(get_jiffies_64()); | ||
461 | + total_nsecs = cur_nsecs - rcpu->prev_wall; | ||
462 | + rcpu->prev_wall = cur_nsecs; | ||
463 | |||
464 | - total_idle_ticks = get_cpu_idle_time(cpu); | ||
465 | - idle_ticks = (unsigned int) (total_idle_ticks - rcpu->prev_idle); | ||
466 | - idle_ticks = min(idle_ticks, total_ticks); | ||
467 | - rcpu->prev_idle = total_idle_ticks; | ||
468 | + total_idle_nsecs = get_cpu_idle_time(cpu); | ||
469 | + idle_nsecs = total_idle_nsecs - rcpu->prev_idle; | ||
470 | + idle_nsecs = min(idle_nsecs, total_nsecs); | ||
471 | + rcpu->prev_idle = total_idle_nsecs; | ||
472 | |||
473 | /* We do a very dumb calculation to update the LEDs for now, | ||
474 | * we'll do better once we have actual PWM implemented | ||
475 | */ | ||
476 | - load = (9 * (total_ticks - idle_ticks)) / total_ticks; | ||
477 | + load = div64_u64(9 * (total_nsecs - idle_nsecs), total_nsecs); | ||
478 | |||
479 | offset = cpu << 3; | ||
480 | cumm = 0; | ||
481 | @@ -278,7 +278,7 @@ static void rackmeter_init_cpu_sniffer(struct rackmeter *rm) | ||
482 | continue; | ||
483 | rcpu = &rm->cpu[cpu]; | ||
484 | rcpu->prev_idle = get_cpu_idle_time(cpu); | ||
485 | - rcpu->prev_wall = jiffies64_to_cputime64(get_jiffies_64()); | ||
486 | + rcpu->prev_wall = jiffies64_to_nsecs(get_jiffies_64()); | ||
487 | schedule_delayed_work_on(cpu, &rm->cpu[cpu].sniffer, | ||
488 | msecs_to_jiffies(CPU_SAMPLING_RATE)); | ||
489 | } | ||
490 | diff --git a/drivers/media/usb/dvb-usb-v2/af9035.c b/drivers/media/usb/dvb-usb-v2/af9035.c | ||
491 | index 8961dd732522..64be30d53847 100644 | ||
492 | --- a/drivers/media/usb/dvb-usb-v2/af9035.c | ||
493 | +++ b/drivers/media/usb/dvb-usb-v2/af9035.c | ||
494 | @@ -406,8 +406,10 @@ static int af9035_i2c_master_xfer(struct i2c_adapter *adap, | ||
495 | msg[0].addr == (state->af9033_i2c_addr[1] >> 1)) | ||
496 | reg |= 0x100000; | ||
497 | |||
498 | - ret = af9035_wr_regs(d, reg, &msg[0].buf[3], | ||
499 | - msg[0].len - 3); | ||
500 | + ret = (msg[0].len >= 3) ? af9035_wr_regs(d, reg, | ||
501 | + &msg[0].buf[3], | ||
502 | + msg[0].len - 3) | ||
503 | + : -EOPNOTSUPP; | ||
504 | } else { | ||
505 | /* I2C write */ | ||
506 | u8 buf[MAX_XFER_SIZE]; | ||
507 | diff --git a/drivers/net/ethernet/mellanox/mlx4/eq.c b/drivers/net/ethernet/mellanox/mlx4/eq.c | ||
508 | index 0509996957d9..e70d6fe504b8 100644 | ||
509 | --- a/drivers/net/ethernet/mellanox/mlx4/eq.c | ||
510 | +++ b/drivers/net/ethernet/mellanox/mlx4/eq.c | ||
511 | @@ -240,7 +240,8 @@ static void mlx4_set_eq_affinity_hint(struct mlx4_priv *priv, int vec) | ||
512 | struct mlx4_dev *dev = &priv->dev; | ||
513 | struct mlx4_eq *eq = &priv->eq_table.eq[vec]; | ||
514 | |||
515 | - if (!eq->affinity_mask || cpumask_empty(eq->affinity_mask)) | ||
516 | + if (!cpumask_available(eq->affinity_mask) || | ||
517 | + cpumask_empty(eq->affinity_mask)) | ||
518 | return; | ||
519 | |||
520 | hint_err = irq_set_affinity_hint(eq->irq, eq->affinity_mask); | ||
521 | diff --git a/drivers/net/ethernet/renesas/ravb.h b/drivers/net/ethernet/renesas/ravb.h | ||
522 | index f1109661a533..410399070639 100644 | ||
523 | --- a/drivers/net/ethernet/renesas/ravb.h | ||
524 | +++ b/drivers/net/ethernet/renesas/ravb.h | ||
525 | @@ -421,6 +421,7 @@ enum EIS_BIT { | ||
526 | EIS_CULF1 = 0x00000080, | ||
527 | EIS_TFFF = 0x00000100, | ||
528 | EIS_QFS = 0x00010000, | ||
529 | + EIS_RESERVED = (GENMASK(31, 17) | GENMASK(15, 11)), | ||
530 | }; | ||
531 | |||
532 | /* RIC0 */ | ||
533 | @@ -465,6 +466,7 @@ enum RIS0_BIT { | ||
534 | RIS0_FRF15 = 0x00008000, | ||
535 | RIS0_FRF16 = 0x00010000, | ||
536 | RIS0_FRF17 = 0x00020000, | ||
537 | + RIS0_RESERVED = GENMASK(31, 18), | ||
538 | }; | ||
539 | |||
540 | /* RIC1 */ | ||
541 | @@ -521,6 +523,7 @@ enum RIS2_BIT { | ||
542 | RIS2_QFF16 = 0x00010000, | ||
543 | RIS2_QFF17 = 0x00020000, | ||
544 | RIS2_RFFF = 0x80000000, | ||
545 | + RIS2_RESERVED = GENMASK(30, 18), | ||
546 | }; | ||
547 | |||
548 | /* TIC */ | ||
549 | @@ -537,6 +540,7 @@ enum TIS_BIT { | ||
550 | TIS_FTF1 = 0x00000002, /* Undocumented? */ | ||
551 | TIS_TFUF = 0x00000100, | ||
552 | TIS_TFWF = 0x00000200, | ||
553 | + TIS_RESERVED = (GENMASK(31, 20) | GENMASK(15, 12) | GENMASK(7, 4)) | ||
554 | }; | ||
555 | |||
556 | /* ISS */ | ||
557 | @@ -610,6 +614,7 @@ enum GIC_BIT { | ||
558 | enum GIS_BIT { | ||
559 | GIS_PTCF = 0x00000001, /* Undocumented? */ | ||
560 | GIS_PTMF = 0x00000004, | ||
561 | + GIS_RESERVED = GENMASK(15, 10), | ||
562 | }; | ||
563 | |||
564 | /* GIE (R-Car Gen3 only) */ | ||
565 | diff --git a/drivers/net/ethernet/renesas/ravb_main.c b/drivers/net/ethernet/renesas/ravb_main.c | ||
566 | index 307ecd500dac..71836a7f56b0 100644 | ||
567 | --- a/drivers/net/ethernet/renesas/ravb_main.c | ||
568 | +++ b/drivers/net/ethernet/renesas/ravb_main.c | ||
569 | @@ -717,10 +717,11 @@ static void ravb_error_interrupt(struct net_device *ndev) | ||
570 | u32 eis, ris2; | ||
571 | |||
572 | eis = ravb_read(ndev, EIS); | ||
573 | - ravb_write(ndev, ~EIS_QFS, EIS); | ||
574 | + ravb_write(ndev, ~(EIS_QFS | EIS_RESERVED), EIS); | ||
575 | if (eis & EIS_QFS) { | ||
576 | ris2 = ravb_read(ndev, RIS2); | ||
577 | - ravb_write(ndev, ~(RIS2_QFF0 | RIS2_RFFF), RIS2); | ||
578 | + ravb_write(ndev, ~(RIS2_QFF0 | RIS2_RFFF | RIS2_RESERVED), | ||
579 | + RIS2); | ||
580 | |||
581 | /* Receive Descriptor Empty int */ | ||
582 | if (ris2 & RIS2_QFF0) | ||
583 | @@ -773,7 +774,7 @@ static bool ravb_timestamp_interrupt(struct net_device *ndev) | ||
584 | u32 tis = ravb_read(ndev, TIS); | ||
585 | |||
586 | if (tis & TIS_TFUF) { | ||
587 | - ravb_write(ndev, ~TIS_TFUF, TIS); | ||
588 | + ravb_write(ndev, ~(TIS_TFUF | TIS_RESERVED), TIS); | ||
589 | ravb_get_tx_tstamp(ndev); | ||
590 | return true; | ||
591 | } | ||
592 | @@ -908,7 +909,7 @@ static int ravb_poll(struct napi_struct *napi, int budget) | ||
593 | /* Processing RX Descriptor Ring */ | ||
594 | if (ris0 & mask) { | ||
595 | /* Clear RX interrupt */ | ||
596 | - ravb_write(ndev, ~mask, RIS0); | ||
597 | + ravb_write(ndev, ~(mask | RIS0_RESERVED), RIS0); | ||
598 | if (ravb_rx(ndev, "a, q)) | ||
599 | goto out; | ||
600 | } | ||
601 | @@ -916,7 +917,7 @@ static int ravb_poll(struct napi_struct *napi, int budget) | ||
602 | if (tis & mask) { | ||
603 | spin_lock_irqsave(&priv->lock, flags); | ||
604 | /* Clear TX interrupt */ | ||
605 | - ravb_write(ndev, ~mask, TIS); | ||
606 | + ravb_write(ndev, ~(mask | TIS_RESERVED), TIS); | ||
607 | ravb_tx_free(ndev, q, true); | ||
608 | netif_wake_subqueue(ndev, q); | ||
609 | mmiowb(); | ||
610 | diff --git a/drivers/net/ethernet/renesas/ravb_ptp.c b/drivers/net/ethernet/renesas/ravb_ptp.c | ||
611 | index eede70ec37f8..9e3222fd69f9 100644 | ||
612 | --- a/drivers/net/ethernet/renesas/ravb_ptp.c | ||
613 | +++ b/drivers/net/ethernet/renesas/ravb_ptp.c | ||
614 | @@ -319,7 +319,7 @@ void ravb_ptp_interrupt(struct net_device *ndev) | ||
615 | } | ||
616 | } | ||
617 | |||
618 | - ravb_write(ndev, ~gis, GIS); | ||
619 | + ravb_write(ndev, ~(gis | GIS_RESERVED), GIS); | ||
620 | } | ||
621 | |||
622 | void ravb_ptp_init(struct net_device *ndev, struct platform_device *pdev) | ||
623 | diff --git a/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c b/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c | ||
624 | index 04148438d7ec..5ed28111c3c3 100644 | ||
625 | --- a/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c | ||
626 | +++ b/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c | ||
627 | @@ -3342,11 +3342,10 @@ static int ibmvscsis_probe(struct vio_dev *vdev, | ||
628 | vscsi->dds.window[LOCAL].liobn, | ||
629 | vscsi->dds.window[REMOTE].liobn); | ||
630 | |||
631 | - strcpy(vscsi->eye, "VSCSI "); | ||
632 | - strncat(vscsi->eye, vdev->name, MAX_EYE); | ||
633 | + snprintf(vscsi->eye, sizeof(vscsi->eye), "VSCSI %s", vdev->name); | ||
634 | |||
635 | vscsi->dds.unit_id = vdev->unit_address; | ||
636 | - strncpy(vscsi->dds.partition_name, partition_name, | ||
637 | + strscpy(vscsi->dds.partition_name, partition_name, | ||
638 | sizeof(vscsi->dds.partition_name)); | ||
639 | vscsi->dds.partition_num = partition_number; | ||
640 | |||
641 | diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c | ||
642 | index f8b6bf56c48e..ab999c4444b8 100644 | ||
643 | --- a/drivers/scsi/sd.c | ||
644 | +++ b/drivers/scsi/sd.c | ||
645 | @@ -1158,7 +1158,8 @@ static int sd_init_command(struct scsi_cmnd *cmd) | ||
646 | case REQ_OP_WRITE: | ||
647 | return sd_setup_read_write_cmnd(cmd); | ||
648 | default: | ||
649 | - BUG(); | ||
650 | + WARN_ON_ONCE(1); | ||
651 | + return BLKPREP_KILL; | ||
652 | } | ||
653 | } | ||
654 | |||
655 | diff --git a/drivers/usb/gadget/function/u_serial.c b/drivers/usb/gadget/function/u_serial.c | ||
656 | index e0cd1e4c8892..2f151e0aa6da 100644 | ||
657 | --- a/drivers/usb/gadget/function/u_serial.c | ||
658 | +++ b/drivers/usb/gadget/function/u_serial.c | ||
659 | @@ -537,7 +537,7 @@ static void gs_rx_push(unsigned long _port) | ||
660 | } | ||
661 | |||
662 | /* push data to (open) tty */ | ||
663 | - if (req->actual) { | ||
664 | + if (req->actual && tty) { | ||
665 | char *packet = req->buf; | ||
666 | unsigned size = req->actual; | ||
667 | unsigned n; | ||
668 | diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h | ||
669 | index 43e27d8ec770..567a6c7af677 100644 | ||
670 | --- a/fs/ext4/ext4.h | ||
671 | +++ b/fs/ext4/ext4.h | ||
672 | @@ -3038,9 +3038,6 @@ extern struct buffer_head *ext4_get_first_inline_block(struct inode *inode, | ||
673 | extern int ext4_inline_data_fiemap(struct inode *inode, | ||
674 | struct fiemap_extent_info *fieinfo, | ||
675 | int *has_inline, __u64 start, __u64 len); | ||
676 | -extern int ext4_try_to_evict_inline_data(handle_t *handle, | ||
677 | - struct inode *inode, | ||
678 | - int needed); | ||
679 | extern void ext4_inline_data_truncate(struct inode *inode, int *has_inline); | ||
680 | |||
681 | extern int ext4_convert_inline_data(struct inode *inode); | ||
682 | diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c | ||
683 | index 211539a7adfc..6779a9f1de3b 100644 | ||
684 | --- a/fs/ext4/inline.c | ||
685 | +++ b/fs/ext4/inline.c | ||
686 | @@ -889,11 +889,11 @@ retry_journal: | ||
687 | flags |= AOP_FLAG_NOFS; | ||
688 | |||
689 | if (ret == -ENOSPC) { | ||
690 | + ext4_journal_stop(handle); | ||
691 | ret = ext4_da_convert_inline_data_to_extent(mapping, | ||
692 | inode, | ||
693 | flags, | ||
694 | fsdata); | ||
695 | - ext4_journal_stop(handle); | ||
696 | if (ret == -ENOSPC && | ||
697 | ext4_should_retry_alloc(inode->i_sb, &retries)) | ||
698 | goto retry_journal; | ||
699 | @@ -1865,42 +1865,6 @@ out: | ||
700 | return (error < 0 ? error : 0); | ||
701 | } | ||
702 | |||
703 | -/* | ||
704 | - * Called during xattr set, and if we can sparse space 'needed', | ||
705 | - * just create the extent tree evict the data to the outer block. | ||
706 | - * | ||
707 | - * We use jbd2 instead of page cache to move data to the 1st block | ||
708 | - * so that the whole transaction can be committed as a whole and | ||
709 | - * the data isn't lost because of the delayed page cache write. | ||
710 | - */ | ||
711 | -int ext4_try_to_evict_inline_data(handle_t *handle, | ||
712 | - struct inode *inode, | ||
713 | - int needed) | ||
714 | -{ | ||
715 | - int error; | ||
716 | - struct ext4_xattr_entry *entry; | ||
717 | - struct ext4_inode *raw_inode; | ||
718 | - struct ext4_iloc iloc; | ||
719 | - | ||
720 | - error = ext4_get_inode_loc(inode, &iloc); | ||
721 | - if (error) | ||
722 | - return error; | ||
723 | - | ||
724 | - raw_inode = ext4_raw_inode(&iloc); | ||
725 | - entry = (struct ext4_xattr_entry *)((void *)raw_inode + | ||
726 | - EXT4_I(inode)->i_inline_off); | ||
727 | - if (EXT4_XATTR_LEN(entry->e_name_len) + | ||
728 | - EXT4_XATTR_SIZE(le32_to_cpu(entry->e_value_size)) < needed) { | ||
729 | - error = -ENOSPC; | ||
730 | - goto out; | ||
731 | - } | ||
732 | - | ||
733 | - error = ext4_convert_inline_data_nolock(handle, inode, &iloc); | ||
734 | -out: | ||
735 | - brelse(iloc.bh); | ||
736 | - return error; | ||
737 | -} | ||
738 | - | ||
739 | void ext4_inline_data_truncate(struct inode *inode, int *has_inline) | ||
740 | { | ||
741 | handle_t *handle; | ||
742 | diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c | ||
743 | index 7d6da09e637b..38385bcb9148 100644 | ||
744 | --- a/fs/ext4/xattr.c | ||
745 | +++ b/fs/ext4/xattr.c | ||
746 | @@ -1086,22 +1086,8 @@ int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode, | ||
747 | if (EXT4_I(inode)->i_extra_isize == 0) | ||
748 | return -ENOSPC; | ||
749 | error = ext4_xattr_set_entry(i, s, inode); | ||
750 | - if (error) { | ||
751 | - if (error == -ENOSPC && | ||
752 | - ext4_has_inline_data(inode)) { | ||
753 | - error = ext4_try_to_evict_inline_data(handle, inode, | ||
754 | - EXT4_XATTR_LEN(strlen(i->name) + | ||
755 | - EXT4_XATTR_SIZE(i->value_len))); | ||
756 | - if (error) | ||
757 | - return error; | ||
758 | - error = ext4_xattr_ibody_find(inode, i, is); | ||
759 | - if (error) | ||
760 | - return error; | ||
761 | - error = ext4_xattr_set_entry(i, s, inode); | ||
762 | - } | ||
763 | - if (error) | ||
764 | - return error; | ||
765 | - } | ||
766 | + if (error) | ||
767 | + return error; | ||
768 | header = IHDR(inode, ext4_raw_inode(&is->iloc)); | ||
769 | if (!IS_LAST_ENTRY(s->first)) { | ||
770 | header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC); | ||
771 | diff --git a/fs/proc/stat.c b/fs/proc/stat.c | ||
772 | index d700c42b3572..44475a44cbf1 100644 | ||
773 | --- a/fs/proc/stat.c | ||
774 | +++ b/fs/proc/stat.c | ||
775 | @@ -21,23 +21,23 @@ | ||
776 | |||
777 | #ifdef arch_idle_time | ||
778 | |||
779 | -static cputime64_t get_idle_time(int cpu) | ||
780 | +static u64 get_idle_time(int cpu) | ||
781 | { | ||
782 | - cputime64_t idle; | ||
783 | + u64 idle; | ||
784 | |||
785 | idle = kcpustat_cpu(cpu).cpustat[CPUTIME_IDLE]; | ||
786 | if (cpu_online(cpu) && !nr_iowait_cpu(cpu)) | ||
787 | - idle += arch_idle_time(cpu); | ||
788 | + idle += cputime_to_nsecs(arch_idle_time(cpu)); | ||
789 | return idle; | ||
790 | } | ||
791 | |||
792 | -static cputime64_t get_iowait_time(int cpu) | ||
793 | +static u64 get_iowait_time(int cpu) | ||
794 | { | ||
795 | - cputime64_t iowait; | ||
796 | + u64 iowait; | ||
797 | |||
798 | iowait = kcpustat_cpu(cpu).cpustat[CPUTIME_IOWAIT]; | ||
799 | if (cpu_online(cpu) && nr_iowait_cpu(cpu)) | ||
800 | - iowait += arch_idle_time(cpu); | ||
801 | + iowait += cputime_to_nsecs(arch_idle_time(cpu)); | ||
802 | return iowait; | ||
803 | } | ||
804 | |||
805 | @@ -45,32 +45,32 @@ static cputime64_t get_iowait_time(int cpu) | ||
806 | |||
807 | static u64 get_idle_time(int cpu) | ||
808 | { | ||
809 | - u64 idle, idle_time = -1ULL; | ||
810 | + u64 idle, idle_usecs = -1ULL; | ||
811 | |||
812 | if (cpu_online(cpu)) | ||
813 | - idle_time = get_cpu_idle_time_us(cpu, NULL); | ||
814 | + idle_usecs = get_cpu_idle_time_us(cpu, NULL); | ||
815 | |||
816 | - if (idle_time == -1ULL) | ||
817 | + if (idle_usecs == -1ULL) | ||
818 | /* !NO_HZ or cpu offline so we can rely on cpustat.idle */ | ||
819 | idle = kcpustat_cpu(cpu).cpustat[CPUTIME_IDLE]; | ||
820 | else | ||
821 | - idle = usecs_to_cputime64(idle_time); | ||
822 | + idle = idle_usecs * NSEC_PER_USEC; | ||
823 | |||
824 | return idle; | ||
825 | } | ||
826 | |||
827 | static u64 get_iowait_time(int cpu) | ||
828 | { | ||
829 | - u64 iowait, iowait_time = -1ULL; | ||
830 | + u64 iowait, iowait_usecs = -1ULL; | ||
831 | |||
832 | if (cpu_online(cpu)) | ||
833 | - iowait_time = get_cpu_iowait_time_us(cpu, NULL); | ||
834 | + iowait_usecs = get_cpu_iowait_time_us(cpu, NULL); | ||
835 | |||
836 | - if (iowait_time == -1ULL) | ||
837 | + if (iowait_usecs == -1ULL) | ||
838 | /* !NO_HZ or cpu offline so we can rely on cpustat.iowait */ | ||
839 | iowait = kcpustat_cpu(cpu).cpustat[CPUTIME_IOWAIT]; | ||
840 | else | ||
841 | - iowait = usecs_to_cputime64(iowait_time); | ||
842 | + iowait = iowait_usecs * NSEC_PER_USEC; | ||
843 | |||
844 | return iowait; | ||
845 | } | ||
846 | @@ -115,16 +115,16 @@ static int show_stat(struct seq_file *p, void *v) | ||
847 | } | ||
848 | sum += arch_irq_stat(); | ||
849 | |||
850 | - seq_put_decimal_ull(p, "cpu ", cputime64_to_clock_t(user)); | ||
851 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(nice)); | ||
852 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(system)); | ||
853 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(idle)); | ||
854 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(iowait)); | ||
855 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(irq)); | ||
856 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(softirq)); | ||
857 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(steal)); | ||
858 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(guest)); | ||
859 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(guest_nice)); | ||
860 | + seq_put_decimal_ull(p, "cpu ", nsec_to_clock_t(user)); | ||
861 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(nice)); | ||
862 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(system)); | ||
863 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(idle)); | ||
864 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(iowait)); | ||
865 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(irq)); | ||
866 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(softirq)); | ||
867 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(steal)); | ||
868 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(guest)); | ||
869 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(guest_nice)); | ||
870 | seq_putc(p, '\n'); | ||
871 | |||
872 | for_each_online_cpu(i) { | ||
873 | @@ -140,16 +140,16 @@ static int show_stat(struct seq_file *p, void *v) | ||
874 | guest = kcpustat_cpu(i).cpustat[CPUTIME_GUEST]; | ||
875 | guest_nice = kcpustat_cpu(i).cpustat[CPUTIME_GUEST_NICE]; | ||
876 | seq_printf(p, "cpu%d", i); | ||
877 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(user)); | ||
878 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(nice)); | ||
879 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(system)); | ||
880 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(idle)); | ||
881 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(iowait)); | ||
882 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(irq)); | ||
883 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(softirq)); | ||
884 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(steal)); | ||
885 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(guest)); | ||
886 | - seq_put_decimal_ull(p, " ", cputime64_to_clock_t(guest_nice)); | ||
887 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(user)); | ||
888 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(nice)); | ||
889 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(system)); | ||
890 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(idle)); | ||
891 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(iowait)); | ||
892 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(irq)); | ||
893 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(softirq)); | ||
894 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(steal)); | ||
895 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(guest)); | ||
896 | + seq_put_decimal_ull(p, " ", nsec_to_clock_t(guest_nice)); | ||
897 | seq_putc(p, '\n'); | ||
898 | } | ||
899 | seq_put_decimal_ull(p, "intr ", (unsigned long long)sum); | ||
900 | diff --git a/fs/proc/uptime.c b/fs/proc/uptime.c | ||
901 | index 33de567c25af..7981c4ffe787 100644 | ||
902 | --- a/fs/proc/uptime.c | ||
903 | +++ b/fs/proc/uptime.c | ||
904 | @@ -5,23 +5,20 @@ | ||
905 | #include <linux/seq_file.h> | ||
906 | #include <linux/time.h> | ||
907 | #include <linux/kernel_stat.h> | ||
908 | -#include <linux/cputime.h> | ||
909 | |||
910 | static int uptime_proc_show(struct seq_file *m, void *v) | ||
911 | { | ||
912 | struct timespec uptime; | ||
913 | struct timespec idle; | ||
914 | - u64 idletime; | ||
915 | u64 nsec; | ||
916 | u32 rem; | ||
917 | int i; | ||
918 | |||
919 | - idletime = 0; | ||
920 | + nsec = 0; | ||
921 | for_each_possible_cpu(i) | ||
922 | - idletime += (__force u64) kcpustat_cpu(i).cpustat[CPUTIME_IDLE]; | ||
923 | + nsec += (__force u64) kcpustat_cpu(i).cpustat[CPUTIME_IDLE]; | ||
924 | |||
925 | get_monotonic_boottime(&uptime); | ||
926 | - nsec = cputime64_to_jiffies64(idletime) * TICK_NSEC; | ||
927 | idle.tv_sec = div_u64_rem(nsec, NSEC_PER_SEC, &rem); | ||
928 | idle.tv_nsec = rem; | ||
929 | seq_printf(m, "%lu.%02lu %lu.%02lu\n", | ||
930 | diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h | ||
931 | index e35e6de633b9..9b9f65d99873 100644 | ||
932 | --- a/include/linux/huge_mm.h | ||
933 | +++ b/include/linux/huge_mm.h | ||
934 | @@ -22,7 +22,7 @@ extern int mincore_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd, | ||
935 | unsigned char *vec); | ||
936 | extern bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr, | ||
937 | unsigned long new_addr, unsigned long old_end, | ||
938 | - pmd_t *old_pmd, pmd_t *new_pmd, bool *need_flush); | ||
939 | + pmd_t *old_pmd, pmd_t *new_pmd); | ||
940 | extern int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd, | ||
941 | unsigned long addr, pgprot_t newprot, | ||
942 | int prot_numa); | ||
943 | diff --git a/kernel/sched/cpuacct.c b/kernel/sched/cpuacct.c | ||
944 | index bc0b309c3f19..4c882791c10c 100644 | ||
945 | --- a/kernel/sched/cpuacct.c | ||
946 | +++ b/kernel/sched/cpuacct.c | ||
947 | @@ -297,7 +297,7 @@ static int cpuacct_stats_show(struct seq_file *sf, void *v) | ||
948 | for (stat = 0; stat < CPUACCT_STAT_NSTATS; stat++) { | ||
949 | seq_printf(sf, "%s %lld\n", | ||
950 | cpuacct_stat_desc[stat], | ||
951 | - cputime64_to_clock_t(val[stat])); | ||
952 | + nsec_to_clock_t(val[stat])); | ||
953 | } | ||
954 | |||
955 | return 0; | ||
956 | diff --git a/kernel/sched/cputime.c b/kernel/sched/cputime.c | ||
957 | index 5ebee3164e64..448d6426fa5f 100644 | ||
958 | --- a/kernel/sched/cputime.c | ||
959 | +++ b/kernel/sched/cputime.c | ||
960 | @@ -37,6 +37,18 @@ void disable_sched_clock_irqtime(void) | ||
961 | sched_clock_irqtime = 0; | ||
962 | } | ||
963 | |||
964 | +static void irqtime_account_delta(struct irqtime *irqtime, u64 delta, | ||
965 | + enum cpu_usage_stat idx) | ||
966 | +{ | ||
967 | + u64 *cpustat = kcpustat_this_cpu->cpustat; | ||
968 | + | ||
969 | + u64_stats_update_begin(&irqtime->sync); | ||
970 | + cpustat[idx] += delta; | ||
971 | + irqtime->total += delta; | ||
972 | + irqtime->tick_delta += delta; | ||
973 | + u64_stats_update_end(&irqtime->sync); | ||
974 | +} | ||
975 | + | ||
976 | /* | ||
977 | * Called before incrementing preempt_count on {soft,}irq_enter | ||
978 | * and before decrementing preempt_count on {soft,}irq_exit. | ||
979 | @@ -54,7 +66,6 @@ void irqtime_account_irq(struct task_struct *curr) | ||
980 | delta = sched_clock_cpu(cpu) - irqtime->irq_start_time; | ||
981 | irqtime->irq_start_time += delta; | ||
982 | |||
983 | - u64_stats_update_begin(&irqtime->sync); | ||
984 | /* | ||
985 | * We do not account for softirq time from ksoftirqd here. | ||
986 | * We want to continue accounting softirq time to ksoftirqd thread | ||
987 | @@ -62,48 +73,29 @@ void irqtime_account_irq(struct task_struct *curr) | ||
988 | * that do not consume any time, but still wants to run. | ||
989 | */ | ||
990 | if (hardirq_count()) | ||
991 | - irqtime->hardirq_time += delta; | ||
992 | + irqtime_account_delta(irqtime, delta, CPUTIME_IRQ); | ||
993 | else if (in_serving_softirq() && curr != this_cpu_ksoftirqd()) | ||
994 | - irqtime->softirq_time += delta; | ||
995 | - | ||
996 | - u64_stats_update_end(&irqtime->sync); | ||
997 | + irqtime_account_delta(irqtime, delta, CPUTIME_SOFTIRQ); | ||
998 | } | ||
999 | EXPORT_SYMBOL_GPL(irqtime_account_irq); | ||
1000 | |||
1001 | -static cputime_t irqtime_account_update(u64 irqtime, int idx, cputime_t maxtime) | ||
1002 | +static cputime_t irqtime_tick_accounted(cputime_t maxtime) | ||
1003 | { | ||
1004 | - u64 *cpustat = kcpustat_this_cpu->cpustat; | ||
1005 | - cputime_t irq_cputime; | ||
1006 | - | ||
1007 | - irq_cputime = nsecs_to_cputime64(irqtime) - cpustat[idx]; | ||
1008 | - irq_cputime = min(irq_cputime, maxtime); | ||
1009 | - cpustat[idx] += irq_cputime; | ||
1010 | - | ||
1011 | - return irq_cputime; | ||
1012 | -} | ||
1013 | + struct irqtime *irqtime = this_cpu_ptr(&cpu_irqtime); | ||
1014 | + cputime_t delta; | ||
1015 | |||
1016 | -static cputime_t irqtime_account_hi_update(cputime_t maxtime) | ||
1017 | -{ | ||
1018 | - return irqtime_account_update(__this_cpu_read(cpu_irqtime.hardirq_time), | ||
1019 | - CPUTIME_IRQ, maxtime); | ||
1020 | -} | ||
1021 | + delta = nsecs_to_cputime(irqtime->tick_delta); | ||
1022 | + delta = min(delta, maxtime); | ||
1023 | + irqtime->tick_delta -= cputime_to_nsecs(delta); | ||
1024 | |||
1025 | -static cputime_t irqtime_account_si_update(cputime_t maxtime) | ||
1026 | -{ | ||
1027 | - return irqtime_account_update(__this_cpu_read(cpu_irqtime.softirq_time), | ||
1028 | - CPUTIME_SOFTIRQ, maxtime); | ||
1029 | + return delta; | ||
1030 | } | ||
1031 | |||
1032 | #else /* CONFIG_IRQ_TIME_ACCOUNTING */ | ||
1033 | |||
1034 | #define sched_clock_irqtime (0) | ||
1035 | |||
1036 | -static cputime_t irqtime_account_hi_update(cputime_t dummy) | ||
1037 | -{ | ||
1038 | - return 0; | ||
1039 | -} | ||
1040 | - | ||
1041 | -static cputime_t irqtime_account_si_update(cputime_t dummy) | ||
1042 | +static cputime_t irqtime_tick_accounted(cputime_t dummy) | ||
1043 | { | ||
1044 | return 0; | ||
1045 | } | ||
1046 | @@ -143,7 +135,7 @@ void account_user_time(struct task_struct *p, cputime_t cputime, | ||
1047 | index = (task_nice(p) > 0) ? CPUTIME_NICE : CPUTIME_USER; | ||
1048 | |||
1049 | /* Add user time to cpustat. */ | ||
1050 | - task_group_account_field(p, index, (__force u64) cputime); | ||
1051 | + task_group_account_field(p, index, cputime_to_nsecs(cputime)); | ||
1052 | |||
1053 | /* Account for user time used */ | ||
1054 | acct_account_cputime(p); | ||
1055 | @@ -168,11 +160,11 @@ static void account_guest_time(struct task_struct *p, cputime_t cputime, | ||
1056 | |||
1057 | /* Add guest time to cpustat. */ | ||
1058 | if (task_nice(p) > 0) { | ||
1059 | - cpustat[CPUTIME_NICE] += (__force u64) cputime; | ||
1060 | - cpustat[CPUTIME_GUEST_NICE] += (__force u64) cputime; | ||
1061 | + cpustat[CPUTIME_NICE] += cputime_to_nsecs(cputime); | ||
1062 | + cpustat[CPUTIME_GUEST_NICE] += cputime_to_nsecs(cputime); | ||
1063 | } else { | ||
1064 | - cpustat[CPUTIME_USER] += (__force u64) cputime; | ||
1065 | - cpustat[CPUTIME_GUEST] += (__force u64) cputime; | ||
1066 | + cpustat[CPUTIME_USER] += cputime_to_nsecs(cputime); | ||
1067 | + cpustat[CPUTIME_GUEST] += cputime_to_nsecs(cputime); | ||
1068 | } | ||
1069 | } | ||
1070 | |||
1071 | @@ -193,7 +185,7 @@ void __account_system_time(struct task_struct *p, cputime_t cputime, | ||
1072 | account_group_system_time(p, cputime); | ||
1073 | |||
1074 | /* Add system time to cpustat. */ | ||
1075 | - task_group_account_field(p, index, (__force u64) cputime); | ||
1076 | + task_group_account_field(p, index, cputime_to_nsecs(cputime)); | ||
1077 | |||
1078 | /* Account for system time used */ | ||
1079 | acct_account_cputime(p); | ||
1080 | @@ -234,7 +226,7 @@ void account_steal_time(cputime_t cputime) | ||
1081 | { | ||
1082 | u64 *cpustat = kcpustat_this_cpu->cpustat; | ||
1083 | |||
1084 | - cpustat[CPUTIME_STEAL] += (__force u64) cputime; | ||
1085 | + cpustat[CPUTIME_STEAL] += cputime_to_nsecs(cputime); | ||
1086 | } | ||
1087 | |||
1088 | /* | ||
1089 | @@ -247,9 +239,9 @@ void account_idle_time(cputime_t cputime) | ||
1090 | struct rq *rq = this_rq(); | ||
1091 | |||
1092 | if (atomic_read(&rq->nr_iowait) > 0) | ||
1093 | - cpustat[CPUTIME_IOWAIT] += (__force u64) cputime; | ||
1094 | + cpustat[CPUTIME_IOWAIT] += cputime_to_nsecs(cputime); | ||
1095 | else | ||
1096 | - cpustat[CPUTIME_IDLE] += (__force u64) cputime; | ||
1097 | + cpustat[CPUTIME_IDLE] += cputime_to_nsecs(cputime); | ||
1098 | } | ||
1099 | |||
1100 | /* | ||
1101 | @@ -290,10 +282,7 @@ static inline cputime_t account_other_time(cputime_t max) | ||
1102 | accounted = steal_account_process_time(max); | ||
1103 | |||
1104 | if (accounted < max) | ||
1105 | - accounted += irqtime_account_hi_update(max - accounted); | ||
1106 | - | ||
1107 | - if (accounted < max) | ||
1108 | - accounted += irqtime_account_si_update(max - accounted); | ||
1109 | + accounted += irqtime_tick_accounted(max - accounted); | ||
1110 | |||
1111 | return accounted; | ||
1112 | } | ||
1113 | diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h | ||
1114 | index f564a1d2c9d5..923cc35e8490 100644 | ||
1115 | --- a/kernel/sched/sched.h | ||
1116 | +++ b/kernel/sched/sched.h | ||
1117 | @@ -4,6 +4,7 @@ | ||
1118 | #include <linux/sched/rt.h> | ||
1119 | #include <linux/u64_stats_sync.h> | ||
1120 | #include <linux/sched/deadline.h> | ||
1121 | +#include <linux/kernel_stat.h> | ||
1122 | #include <linux/binfmts.h> | ||
1123 | #include <linux/mutex.h> | ||
1124 | #include <linux/spinlock.h> | ||
1125 | @@ -1742,14 +1743,19 @@ static inline void nohz_balance_exit_idle(unsigned int cpu) { } | ||
1126 | |||
1127 | #ifdef CONFIG_IRQ_TIME_ACCOUNTING | ||
1128 | struct irqtime { | ||
1129 | - u64 hardirq_time; | ||
1130 | - u64 softirq_time; | ||
1131 | + u64 total; | ||
1132 | + u64 tick_delta; | ||
1133 | u64 irq_start_time; | ||
1134 | struct u64_stats_sync sync; | ||
1135 | }; | ||
1136 | |||
1137 | DECLARE_PER_CPU(struct irqtime, cpu_irqtime); | ||
1138 | |||
1139 | +/* | ||
1140 | + * Returns the irqtime minus the softirq time computed by ksoftirqd. | ||
1141 | + * Otherwise ksoftirqd's sum_exec_runtime is substracted its own runtime | ||
1142 | + * and never move forward. | ||
1143 | + */ | ||
1144 | static inline u64 irq_time_read(int cpu) | ||
1145 | { | ||
1146 | struct irqtime *irqtime = &per_cpu(cpu_irqtime, cpu); | ||
1147 | @@ -1758,7 +1764,7 @@ static inline u64 irq_time_read(int cpu) | ||
1148 | |||
1149 | do { | ||
1150 | seq = __u64_stats_fetch_begin(&irqtime->sync); | ||
1151 | - total = irqtime->softirq_time + irqtime->hardirq_time; | ||
1152 | + total = irqtime->total; | ||
1153 | } while (__u64_stats_fetch_retry(&irqtime->sync, seq)); | ||
1154 | |||
1155 | return total; | ||
1156 | diff --git a/mm/huge_memory.c b/mm/huge_memory.c | ||
1157 | index e4c6c3edaf6a..9f7bba700e4e 100644 | ||
1158 | --- a/mm/huge_memory.c | ||
1159 | +++ b/mm/huge_memory.c | ||
1160 | @@ -1445,7 +1445,7 @@ int zap_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma, | ||
1161 | |||
1162 | bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr, | ||
1163 | unsigned long new_addr, unsigned long old_end, | ||
1164 | - pmd_t *old_pmd, pmd_t *new_pmd, bool *need_flush) | ||
1165 | + pmd_t *old_pmd, pmd_t *new_pmd) | ||
1166 | { | ||
1167 | spinlock_t *old_ptl, *new_ptl; | ||
1168 | pmd_t pmd; | ||
1169 | @@ -1476,7 +1476,7 @@ bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr, | ||
1170 | if (new_ptl != old_ptl) | ||
1171 | spin_lock_nested(new_ptl, SINGLE_DEPTH_NESTING); | ||
1172 | pmd = pmdp_huge_get_and_clear(mm, old_addr, old_pmd); | ||
1173 | - if (pmd_present(pmd) && pmd_dirty(pmd)) | ||
1174 | + if (pmd_present(pmd)) | ||
1175 | force_flush = true; | ||
1176 | VM_BUG_ON(!pmd_none(*new_pmd)); | ||
1177 | |||
1178 | @@ -1487,12 +1487,10 @@ bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr, | ||
1179 | pgtable_trans_huge_deposit(mm, new_pmd, pgtable); | ||
1180 | } | ||
1181 | set_pmd_at(mm, new_addr, new_pmd, pmd_mksoft_dirty(pmd)); | ||
1182 | - if (new_ptl != old_ptl) | ||
1183 | - spin_unlock(new_ptl); | ||
1184 | if (force_flush) | ||
1185 | flush_tlb_range(vma, old_addr, old_addr + PMD_SIZE); | ||
1186 | - else | ||
1187 | - *need_flush = true; | ||
1188 | + if (new_ptl != old_ptl) | ||
1189 | + spin_unlock(new_ptl); | ||
1190 | spin_unlock(old_ptl); | ||
1191 | return true; | ||
1192 | } | ||
1193 | diff --git a/mm/mremap.c b/mm/mremap.c | ||
1194 | index 15976716dd40..9e6035969d7b 100644 | ||
1195 | --- a/mm/mremap.c | ||
1196 | +++ b/mm/mremap.c | ||
1197 | @@ -104,7 +104,7 @@ static pte_t move_soft_dirty_pte(pte_t pte) | ||
1198 | static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, | ||
1199 | unsigned long old_addr, unsigned long old_end, | ||
1200 | struct vm_area_struct *new_vma, pmd_t *new_pmd, | ||
1201 | - unsigned long new_addr, bool need_rmap_locks, bool *need_flush) | ||
1202 | + unsigned long new_addr, bool need_rmap_locks) | ||
1203 | { | ||
1204 | struct mm_struct *mm = vma->vm_mm; | ||
1205 | pte_t *old_pte, *new_pte, pte; | ||
1206 | @@ -152,15 +152,17 @@ static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, | ||
1207 | |||
1208 | pte = ptep_get_and_clear(mm, old_addr, old_pte); | ||
1209 | /* | ||
1210 | - * If we are remapping a dirty PTE, make sure | ||
1211 | + * If we are remapping a valid PTE, make sure | ||
1212 | * to flush TLB before we drop the PTL for the | ||
1213 | - * old PTE or we may race with page_mkclean(). | ||
1214 | + * PTE. | ||
1215 | * | ||
1216 | - * This check has to be done after we removed the | ||
1217 | - * old PTE from page tables or another thread may | ||
1218 | - * dirty it after the check and before the removal. | ||
1219 | + * NOTE! Both old and new PTL matter: the old one | ||
1220 | + * for racing with page_mkclean(), the new one to | ||
1221 | + * make sure the physical page stays valid until | ||
1222 | + * the TLB entry for the old mapping has been | ||
1223 | + * flushed. | ||
1224 | */ | ||
1225 | - if (pte_present(pte) && pte_dirty(pte)) | ||
1226 | + if (pte_present(pte)) | ||
1227 | force_flush = true; | ||
1228 | pte = move_pte(pte, new_vma->vm_page_prot, old_addr, new_addr); | ||
1229 | pte = move_soft_dirty_pte(pte); | ||
1230 | @@ -168,13 +170,11 @@ static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, | ||
1231 | } | ||
1232 | |||
1233 | arch_leave_lazy_mmu_mode(); | ||
1234 | + if (force_flush) | ||
1235 | + flush_tlb_range(vma, old_end - len, old_end); | ||
1236 | if (new_ptl != old_ptl) | ||
1237 | spin_unlock(new_ptl); | ||
1238 | pte_unmap(new_pte - 1); | ||
1239 | - if (force_flush) | ||
1240 | - flush_tlb_range(vma, old_end - len, old_end); | ||
1241 | - else | ||
1242 | - *need_flush = true; | ||
1243 | pte_unmap_unlock(old_pte - 1, old_ptl); | ||
1244 | if (need_rmap_locks) | ||
1245 | drop_rmap_locks(vma); | ||
1246 | @@ -189,7 +189,6 @@ unsigned long move_page_tables(struct vm_area_struct *vma, | ||
1247 | { | ||
1248 | unsigned long extent, next, old_end; | ||
1249 | pmd_t *old_pmd, *new_pmd; | ||
1250 | - bool need_flush = false; | ||
1251 | unsigned long mmun_start; /* For mmu_notifiers */ | ||
1252 | unsigned long mmun_end; /* For mmu_notifiers */ | ||
1253 | |||
1254 | @@ -220,8 +219,7 @@ unsigned long move_page_tables(struct vm_area_struct *vma, | ||
1255 | if (need_rmap_locks) | ||
1256 | take_rmap_locks(vma); | ||
1257 | moved = move_huge_pmd(vma, old_addr, new_addr, | ||
1258 | - old_end, old_pmd, new_pmd, | ||
1259 | - &need_flush); | ||
1260 | + old_end, old_pmd, new_pmd); | ||
1261 | if (need_rmap_locks) | ||
1262 | drop_rmap_locks(vma); | ||
1263 | if (moved) | ||
1264 | @@ -239,10 +237,8 @@ unsigned long move_page_tables(struct vm_area_struct *vma, | ||
1265 | if (extent > LATENCY_LIMIT) | ||
1266 | extent = LATENCY_LIMIT; | ||
1267 | move_ptes(vma, old_pmd, old_addr, old_addr + extent, new_vma, | ||
1268 | - new_pmd, new_addr, need_rmap_locks, &need_flush); | ||
1269 | + new_pmd, new_addr, need_rmap_locks); | ||
1270 | } | ||
1271 | - if (need_flush) | ||
1272 | - flush_tlb_range(vma, old_end-len, old_addr); | ||
1273 | |||
1274 | mmu_notifier_invalidate_range_end(vma->vm_mm, mmun_start, mmun_end); | ||
1275 | |||
1276 | diff --git a/net/batman-adv/bat_v_elp.c b/net/batman-adv/bat_v_elp.c | ||
1277 | index ee08540ce503..5d79004de25c 100644 | ||
1278 | --- a/net/batman-adv/bat_v_elp.c | ||
1279 | +++ b/net/batman-adv/bat_v_elp.c | ||
1280 | @@ -243,6 +243,7 @@ static void batadv_v_elp_periodic_work(struct work_struct *work) | ||
1281 | struct batadv_priv *bat_priv; | ||
1282 | struct sk_buff *skb; | ||
1283 | u32 elp_interval; | ||
1284 | + bool ret; | ||
1285 | |||
1286 | bat_v = container_of(work, struct batadv_hard_iface_bat_v, elp_wq.work); | ||
1287 | hard_iface = container_of(bat_v, struct batadv_hard_iface, bat_v); | ||
1288 | @@ -304,8 +305,11 @@ static void batadv_v_elp_periodic_work(struct work_struct *work) | ||
1289 | * may sleep and that is not allowed in an rcu protected | ||
1290 | * context. Therefore schedule a task for that. | ||
1291 | */ | ||
1292 | - queue_work(batadv_event_workqueue, | ||
1293 | - &hardif_neigh->bat_v.metric_work); | ||
1294 | + ret = queue_work(batadv_event_workqueue, | ||
1295 | + &hardif_neigh->bat_v.metric_work); | ||
1296 | + | ||
1297 | + if (!ret) | ||
1298 | + batadv_hardif_neigh_put(hardif_neigh); | ||
1299 | } | ||
1300 | rcu_read_unlock(); | ||
1301 | |||
1302 | diff --git a/net/batman-adv/bridge_loop_avoidance.c b/net/batman-adv/bridge_loop_avoidance.c | ||
1303 | index 582e27698bf0..8b6f654bc85d 100644 | ||
1304 | --- a/net/batman-adv/bridge_loop_avoidance.c | ||
1305 | +++ b/net/batman-adv/bridge_loop_avoidance.c | ||
1306 | @@ -1767,6 +1767,7 @@ batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb, | ||
1307 | { | ||
1308 | struct batadv_bla_backbone_gw *backbone_gw; | ||
1309 | struct ethhdr *ethhdr; | ||
1310 | + bool ret; | ||
1311 | |||
1312 | ethhdr = eth_hdr(skb); | ||
1313 | |||
1314 | @@ -1790,8 +1791,13 @@ batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb, | ||
1315 | if (unlikely(!backbone_gw)) | ||
1316 | return true; | ||
1317 | |||
1318 | - queue_work(batadv_event_workqueue, &backbone_gw->report_work); | ||
1319 | - /* backbone_gw is unreferenced in the report work function function */ | ||
1320 | + ret = queue_work(batadv_event_workqueue, &backbone_gw->report_work); | ||
1321 | + | ||
1322 | + /* backbone_gw is unreferenced in the report work function function | ||
1323 | + * if queue_work() call was successful | ||
1324 | + */ | ||
1325 | + if (!ret) | ||
1326 | + batadv_backbone_gw_put(backbone_gw); | ||
1327 | |||
1328 | return true; | ||
1329 | } | ||
1330 | diff --git a/net/batman-adv/network-coding.c b/net/batman-adv/network-coding.c | ||
1331 | index e3baf697a35c..a7b5cf08d363 100644 | ||
1332 | --- a/net/batman-adv/network-coding.c | ||
1333 | +++ b/net/batman-adv/network-coding.c | ||
1334 | @@ -845,16 +845,27 @@ batadv_nc_get_nc_node(struct batadv_priv *bat_priv, | ||
1335 | spinlock_t *lock; /* Used to lock list selected by "int in_coding" */ | ||
1336 | struct list_head *list; | ||
1337 | |||
1338 | + /* Select ingoing or outgoing coding node */ | ||
1339 | + if (in_coding) { | ||
1340 | + lock = &orig_neigh_node->in_coding_list_lock; | ||
1341 | + list = &orig_neigh_node->in_coding_list; | ||
1342 | + } else { | ||
1343 | + lock = &orig_neigh_node->out_coding_list_lock; | ||
1344 | + list = &orig_neigh_node->out_coding_list; | ||
1345 | + } | ||
1346 | + | ||
1347 | + spin_lock_bh(lock); | ||
1348 | + | ||
1349 | /* Check if nc_node is already added */ | ||
1350 | nc_node = batadv_nc_find_nc_node(orig_node, orig_neigh_node, in_coding); | ||
1351 | |||
1352 | /* Node found */ | ||
1353 | if (nc_node) | ||
1354 | - return nc_node; | ||
1355 | + goto unlock; | ||
1356 | |||
1357 | nc_node = kzalloc(sizeof(*nc_node), GFP_ATOMIC); | ||
1358 | if (!nc_node) | ||
1359 | - return NULL; | ||
1360 | + goto unlock; | ||
1361 | |||
1362 | /* Initialize nc_node */ | ||
1363 | INIT_LIST_HEAD(&nc_node->list); | ||
1364 | @@ -863,22 +874,14 @@ batadv_nc_get_nc_node(struct batadv_priv *bat_priv, | ||
1365 | kref_get(&orig_neigh_node->refcount); | ||
1366 | nc_node->orig_node = orig_neigh_node; | ||
1367 | |||
1368 | - /* Select ingoing or outgoing coding node */ | ||
1369 | - if (in_coding) { | ||
1370 | - lock = &orig_neigh_node->in_coding_list_lock; | ||
1371 | - list = &orig_neigh_node->in_coding_list; | ||
1372 | - } else { | ||
1373 | - lock = &orig_neigh_node->out_coding_list_lock; | ||
1374 | - list = &orig_neigh_node->out_coding_list; | ||
1375 | - } | ||
1376 | - | ||
1377 | batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_node %pM -> %pM\n", | ||
1378 | nc_node->addr, nc_node->orig_node->orig); | ||
1379 | |||
1380 | /* Add nc_node to orig_node */ | ||
1381 | - spin_lock_bh(lock); | ||
1382 | kref_get(&nc_node->refcount); | ||
1383 | list_add_tail_rcu(&nc_node->list, list); | ||
1384 | + | ||
1385 | +unlock: | ||
1386 | spin_unlock_bh(lock); | ||
1387 | |||
1388 | return nc_node; | ||
1389 | diff --git a/net/batman-adv/soft-interface.c b/net/batman-adv/soft-interface.c | ||
1390 | index 84c1b388d9ed..05bc176decf0 100644 | ||
1391 | --- a/net/batman-adv/soft-interface.c | ||
1392 | +++ b/net/batman-adv/soft-interface.c | ||
1393 | @@ -565,15 +565,20 @@ int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid) | ||
1394 | struct batadv_softif_vlan *vlan; | ||
1395 | int err; | ||
1396 | |||
1397 | + spin_lock_bh(&bat_priv->softif_vlan_list_lock); | ||
1398 | + | ||
1399 | vlan = batadv_softif_vlan_get(bat_priv, vid); | ||
1400 | if (vlan) { | ||
1401 | batadv_softif_vlan_put(vlan); | ||
1402 | + spin_unlock_bh(&bat_priv->softif_vlan_list_lock); | ||
1403 | return -EEXIST; | ||
1404 | } | ||
1405 | |||
1406 | vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC); | ||
1407 | - if (!vlan) | ||
1408 | + if (!vlan) { | ||
1409 | + spin_unlock_bh(&bat_priv->softif_vlan_list_lock); | ||
1410 | return -ENOMEM; | ||
1411 | + } | ||
1412 | |||
1413 | vlan->bat_priv = bat_priv; | ||
1414 | vlan->vid = vid; | ||
1415 | @@ -581,17 +586,23 @@ int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid) | ||
1416 | |||
1417 | atomic_set(&vlan->ap_isolation, 0); | ||
1418 | |||
1419 | + kref_get(&vlan->refcount); | ||
1420 | + hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list); | ||
1421 | + spin_unlock_bh(&bat_priv->softif_vlan_list_lock); | ||
1422 | + | ||
1423 | + /* batadv_sysfs_add_vlan cannot be in the spinlock section due to the | ||
1424 | + * sleeping behavior of the sysfs functions and the fs_reclaim lock | ||
1425 | + */ | ||
1426 | err = batadv_sysfs_add_vlan(bat_priv->soft_iface, vlan); | ||
1427 | if (err) { | ||
1428 | - kfree(vlan); | ||
1429 | + /* ref for the function */ | ||
1430 | + batadv_softif_vlan_put(vlan); | ||
1431 | + | ||
1432 | + /* ref for the list */ | ||
1433 | + batadv_softif_vlan_put(vlan); | ||
1434 | return err; | ||
1435 | } | ||
1436 | |||
1437 | - spin_lock_bh(&bat_priv->softif_vlan_list_lock); | ||
1438 | - kref_get(&vlan->refcount); | ||
1439 | - hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list); | ||
1440 | - spin_unlock_bh(&bat_priv->softif_vlan_list_lock); | ||
1441 | - | ||
1442 | /* add a new TT local entry. This one will be marked with the NOPURGE | ||
1443 | * flag | ||
1444 | */ | ||
1445 | diff --git a/net/batman-adv/sysfs.c b/net/batman-adv/sysfs.c | ||
1446 | index 02d96f224c60..31d7e239a1fd 100644 | ||
1447 | --- a/net/batman-adv/sysfs.c | ||
1448 | +++ b/net/batman-adv/sysfs.c | ||
1449 | @@ -187,7 +187,8 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ | ||
1450 | \ | ||
1451 | return __batadv_store_uint_attr(buff, count, _min, _max, \ | ||
1452 | _post_func, attr, \ | ||
1453 | - &bat_priv->_var, net_dev); \ | ||
1454 | + &bat_priv->_var, net_dev, \ | ||
1455 | + NULL); \ | ||
1456 | } | ||
1457 | |||
1458 | #define BATADV_ATTR_SIF_SHOW_UINT(_name, _var) \ | ||
1459 | @@ -261,7 +262,9 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ | ||
1460 | \ | ||
1461 | length = __batadv_store_uint_attr(buff, count, _min, _max, \ | ||
1462 | _post_func, attr, \ | ||
1463 | - &hard_iface->_var, net_dev); \ | ||
1464 | + &hard_iface->_var, \ | ||
1465 | + hard_iface->soft_iface, \ | ||
1466 | + net_dev); \ | ||
1467 | \ | ||
1468 | batadv_hardif_put(hard_iface); \ | ||
1469 | return length; \ | ||
1470 | @@ -355,10 +358,12 @@ __batadv_store_bool_attr(char *buff, size_t count, | ||
1471 | |||
1472 | static int batadv_store_uint_attr(const char *buff, size_t count, | ||
1473 | struct net_device *net_dev, | ||
1474 | + struct net_device *slave_dev, | ||
1475 | const char *attr_name, | ||
1476 | unsigned int min, unsigned int max, | ||
1477 | atomic_t *attr) | ||
1478 | { | ||
1479 | + char ifname[IFNAMSIZ + 3] = ""; | ||
1480 | unsigned long uint_val; | ||
1481 | int ret; | ||
1482 | |||
1483 | @@ -384,8 +389,11 @@ static int batadv_store_uint_attr(const char *buff, size_t count, | ||
1484 | if (atomic_read(attr) == uint_val) | ||
1485 | return count; | ||
1486 | |||
1487 | - batadv_info(net_dev, "%s: Changing from: %i to: %lu\n", | ||
1488 | - attr_name, atomic_read(attr), uint_val); | ||
1489 | + if (slave_dev) | ||
1490 | + snprintf(ifname, sizeof(ifname), "%s: ", slave_dev->name); | ||
1491 | + | ||
1492 | + batadv_info(net_dev, "%s: %sChanging from: %i to: %lu\n", | ||
1493 | + attr_name, ifname, atomic_read(attr), uint_val); | ||
1494 | |||
1495 | atomic_set(attr, uint_val); | ||
1496 | return count; | ||
1497 | @@ -396,12 +404,13 @@ static ssize_t __batadv_store_uint_attr(const char *buff, size_t count, | ||
1498 | void (*post_func)(struct net_device *), | ||
1499 | const struct attribute *attr, | ||
1500 | atomic_t *attr_store, | ||
1501 | - struct net_device *net_dev) | ||
1502 | + struct net_device *net_dev, | ||
1503 | + struct net_device *slave_dev) | ||
1504 | { | ||
1505 | int ret; | ||
1506 | |||
1507 | - ret = batadv_store_uint_attr(buff, count, net_dev, attr->name, min, max, | ||
1508 | - attr_store); | ||
1509 | + ret = batadv_store_uint_attr(buff, count, net_dev, slave_dev, | ||
1510 | + attr->name, min, max, attr_store); | ||
1511 | if (post_func && ret) | ||
1512 | post_func(net_dev); | ||
1513 | |||
1514 | @@ -570,7 +579,7 @@ static ssize_t batadv_store_gw_sel_class(struct kobject *kobj, | ||
1515 | return __batadv_store_uint_attr(buff, count, 1, BATADV_TQ_MAX_VALUE, | ||
1516 | batadv_post_gw_reselect, attr, | ||
1517 | &bat_priv->gw.sel_class, | ||
1518 | - bat_priv->soft_iface); | ||
1519 | + bat_priv->soft_iface, NULL); | ||
1520 | } | ||
1521 | |||
1522 | static ssize_t batadv_show_gw_bwidth(struct kobject *kobj, | ||
1523 | @@ -1084,8 +1093,9 @@ static ssize_t batadv_store_throughput_override(struct kobject *kobj, | ||
1524 | if (old_tp_override == tp_override) | ||
1525 | goto out; | ||
1526 | |||
1527 | - batadv_info(net_dev, "%s: Changing from: %u.%u MBit to: %u.%u MBit\n", | ||
1528 | - "throughput_override", | ||
1529 | + batadv_info(hard_iface->soft_iface, | ||
1530 | + "%s: %s: Changing from: %u.%u MBit to: %u.%u MBit\n", | ||
1531 | + "throughput_override", net_dev->name, | ||
1532 | old_tp_override / 10, old_tp_override % 10, | ||
1533 | tp_override / 10, tp_override % 10); | ||
1534 | |||
1535 | diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c | ||
1536 | index 0dc85eb1cb7a..b9f9a310eb78 100644 | ||
1537 | --- a/net/batman-adv/translation-table.c | ||
1538 | +++ b/net/batman-adv/translation-table.c | ||
1539 | @@ -1550,6 +1550,8 @@ batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global, | ||
1540 | { | ||
1541 | struct batadv_tt_orig_list_entry *orig_entry; | ||
1542 | |||
1543 | + spin_lock_bh(&tt_global->list_lock); | ||
1544 | + | ||
1545 | orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node); | ||
1546 | if (orig_entry) { | ||
1547 | /* refresh the ttvn: the current value could be a bogus one that | ||
1548 | @@ -1570,16 +1572,16 @@ batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global, | ||
1549 | orig_entry->ttvn = ttvn; | ||
1550 | kref_init(&orig_entry->refcount); | ||
1551 | |||
1552 | - spin_lock_bh(&tt_global->list_lock); | ||
1553 | kref_get(&orig_entry->refcount); | ||
1554 | hlist_add_head_rcu(&orig_entry->list, | ||
1555 | &tt_global->orig_list); | ||
1556 | - spin_unlock_bh(&tt_global->list_lock); | ||
1557 | atomic_inc(&tt_global->orig_list_count); | ||
1558 | |||
1559 | out: | ||
1560 | if (orig_entry) | ||
1561 | batadv_tt_orig_list_entry_put(orig_entry); | ||
1562 | + | ||
1563 | + spin_unlock_bh(&tt_global->list_lock); | ||
1564 | } | ||
1565 | |||
1566 | /** | ||
1567 | diff --git a/net/batman-adv/tvlv.c b/net/batman-adv/tvlv.c | ||
1568 | index 77654f055f24..8e91a26e9b00 100644 | ||
1569 | --- a/net/batman-adv/tvlv.c | ||
1570 | +++ b/net/batman-adv/tvlv.c | ||
1571 | @@ -528,15 +528,20 @@ void batadv_tvlv_handler_register(struct batadv_priv *bat_priv, | ||
1572 | { | ||
1573 | struct batadv_tvlv_handler *tvlv_handler; | ||
1574 | |||
1575 | + spin_lock_bh(&bat_priv->tvlv.handler_list_lock); | ||
1576 | + | ||
1577 | tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version); | ||
1578 | if (tvlv_handler) { | ||
1579 | + spin_unlock_bh(&bat_priv->tvlv.handler_list_lock); | ||
1580 | batadv_tvlv_handler_put(tvlv_handler); | ||
1581 | return; | ||
1582 | } | ||
1583 | |||
1584 | tvlv_handler = kzalloc(sizeof(*tvlv_handler), GFP_ATOMIC); | ||
1585 | - if (!tvlv_handler) | ||
1586 | + if (!tvlv_handler) { | ||
1587 | + spin_unlock_bh(&bat_priv->tvlv.handler_list_lock); | ||
1588 | return; | ||
1589 | + } | ||
1590 | |||
1591 | tvlv_handler->ogm_handler = optr; | ||
1592 | tvlv_handler->unicast_handler = uptr; | ||
1593 | @@ -546,7 +551,6 @@ void batadv_tvlv_handler_register(struct batadv_priv *bat_priv, | ||
1594 | kref_init(&tvlv_handler->refcount); | ||
1595 | INIT_HLIST_NODE(&tvlv_handler->list); | ||
1596 | |||
1597 | - spin_lock_bh(&bat_priv->tvlv.handler_list_lock); | ||
1598 | kref_get(&tvlv_handler->refcount); | ||
1599 | hlist_add_head_rcu(&tvlv_handler->list, &bat_priv->tvlv.handler_list); | ||
1600 | spin_unlock_bh(&bat_priv->tvlv.handler_list_lock); | ||
1601 | diff --git a/net/netfilter/nf_nat_core.c b/net/netfilter/nf_nat_core.c | ||
1602 | index 624d6e4dcd5c..51b0d832bd07 100644 | ||
1603 | --- a/net/netfilter/nf_nat_core.c | ||
1604 | +++ b/net/netfilter/nf_nat_core.c | ||
1605 | @@ -421,7 +421,7 @@ nf_nat_setup_info(struct nf_conn *ct, | ||
1606 | else | ||
1607 | ct->status |= IPS_DST_NAT; | ||
1608 | |||
1609 | - if (nfct_help(ct)) | ||
1610 | + if (nfct_help(ct) && !nfct_seqadj(ct)) | ||
1611 | if (!nfct_seqadj_ext_add(ct)) | ||
1612 | return NF_DROP; | ||
1613 | } |