commit: 017a1ef3e1cf814e9eae5df7295615f0378390a6 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Sat Oct 20 12:43:17 2018 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Sat Oct 20 12:43:17 2018 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=017a1ef3
Linux patch 4.9.135 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 10 +- 1134_linux-4.9.135.patch | 1613 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1620 insertions(+), 3 deletions(-) diff --git a/0000_README b/0000_README index 99ea31b..0a80b16 100644 --- a/0000_README +++ b/0000_README @@ -567,15 +567,19 @@ Patch: 1130_linux-4.9.131.patch From: http://www.kernel.org Desc: Linux 4.9.131 -Patch: 1130_linux-4.9.132.patch +Patch: 1131_linux-4.9.132.patch From: http://www.kernel.org Desc: Linux 4.9.132 -Patch: 1130_linux-4.9.133.patch +Patch: 1132_linux-4.9.133.patch From: http://www.kernel.org Desc: Linux 4.9.133 -Patch: 1131_linux-4.9.134.patch +Patch: 1133_linux-4.9.134.patch +From: http://www.kernel.org +Desc: Linux 4.9.134 + +Patch: 1134_linux-4.9.135.patch From: http://www.kernel.org Desc: Linux 4.9.134 diff --git a/1134_linux-4.9.135.patch b/1134_linux-4.9.135.patch new file mode 100644 index 0000000..f321d7f --- /dev/null +++ b/1134_linux-4.9.135.patch @@ -0,0 +1,1613 @@ +diff --git a/Makefile b/Makefile +index 46135e4333e6..3678e4d19ebc 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 9 +-SUBLEVEL = 134 ++SUBLEVEL = 135 + EXTRAVERSION = + NAME = Roaring Lionus + +diff --git a/arch/arc/Makefile b/arch/arc/Makefile +index 8447eed836ef..a3b456008201 100644 +--- a/arch/arc/Makefile ++++ b/arch/arc/Makefile +@@ -8,34 +8,12 @@ + + UTS_MACHINE := arc + +-ifeq ($(CROSS_COMPILE),) +-ifndef CONFIG_CPU_BIG_ENDIAN +-CROSS_COMPILE := arc-linux- +-else +-CROSS_COMPILE := arceb-linux- +-endif +-endif +- + KBUILD_DEFCONFIG := nsim_700_defconfig + + cflags-y += -fno-common -pipe -fno-builtin -mmedium-calls -D__linux__ + cflags-$(CONFIG_ISA_ARCOMPACT) += -mA7 + cflags-$(CONFIG_ISA_ARCV2) += -mcpu=archs + +-is_700 = $(shell $(CC) -dM -E - < /dev/null | grep -q "ARC700" && echo 1 || echo 0) +- +-ifdef CONFIG_ISA_ARCOMPACT +-ifeq ($(is_700), 0) +- $(error Toolchain not configured for ARCompact builds) +-endif +-endif +- +-ifdef CONFIG_ISA_ARCV2 +-ifeq ($(is_700), 1) +- $(error Toolchain not configured for ARCv2 builds) +-endif +-endif +- + ifdef CONFIG_ARC_CURR_IN_REG + # For a global register defintion, make sure it gets passed to every file + # We had a customer reported bug where some code built in kernel was NOT using +@@ -89,7 +67,7 @@ ldflags-$(CONFIG_CPU_BIG_ENDIAN) += -EB + # --build-id w/o "-marclinux". Default arc-elf32-ld is OK + ldflags-$(upto_gcc44) += -marclinux + +-LIBGCC := $(shell $(CC) $(cflags-y) --print-libgcc-file-name) ++LIBGCC = $(shell $(CC) $(cflags-y) --print-libgcc-file-name) + + # Modules with short calls might break for calls into builtin-kernel + KBUILD_CFLAGS_MODULE += -mlong-calls -mno-millicode +diff --git a/arch/powerpc/kernel/tm.S b/arch/powerpc/kernel/tm.S +index 3a2d04134da9..f59b73810630 100644 +--- a/arch/powerpc/kernel/tm.S ++++ b/arch/powerpc/kernel/tm.S +@@ -166,13 +166,27 @@ _GLOBAL(tm_reclaim) + std r1, PACATMSCRATCH(r13) + ld r1, PACAR1(r13) + +- /* Store the PPR in r11 and reset to decent value */ + std r11, GPR11(r1) /* Temporary stash */ + ++ /* ++ * Move the saved user r1 to the kernel stack in case PACATMSCRATCH is ++ * clobbered by an exception once we turn on MSR_RI below. ++ */ ++ ld r11, PACATMSCRATCH(r13) ++ std r11, GPR1(r1) ++ ++ /* ++ * Store r13 away so we can free up the scratch SPR for the SLB fault ++ * handler (needed once we start accessing the thread_struct). ++ */ ++ GET_SCRATCH0(r11) ++ std r11, GPR13(r1) ++ + /* Reset MSR RI so we can take SLB faults again */ + li r11, MSR_RI + mtmsrd r11, 1 + ++ /* Store the PPR in r11 and reset to decent value */ + mfspr r11, SPRN_PPR + HMT_MEDIUM + +@@ -197,11 +211,11 @@ _GLOBAL(tm_reclaim) + SAVE_GPR(8, r7) /* user r8 */ + SAVE_GPR(9, r7) /* user r9 */ + SAVE_GPR(10, r7) /* user r10 */ +- ld r3, PACATMSCRATCH(r13) /* user r1 */ ++ ld r3, GPR1(r1) /* user r1 */ + ld r4, GPR7(r1) /* user r7 */ + ld r5, GPR11(r1) /* user r11 */ + ld r6, GPR12(r1) /* user r12 */ +- GET_SCRATCH0(8) /* user r13 */ ++ ld r8, GPR13(r1) /* user r13 */ + std r3, GPR1(r7) + std r4, GPR7(r7) + std r5, GPR11(r7) +diff --git a/arch/s390/appldata/appldata_os.c b/arch/s390/appldata/appldata_os.c +index 69b23b25ac34..08b9e942a262 100644 +--- a/arch/s390/appldata/appldata_os.c ++++ b/arch/s390/appldata/appldata_os.c +@@ -113,21 +113,21 @@ static void appldata_get_os_data(void *data) + j = 0; + for_each_online_cpu(i) { + os_data->os_cpu[j].per_cpu_user = +- cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_USER]); ++ nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_USER]); + os_data->os_cpu[j].per_cpu_nice = +- cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_NICE]); ++ nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_NICE]); + os_data->os_cpu[j].per_cpu_system = +- cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM]); ++ nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SYSTEM]); + os_data->os_cpu[j].per_cpu_idle = +- cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IDLE]); ++ nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IDLE]); + os_data->os_cpu[j].per_cpu_irq = +- cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IRQ]); ++ nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IRQ]); + os_data->os_cpu[j].per_cpu_softirq = +- cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ]); ++ nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_SOFTIRQ]); + os_data->os_cpu[j].per_cpu_iowait = +- cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IOWAIT]); ++ nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_IOWAIT]); + os_data->os_cpu[j].per_cpu_steal = +- cputime_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_STEAL]); ++ nsecs_to_jiffies(kcpustat_cpu(i).cpustat[CPUTIME_STEAL]); + os_data->os_cpu[j].cpu_id = i; + j++; + } +diff --git a/arch/x86/include/asm/pgtable_types.h b/arch/x86/include/asm/pgtable_types.h +index dfdb7e21ba56..93d089c9509a 100644 +--- a/arch/x86/include/asm/pgtable_types.h ++++ b/arch/x86/include/asm/pgtable_types.h +@@ -134,7 +134,7 @@ + */ + #define _PAGE_CHG_MASK (PTE_PFN_MASK | _PAGE_PCD | _PAGE_PWT | \ + _PAGE_SPECIAL | _PAGE_ACCESSED | _PAGE_DIRTY | \ +- _PAGE_SOFT_DIRTY) ++ _PAGE_SOFT_DIRTY | _PAGE_DEVMAP) + #define _HPAGE_CHG_MASK (_PAGE_CHG_MASK | _PAGE_PSE) + + /* The ASID is the lower 12 bits of CR3 */ +diff --git a/drivers/clocksource/timer-ti-32k.c b/drivers/clocksource/timer-ti-32k.c +index cf5b14e442e4..e9ab92d0c358 100644 +--- a/drivers/clocksource/timer-ti-32k.c ++++ b/drivers/clocksource/timer-ti-32k.c +@@ -98,6 +98,9 @@ static int __init ti_32k_timer_init(struct device_node *np) + return -ENXIO; + } + ++ if (!of_machine_is_compatible("ti,am43")) ++ ti_32k_timer.cs.flags |= CLOCK_SOURCE_SUSPEND_NONSTOP; ++ + ti_32k_timer.counter = ti_32k_timer.base; + + /* +diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c +index af5eff6835a8..d6d91e8afa9e 100644 +--- a/drivers/cpufreq/cpufreq.c ++++ b/drivers/cpufreq/cpufreq.c +@@ -132,7 +132,7 @@ static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall) + u64 cur_wall_time; + u64 busy_time; + +- cur_wall_time = jiffies64_to_cputime64(get_jiffies_64()); ++ cur_wall_time = jiffies64_to_nsecs(get_jiffies_64()); + + busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER]; + busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM]; +@@ -143,9 +143,9 @@ static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall) + + idle_time = cur_wall_time - busy_time; + if (wall) +- *wall = cputime_to_usecs(cur_wall_time); ++ *wall = div_u64(cur_wall_time, NSEC_PER_USEC); + +- return cputime_to_usecs(idle_time); ++ return div_u64(idle_time, NSEC_PER_USEC); + } + + u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy) +diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c +index 642dd0f183a8..38d1a8216084 100644 +--- a/drivers/cpufreq/cpufreq_governor.c ++++ b/drivers/cpufreq/cpufreq_governor.c +@@ -152,7 +152,7 @@ unsigned int dbs_update(struct cpufreq_policy *policy) + if (ignore_nice) { + u64 cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE]; + +- idle_time += cputime_to_usecs(cur_nice - j_cdbs->prev_cpu_nice); ++ idle_time += div_u64(cur_nice - j_cdbs->prev_cpu_nice, NSEC_PER_USEC); + j_cdbs->prev_cpu_nice = cur_nice; + } + +diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c +index 06d3abdffd3a..b084708fd113 100644 +--- a/drivers/cpufreq/cpufreq_stats.c ++++ b/drivers/cpufreq/cpufreq_stats.c +@@ -13,7 +13,6 @@ + #include <linux/cpufreq.h> + #include <linux/module.h> + #include <linux/slab.h> +-#include <linux/cputime.h> + + static DEFINE_SPINLOCK(cpufreq_stats_lock); + +diff --git a/drivers/gpu/drm/arm/malidp_drv.c b/drivers/gpu/drm/arm/malidp_drv.c +index 9280358b8f15..59d484736b4e 100644 +--- a/drivers/gpu/drm/arm/malidp_drv.c ++++ b/drivers/gpu/drm/arm/malidp_drv.c +@@ -378,6 +378,7 @@ static int malidp_bind(struct device *dev) + goto irq_init_fail; + + ret = drm_vblank_init(drm, drm->mode_config.num_crtc); ++ drm_crtc_vblank_reset(&malidp->crtc); + if (ret < 0) { + DRM_ERROR("failed to initialise vblank\n"); + goto vblank_fail; +diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c +index 2248b330c047..70597854397f 100644 +--- a/drivers/hid/hid-core.c ++++ b/drivers/hid/hid-core.c +@@ -1853,6 +1853,9 @@ static const struct hid_device_id hid_have_special_driver[] = { + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) }, + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS) }, + { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_ANSI) }, ++ { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_ANSI) }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_ANSI) }, ++ { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_ANSI) }, + { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) }, + { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) }, + { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_NOTEBOOK_KEYBOARD) }, +diff --git a/drivers/hv/hv_kvp.c b/drivers/hv/hv_kvp.c +index 5e1fdc8d32ab..2fd0f119a67b 100644 +--- a/drivers/hv/hv_kvp.c ++++ b/drivers/hv/hv_kvp.c +@@ -616,21 +616,22 @@ void hv_kvp_onchannelcallback(void *context) + NEGO_IN_PROGRESS, + NEGO_FINISHED} host_negotiatied = NEGO_NOT_STARTED; + +- if (host_negotiatied == NEGO_NOT_STARTED && +- kvp_transaction.state < HVUTIL_READY) { ++ if (kvp_transaction.state < HVUTIL_READY) { + /* + * If userspace daemon is not connected and host is asking + * us to negotiate we need to delay to not lose messages. + * This is important for Failover IP setting. + */ +- host_negotiatied = NEGO_IN_PROGRESS; +- schedule_delayed_work(&kvp_host_handshake_work, ++ if (host_negotiatied == NEGO_NOT_STARTED) { ++ host_negotiatied = NEGO_IN_PROGRESS; ++ schedule_delayed_work(&kvp_host_handshake_work, + HV_UTIL_NEGO_TIMEOUT * HZ); ++ } + return; + } + if (kvp_transaction.state > HVUTIL_READY) + return; +- ++recheck: + vmbus_recvpacket(channel, recv_buffer, PAGE_SIZE * 4, &recvlen, + &requestid); + +@@ -707,6 +708,8 @@ void hv_kvp_onchannelcallback(void *context) + VM_PKT_DATA_INBAND, 0); + + host_negotiatied = NEGO_FINISHED; ++ ++ goto recheck; + } + + } +diff --git a/drivers/input/keyboard/atakbd.c b/drivers/input/keyboard/atakbd.c +index f1235831283d..fdeda0b0fbd6 100644 +--- a/drivers/input/keyboard/atakbd.c ++++ b/drivers/input/keyboard/atakbd.c +@@ -79,8 +79,7 @@ MODULE_LICENSE("GPL"); + */ + + +-static unsigned char atakbd_keycode[0x72] = { /* American layout */ +- [0] = KEY_GRAVE, ++static unsigned char atakbd_keycode[0x73] = { /* American layout */ + [1] = KEY_ESC, + [2] = KEY_1, + [3] = KEY_2, +@@ -121,9 +120,9 @@ static unsigned char atakbd_keycode[0x72] = { /* American layout */ + [38] = KEY_L, + [39] = KEY_SEMICOLON, + [40] = KEY_APOSTROPHE, +- [41] = KEY_BACKSLASH, /* FIXME, '#' */ ++ [41] = KEY_GRAVE, + [42] = KEY_LEFTSHIFT, +- [43] = KEY_GRAVE, /* FIXME: '~' */ ++ [43] = KEY_BACKSLASH, + [44] = KEY_Z, + [45] = KEY_X, + [46] = KEY_C, +@@ -149,45 +148,34 @@ static unsigned char atakbd_keycode[0x72] = { /* American layout */ + [66] = KEY_F8, + [67] = KEY_F9, + [68] = KEY_F10, +- [69] = KEY_ESC, +- [70] = KEY_DELETE, +- [71] = KEY_KP7, +- [72] = KEY_KP8, +- [73] = KEY_KP9, ++ [71] = KEY_HOME, ++ [72] = KEY_UP, + [74] = KEY_KPMINUS, +- [75] = KEY_KP4, +- [76] = KEY_KP5, +- [77] = KEY_KP6, ++ [75] = KEY_LEFT, ++ [77] = KEY_RIGHT, + [78] = KEY_KPPLUS, +- [79] = KEY_KP1, +- [80] = KEY_KP2, +- [81] = KEY_KP3, +- [82] = KEY_KP0, +- [83] = KEY_KPDOT, +- [90] = KEY_KPLEFTPAREN, +- [91] = KEY_KPRIGHTPAREN, +- [92] = KEY_KPASTERISK, /* FIXME */ +- [93] = KEY_KPASTERISK, +- [94] = KEY_KPPLUS, +- [95] = KEY_HELP, ++ [80] = KEY_DOWN, ++ [82] = KEY_INSERT, ++ [83] = KEY_DELETE, + [96] = KEY_102ND, +- [97] = KEY_KPASTERISK, /* FIXME */ +- [98] = KEY_KPSLASH, ++ [97] = KEY_UNDO, ++ [98] = KEY_HELP, + [99] = KEY_KPLEFTPAREN, + [100] = KEY_KPRIGHTPAREN, + [101] = KEY_KPSLASH, + [102] = KEY_KPASTERISK, +- [103] = KEY_UP, +- [104] = KEY_KPASTERISK, /* FIXME */ +- [105] = KEY_LEFT, +- [106] = KEY_RIGHT, +- [107] = KEY_KPASTERISK, /* FIXME */ +- [108] = KEY_DOWN, +- [109] = KEY_KPASTERISK, /* FIXME */ +- [110] = KEY_KPASTERISK, /* FIXME */ +- [111] = KEY_KPASTERISK, /* FIXME */ +- [112] = KEY_KPASTERISK, /* FIXME */ +- [113] = KEY_KPASTERISK /* FIXME */ ++ [103] = KEY_KP7, ++ [104] = KEY_KP8, ++ [105] = KEY_KP9, ++ [106] = KEY_KP4, ++ [107] = KEY_KP5, ++ [108] = KEY_KP6, ++ [109] = KEY_KP1, ++ [110] = KEY_KP2, ++ [111] = KEY_KP3, ++ [112] = KEY_KP0, ++ [113] = KEY_KPDOT, ++ [114] = KEY_KPENTER, + }; + + static struct input_dev *atakbd_dev; +@@ -195,21 +183,15 @@ static struct input_dev *atakbd_dev; + static void atakbd_interrupt(unsigned char scancode, char down) + { + +- if (scancode < 0x72) { /* scancodes < 0xf2 are keys */ ++ if (scancode < 0x73) { /* scancodes < 0xf3 are keys */ + + // report raw events here? + + scancode = atakbd_keycode[scancode]; + +- if (scancode == KEY_CAPSLOCK) { /* CapsLock is a toggle switch key on Amiga */ +- input_report_key(atakbd_dev, scancode, 1); +- input_report_key(atakbd_dev, scancode, 0); +- input_sync(atakbd_dev); +- } else { +- input_report_key(atakbd_dev, scancode, down); +- input_sync(atakbd_dev); +- } +- } else /* scancodes >= 0xf2 are mouse data, most likely */ ++ input_report_key(atakbd_dev, scancode, down); ++ input_sync(atakbd_dev); ++ } else /* scancodes >= 0xf3 are mouse data, most likely */ + printk(KERN_INFO "atakbd: unhandled scancode %x\n", scancode); + + return; +diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c +index 16199b36a11e..bba1b9f2f782 100644 +--- a/drivers/iommu/amd_iommu.c ++++ b/drivers/iommu/amd_iommu.c +@@ -288,7 +288,13 @@ static u16 get_alias(struct device *dev) + + /* The callers make sure that get_device_id() does not fail here */ + devid = get_device_id(dev); ++ ++ /* For ACPI HID devices, we simply return the devid as such */ ++ if (!dev_is_pci(dev)) ++ return devid; ++ + ivrs_alias = amd_iommu_alias_table[devid]; ++ + pci_for_each_dma_alias(pdev, __last_alias, &pci_alias); + + if (ivrs_alias == pci_alias) +diff --git a/drivers/macintosh/rack-meter.c b/drivers/macintosh/rack-meter.c +index 25852e399ab2..c5aba26c604a 100644 +--- a/drivers/macintosh/rack-meter.c ++++ b/drivers/macintosh/rack-meter.c +@@ -52,8 +52,8 @@ struct rackmeter_dma { + struct rackmeter_cpu { + struct delayed_work sniffer; + struct rackmeter *rm; +- cputime64_t prev_wall; +- cputime64_t prev_idle; ++ u64 prev_wall; ++ u64 prev_idle; + int zero; + } ____cacheline_aligned; + +@@ -81,7 +81,7 @@ static int rackmeter_ignore_nice; + /* This is copied from cpufreq_ondemand, maybe we should put it in + * a common header somewhere + */ +-static inline cputime64_t get_cpu_idle_time(unsigned int cpu) ++static inline u64 get_cpu_idle_time(unsigned int cpu) + { + u64 retval; + +@@ -217,23 +217,23 @@ static void rackmeter_do_timer(struct work_struct *work) + container_of(work, struct rackmeter_cpu, sniffer.work); + struct rackmeter *rm = rcpu->rm; + unsigned int cpu = smp_processor_id(); +- cputime64_t cur_jiffies, total_idle_ticks; +- unsigned int total_ticks, idle_ticks; ++ u64 cur_nsecs, total_idle_nsecs; ++ u64 total_nsecs, idle_nsecs; + int i, offset, load, cumm, pause; + +- cur_jiffies = jiffies64_to_cputime64(get_jiffies_64()); +- total_ticks = (unsigned int) (cur_jiffies - rcpu->prev_wall); +- rcpu->prev_wall = cur_jiffies; ++ cur_nsecs = jiffies64_to_nsecs(get_jiffies_64()); ++ total_nsecs = cur_nsecs - rcpu->prev_wall; ++ rcpu->prev_wall = cur_nsecs; + +- total_idle_ticks = get_cpu_idle_time(cpu); +- idle_ticks = (unsigned int) (total_idle_ticks - rcpu->prev_idle); +- idle_ticks = min(idle_ticks, total_ticks); +- rcpu->prev_idle = total_idle_ticks; ++ total_idle_nsecs = get_cpu_idle_time(cpu); ++ idle_nsecs = total_idle_nsecs - rcpu->prev_idle; ++ idle_nsecs = min(idle_nsecs, total_nsecs); ++ rcpu->prev_idle = total_idle_nsecs; + + /* We do a very dumb calculation to update the LEDs for now, + * we'll do better once we have actual PWM implemented + */ +- load = (9 * (total_ticks - idle_ticks)) / total_ticks; ++ load = div64_u64(9 * (total_nsecs - idle_nsecs), total_nsecs); + + offset = cpu << 3; + cumm = 0; +@@ -278,7 +278,7 @@ static void rackmeter_init_cpu_sniffer(struct rackmeter *rm) + continue; + rcpu = &rm->cpu[cpu]; + rcpu->prev_idle = get_cpu_idle_time(cpu); +- rcpu->prev_wall = jiffies64_to_cputime64(get_jiffies_64()); ++ rcpu->prev_wall = jiffies64_to_nsecs(get_jiffies_64()); + schedule_delayed_work_on(cpu, &rm->cpu[cpu].sniffer, + msecs_to_jiffies(CPU_SAMPLING_RATE)); + } +diff --git a/drivers/media/usb/dvb-usb-v2/af9035.c b/drivers/media/usb/dvb-usb-v2/af9035.c +index 8961dd732522..64be30d53847 100644 +--- a/drivers/media/usb/dvb-usb-v2/af9035.c ++++ b/drivers/media/usb/dvb-usb-v2/af9035.c +@@ -406,8 +406,10 @@ static int af9035_i2c_master_xfer(struct i2c_adapter *adap, + msg[0].addr == (state->af9033_i2c_addr[1] >> 1)) + reg |= 0x100000; + +- ret = af9035_wr_regs(d, reg, &msg[0].buf[3], +- msg[0].len - 3); ++ ret = (msg[0].len >= 3) ? af9035_wr_regs(d, reg, ++ &msg[0].buf[3], ++ msg[0].len - 3) ++ : -EOPNOTSUPP; + } else { + /* I2C write */ + u8 buf[MAX_XFER_SIZE]; +diff --git a/drivers/net/ethernet/mellanox/mlx4/eq.c b/drivers/net/ethernet/mellanox/mlx4/eq.c +index 0509996957d9..e70d6fe504b8 100644 +--- a/drivers/net/ethernet/mellanox/mlx4/eq.c ++++ b/drivers/net/ethernet/mellanox/mlx4/eq.c +@@ -240,7 +240,8 @@ static void mlx4_set_eq_affinity_hint(struct mlx4_priv *priv, int vec) + struct mlx4_dev *dev = &priv->dev; + struct mlx4_eq *eq = &priv->eq_table.eq[vec]; + +- if (!eq->affinity_mask || cpumask_empty(eq->affinity_mask)) ++ if (!cpumask_available(eq->affinity_mask) || ++ cpumask_empty(eq->affinity_mask)) + return; + + hint_err = irq_set_affinity_hint(eq->irq, eq->affinity_mask); +diff --git a/drivers/net/ethernet/renesas/ravb.h b/drivers/net/ethernet/renesas/ravb.h +index f1109661a533..410399070639 100644 +--- a/drivers/net/ethernet/renesas/ravb.h ++++ b/drivers/net/ethernet/renesas/ravb.h +@@ -421,6 +421,7 @@ enum EIS_BIT { + EIS_CULF1 = 0x00000080, + EIS_TFFF = 0x00000100, + EIS_QFS = 0x00010000, ++ EIS_RESERVED = (GENMASK(31, 17) | GENMASK(15, 11)), + }; + + /* RIC0 */ +@@ -465,6 +466,7 @@ enum RIS0_BIT { + RIS0_FRF15 = 0x00008000, + RIS0_FRF16 = 0x00010000, + RIS0_FRF17 = 0x00020000, ++ RIS0_RESERVED = GENMASK(31, 18), + }; + + /* RIC1 */ +@@ -521,6 +523,7 @@ enum RIS2_BIT { + RIS2_QFF16 = 0x00010000, + RIS2_QFF17 = 0x00020000, + RIS2_RFFF = 0x80000000, ++ RIS2_RESERVED = GENMASK(30, 18), + }; + + /* TIC */ +@@ -537,6 +540,7 @@ enum TIS_BIT { + TIS_FTF1 = 0x00000002, /* Undocumented? */ + TIS_TFUF = 0x00000100, + TIS_TFWF = 0x00000200, ++ TIS_RESERVED = (GENMASK(31, 20) | GENMASK(15, 12) | GENMASK(7, 4)) + }; + + /* ISS */ +@@ -610,6 +614,7 @@ enum GIC_BIT { + enum GIS_BIT { + GIS_PTCF = 0x00000001, /* Undocumented? */ + GIS_PTMF = 0x00000004, ++ GIS_RESERVED = GENMASK(15, 10), + }; + + /* GIE (R-Car Gen3 only) */ +diff --git a/drivers/net/ethernet/renesas/ravb_main.c b/drivers/net/ethernet/renesas/ravb_main.c +index 307ecd500dac..71836a7f56b0 100644 +--- a/drivers/net/ethernet/renesas/ravb_main.c ++++ b/drivers/net/ethernet/renesas/ravb_main.c +@@ -717,10 +717,11 @@ static void ravb_error_interrupt(struct net_device *ndev) + u32 eis, ris2; + + eis = ravb_read(ndev, EIS); +- ravb_write(ndev, ~EIS_QFS, EIS); ++ ravb_write(ndev, ~(EIS_QFS | EIS_RESERVED), EIS); + if (eis & EIS_QFS) { + ris2 = ravb_read(ndev, RIS2); +- ravb_write(ndev, ~(RIS2_QFF0 | RIS2_RFFF), RIS2); ++ ravb_write(ndev, ~(RIS2_QFF0 | RIS2_RFFF | RIS2_RESERVED), ++ RIS2); + + /* Receive Descriptor Empty int */ + if (ris2 & RIS2_QFF0) +@@ -773,7 +774,7 @@ static bool ravb_timestamp_interrupt(struct net_device *ndev) + u32 tis = ravb_read(ndev, TIS); + + if (tis & TIS_TFUF) { +- ravb_write(ndev, ~TIS_TFUF, TIS); ++ ravb_write(ndev, ~(TIS_TFUF | TIS_RESERVED), TIS); + ravb_get_tx_tstamp(ndev); + return true; + } +@@ -908,7 +909,7 @@ static int ravb_poll(struct napi_struct *napi, int budget) + /* Processing RX Descriptor Ring */ + if (ris0 & mask) { + /* Clear RX interrupt */ +- ravb_write(ndev, ~mask, RIS0); ++ ravb_write(ndev, ~(mask | RIS0_RESERVED), RIS0); + if (ravb_rx(ndev, "a, q)) + goto out; + } +@@ -916,7 +917,7 @@ static int ravb_poll(struct napi_struct *napi, int budget) + if (tis & mask) { + spin_lock_irqsave(&priv->lock, flags); + /* Clear TX interrupt */ +- ravb_write(ndev, ~mask, TIS); ++ ravb_write(ndev, ~(mask | TIS_RESERVED), TIS); + ravb_tx_free(ndev, q, true); + netif_wake_subqueue(ndev, q); + mmiowb(); +diff --git a/drivers/net/ethernet/renesas/ravb_ptp.c b/drivers/net/ethernet/renesas/ravb_ptp.c +index eede70ec37f8..9e3222fd69f9 100644 +--- a/drivers/net/ethernet/renesas/ravb_ptp.c ++++ b/drivers/net/ethernet/renesas/ravb_ptp.c +@@ -319,7 +319,7 @@ void ravb_ptp_interrupt(struct net_device *ndev) + } + } + +- ravb_write(ndev, ~gis, GIS); ++ ravb_write(ndev, ~(gis | GIS_RESERVED), GIS); + } + + void ravb_ptp_init(struct net_device *ndev, struct platform_device *pdev) +diff --git a/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c b/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c +index 04148438d7ec..5ed28111c3c3 100644 +--- a/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c ++++ b/drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c +@@ -3342,11 +3342,10 @@ static int ibmvscsis_probe(struct vio_dev *vdev, + vscsi->dds.window[LOCAL].liobn, + vscsi->dds.window[REMOTE].liobn); + +- strcpy(vscsi->eye, "VSCSI "); +- strncat(vscsi->eye, vdev->name, MAX_EYE); ++ snprintf(vscsi->eye, sizeof(vscsi->eye), "VSCSI %s", vdev->name); + + vscsi->dds.unit_id = vdev->unit_address; +- strncpy(vscsi->dds.partition_name, partition_name, ++ strscpy(vscsi->dds.partition_name, partition_name, + sizeof(vscsi->dds.partition_name)); + vscsi->dds.partition_num = partition_number; + +diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c +index f8b6bf56c48e..ab999c4444b8 100644 +--- a/drivers/scsi/sd.c ++++ b/drivers/scsi/sd.c +@@ -1158,7 +1158,8 @@ static int sd_init_command(struct scsi_cmnd *cmd) + case REQ_OP_WRITE: + return sd_setup_read_write_cmnd(cmd); + default: +- BUG(); ++ WARN_ON_ONCE(1); ++ return BLKPREP_KILL; + } + } + +diff --git a/drivers/usb/gadget/function/u_serial.c b/drivers/usb/gadget/function/u_serial.c +index e0cd1e4c8892..2f151e0aa6da 100644 +--- a/drivers/usb/gadget/function/u_serial.c ++++ b/drivers/usb/gadget/function/u_serial.c +@@ -537,7 +537,7 @@ static void gs_rx_push(unsigned long _port) + } + + /* push data to (open) tty */ +- if (req->actual) { ++ if (req->actual && tty) { + char *packet = req->buf; + unsigned size = req->actual; + unsigned n; +diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h +index 43e27d8ec770..567a6c7af677 100644 +--- a/fs/ext4/ext4.h ++++ b/fs/ext4/ext4.h +@@ -3038,9 +3038,6 @@ extern struct buffer_head *ext4_get_first_inline_block(struct inode *inode, + extern int ext4_inline_data_fiemap(struct inode *inode, + struct fiemap_extent_info *fieinfo, + int *has_inline, __u64 start, __u64 len); +-extern int ext4_try_to_evict_inline_data(handle_t *handle, +- struct inode *inode, +- int needed); + extern void ext4_inline_data_truncate(struct inode *inode, int *has_inline); + + extern int ext4_convert_inline_data(struct inode *inode); +diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c +index 211539a7adfc..6779a9f1de3b 100644 +--- a/fs/ext4/inline.c ++++ b/fs/ext4/inline.c +@@ -889,11 +889,11 @@ retry_journal: + flags |= AOP_FLAG_NOFS; + + if (ret == -ENOSPC) { ++ ext4_journal_stop(handle); + ret = ext4_da_convert_inline_data_to_extent(mapping, + inode, + flags, + fsdata); +- ext4_journal_stop(handle); + if (ret == -ENOSPC && + ext4_should_retry_alloc(inode->i_sb, &retries)) + goto retry_journal; +@@ -1865,42 +1865,6 @@ out: + return (error < 0 ? error : 0); + } + +-/* +- * Called during xattr set, and if we can sparse space 'needed', +- * just create the extent tree evict the data to the outer block. +- * +- * We use jbd2 instead of page cache to move data to the 1st block +- * so that the whole transaction can be committed as a whole and +- * the data isn't lost because of the delayed page cache write. +- */ +-int ext4_try_to_evict_inline_data(handle_t *handle, +- struct inode *inode, +- int needed) +-{ +- int error; +- struct ext4_xattr_entry *entry; +- struct ext4_inode *raw_inode; +- struct ext4_iloc iloc; +- +- error = ext4_get_inode_loc(inode, &iloc); +- if (error) +- return error; +- +- raw_inode = ext4_raw_inode(&iloc); +- entry = (struct ext4_xattr_entry *)((void *)raw_inode + +- EXT4_I(inode)->i_inline_off); +- if (EXT4_XATTR_LEN(entry->e_name_len) + +- EXT4_XATTR_SIZE(le32_to_cpu(entry->e_value_size)) < needed) { +- error = -ENOSPC; +- goto out; +- } +- +- error = ext4_convert_inline_data_nolock(handle, inode, &iloc); +-out: +- brelse(iloc.bh); +- return error; +-} +- + void ext4_inline_data_truncate(struct inode *inode, int *has_inline) + { + handle_t *handle; +diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c +index 7d6da09e637b..38385bcb9148 100644 +--- a/fs/ext4/xattr.c ++++ b/fs/ext4/xattr.c +@@ -1086,22 +1086,8 @@ int ext4_xattr_ibody_inline_set(handle_t *handle, struct inode *inode, + if (EXT4_I(inode)->i_extra_isize == 0) + return -ENOSPC; + error = ext4_xattr_set_entry(i, s, inode); +- if (error) { +- if (error == -ENOSPC && +- ext4_has_inline_data(inode)) { +- error = ext4_try_to_evict_inline_data(handle, inode, +- EXT4_XATTR_LEN(strlen(i->name) + +- EXT4_XATTR_SIZE(i->value_len))); +- if (error) +- return error; +- error = ext4_xattr_ibody_find(inode, i, is); +- if (error) +- return error; +- error = ext4_xattr_set_entry(i, s, inode); +- } +- if (error) +- return error; +- } ++ if (error) ++ return error; + header = IHDR(inode, ext4_raw_inode(&is->iloc)); + if (!IS_LAST_ENTRY(s->first)) { + header->h_magic = cpu_to_le32(EXT4_XATTR_MAGIC); +diff --git a/fs/proc/stat.c b/fs/proc/stat.c +index d700c42b3572..44475a44cbf1 100644 +--- a/fs/proc/stat.c ++++ b/fs/proc/stat.c +@@ -21,23 +21,23 @@ + + #ifdef arch_idle_time + +-static cputime64_t get_idle_time(int cpu) ++static u64 get_idle_time(int cpu) + { +- cputime64_t idle; ++ u64 idle; + + idle = kcpustat_cpu(cpu).cpustat[CPUTIME_IDLE]; + if (cpu_online(cpu) && !nr_iowait_cpu(cpu)) +- idle += arch_idle_time(cpu); ++ idle += cputime_to_nsecs(arch_idle_time(cpu)); + return idle; + } + +-static cputime64_t get_iowait_time(int cpu) ++static u64 get_iowait_time(int cpu) + { +- cputime64_t iowait; ++ u64 iowait; + + iowait = kcpustat_cpu(cpu).cpustat[CPUTIME_IOWAIT]; + if (cpu_online(cpu) && nr_iowait_cpu(cpu)) +- iowait += arch_idle_time(cpu); ++ iowait += cputime_to_nsecs(arch_idle_time(cpu)); + return iowait; + } + +@@ -45,32 +45,32 @@ static cputime64_t get_iowait_time(int cpu) + + static u64 get_idle_time(int cpu) + { +- u64 idle, idle_time = -1ULL; ++ u64 idle, idle_usecs = -1ULL; + + if (cpu_online(cpu)) +- idle_time = get_cpu_idle_time_us(cpu, NULL); ++ idle_usecs = get_cpu_idle_time_us(cpu, NULL); + +- if (idle_time == -1ULL) ++ if (idle_usecs == -1ULL) + /* !NO_HZ or cpu offline so we can rely on cpustat.idle */ + idle = kcpustat_cpu(cpu).cpustat[CPUTIME_IDLE]; + else +- idle = usecs_to_cputime64(idle_time); ++ idle = idle_usecs * NSEC_PER_USEC; + + return idle; + } + + static u64 get_iowait_time(int cpu) + { +- u64 iowait, iowait_time = -1ULL; ++ u64 iowait, iowait_usecs = -1ULL; + + if (cpu_online(cpu)) +- iowait_time = get_cpu_iowait_time_us(cpu, NULL); ++ iowait_usecs = get_cpu_iowait_time_us(cpu, NULL); + +- if (iowait_time == -1ULL) ++ if (iowait_usecs == -1ULL) + /* !NO_HZ or cpu offline so we can rely on cpustat.iowait */ + iowait = kcpustat_cpu(cpu).cpustat[CPUTIME_IOWAIT]; + else +- iowait = usecs_to_cputime64(iowait_time); ++ iowait = iowait_usecs * NSEC_PER_USEC; + + return iowait; + } +@@ -115,16 +115,16 @@ static int show_stat(struct seq_file *p, void *v) + } + sum += arch_irq_stat(); + +- seq_put_decimal_ull(p, "cpu ", cputime64_to_clock_t(user)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(nice)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(system)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(idle)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(iowait)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(irq)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(softirq)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(steal)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(guest)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(guest_nice)); ++ seq_put_decimal_ull(p, "cpu ", nsec_to_clock_t(user)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(nice)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(system)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(idle)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(iowait)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(irq)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(softirq)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(steal)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(guest)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(guest_nice)); + seq_putc(p, '\n'); + + for_each_online_cpu(i) { +@@ -140,16 +140,16 @@ static int show_stat(struct seq_file *p, void *v) + guest = kcpustat_cpu(i).cpustat[CPUTIME_GUEST]; + guest_nice = kcpustat_cpu(i).cpustat[CPUTIME_GUEST_NICE]; + seq_printf(p, "cpu%d", i); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(user)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(nice)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(system)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(idle)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(iowait)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(irq)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(softirq)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(steal)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(guest)); +- seq_put_decimal_ull(p, " ", cputime64_to_clock_t(guest_nice)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(user)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(nice)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(system)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(idle)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(iowait)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(irq)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(softirq)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(steal)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(guest)); ++ seq_put_decimal_ull(p, " ", nsec_to_clock_t(guest_nice)); + seq_putc(p, '\n'); + } + seq_put_decimal_ull(p, "intr ", (unsigned long long)sum); +diff --git a/fs/proc/uptime.c b/fs/proc/uptime.c +index 33de567c25af..7981c4ffe787 100644 +--- a/fs/proc/uptime.c ++++ b/fs/proc/uptime.c +@@ -5,23 +5,20 @@ + #include <linux/seq_file.h> + #include <linux/time.h> + #include <linux/kernel_stat.h> +-#include <linux/cputime.h> + + static int uptime_proc_show(struct seq_file *m, void *v) + { + struct timespec uptime; + struct timespec idle; +- u64 idletime; + u64 nsec; + u32 rem; + int i; + +- idletime = 0; ++ nsec = 0; + for_each_possible_cpu(i) +- idletime += (__force u64) kcpustat_cpu(i).cpustat[CPUTIME_IDLE]; ++ nsec += (__force u64) kcpustat_cpu(i).cpustat[CPUTIME_IDLE]; + + get_monotonic_boottime(&uptime); +- nsec = cputime64_to_jiffies64(idletime) * TICK_NSEC; + idle.tv_sec = div_u64_rem(nsec, NSEC_PER_SEC, &rem); + idle.tv_nsec = rem; + seq_printf(m, "%lu.%02lu %lu.%02lu\n", +diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h +index e35e6de633b9..9b9f65d99873 100644 +--- a/include/linux/huge_mm.h ++++ b/include/linux/huge_mm.h +@@ -22,7 +22,7 @@ extern int mincore_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd, + unsigned char *vec); + extern bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr, + unsigned long new_addr, unsigned long old_end, +- pmd_t *old_pmd, pmd_t *new_pmd, bool *need_flush); ++ pmd_t *old_pmd, pmd_t *new_pmd); + extern int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd, + unsigned long addr, pgprot_t newprot, + int prot_numa); +diff --git a/kernel/sched/cpuacct.c b/kernel/sched/cpuacct.c +index bc0b309c3f19..4c882791c10c 100644 +--- a/kernel/sched/cpuacct.c ++++ b/kernel/sched/cpuacct.c +@@ -297,7 +297,7 @@ static int cpuacct_stats_show(struct seq_file *sf, void *v) + for (stat = 0; stat < CPUACCT_STAT_NSTATS; stat++) { + seq_printf(sf, "%s %lld\n", + cpuacct_stat_desc[stat], +- cputime64_to_clock_t(val[stat])); ++ nsec_to_clock_t(val[stat])); + } + + return 0; +diff --git a/kernel/sched/cputime.c b/kernel/sched/cputime.c +index 5ebee3164e64..448d6426fa5f 100644 +--- a/kernel/sched/cputime.c ++++ b/kernel/sched/cputime.c +@@ -37,6 +37,18 @@ void disable_sched_clock_irqtime(void) + sched_clock_irqtime = 0; + } + ++static void irqtime_account_delta(struct irqtime *irqtime, u64 delta, ++ enum cpu_usage_stat idx) ++{ ++ u64 *cpustat = kcpustat_this_cpu->cpustat; ++ ++ u64_stats_update_begin(&irqtime->sync); ++ cpustat[idx] += delta; ++ irqtime->total += delta; ++ irqtime->tick_delta += delta; ++ u64_stats_update_end(&irqtime->sync); ++} ++ + /* + * Called before incrementing preempt_count on {soft,}irq_enter + * and before decrementing preempt_count on {soft,}irq_exit. +@@ -54,7 +66,6 @@ void irqtime_account_irq(struct task_struct *curr) + delta = sched_clock_cpu(cpu) - irqtime->irq_start_time; + irqtime->irq_start_time += delta; + +- u64_stats_update_begin(&irqtime->sync); + /* + * We do not account for softirq time from ksoftirqd here. + * We want to continue accounting softirq time to ksoftirqd thread +@@ -62,48 +73,29 @@ void irqtime_account_irq(struct task_struct *curr) + * that do not consume any time, but still wants to run. + */ + if (hardirq_count()) +- irqtime->hardirq_time += delta; ++ irqtime_account_delta(irqtime, delta, CPUTIME_IRQ); + else if (in_serving_softirq() && curr != this_cpu_ksoftirqd()) +- irqtime->softirq_time += delta; +- +- u64_stats_update_end(&irqtime->sync); ++ irqtime_account_delta(irqtime, delta, CPUTIME_SOFTIRQ); + } + EXPORT_SYMBOL_GPL(irqtime_account_irq); + +-static cputime_t irqtime_account_update(u64 irqtime, int idx, cputime_t maxtime) ++static cputime_t irqtime_tick_accounted(cputime_t maxtime) + { +- u64 *cpustat = kcpustat_this_cpu->cpustat; +- cputime_t irq_cputime; +- +- irq_cputime = nsecs_to_cputime64(irqtime) - cpustat[idx]; +- irq_cputime = min(irq_cputime, maxtime); +- cpustat[idx] += irq_cputime; +- +- return irq_cputime; +-} ++ struct irqtime *irqtime = this_cpu_ptr(&cpu_irqtime); ++ cputime_t delta; + +-static cputime_t irqtime_account_hi_update(cputime_t maxtime) +-{ +- return irqtime_account_update(__this_cpu_read(cpu_irqtime.hardirq_time), +- CPUTIME_IRQ, maxtime); +-} ++ delta = nsecs_to_cputime(irqtime->tick_delta); ++ delta = min(delta, maxtime); ++ irqtime->tick_delta -= cputime_to_nsecs(delta); + +-static cputime_t irqtime_account_si_update(cputime_t maxtime) +-{ +- return irqtime_account_update(__this_cpu_read(cpu_irqtime.softirq_time), +- CPUTIME_SOFTIRQ, maxtime); ++ return delta; + } + + #else /* CONFIG_IRQ_TIME_ACCOUNTING */ + + #define sched_clock_irqtime (0) + +-static cputime_t irqtime_account_hi_update(cputime_t dummy) +-{ +- return 0; +-} +- +-static cputime_t irqtime_account_si_update(cputime_t dummy) ++static cputime_t irqtime_tick_accounted(cputime_t dummy) + { + return 0; + } +@@ -143,7 +135,7 @@ void account_user_time(struct task_struct *p, cputime_t cputime, + index = (task_nice(p) > 0) ? CPUTIME_NICE : CPUTIME_USER; + + /* Add user time to cpustat. */ +- task_group_account_field(p, index, (__force u64) cputime); ++ task_group_account_field(p, index, cputime_to_nsecs(cputime)); + + /* Account for user time used */ + acct_account_cputime(p); +@@ -168,11 +160,11 @@ static void account_guest_time(struct task_struct *p, cputime_t cputime, + + /* Add guest time to cpustat. */ + if (task_nice(p) > 0) { +- cpustat[CPUTIME_NICE] += (__force u64) cputime; +- cpustat[CPUTIME_GUEST_NICE] += (__force u64) cputime; ++ cpustat[CPUTIME_NICE] += cputime_to_nsecs(cputime); ++ cpustat[CPUTIME_GUEST_NICE] += cputime_to_nsecs(cputime); + } else { +- cpustat[CPUTIME_USER] += (__force u64) cputime; +- cpustat[CPUTIME_GUEST] += (__force u64) cputime; ++ cpustat[CPUTIME_USER] += cputime_to_nsecs(cputime); ++ cpustat[CPUTIME_GUEST] += cputime_to_nsecs(cputime); + } + } + +@@ -193,7 +185,7 @@ void __account_system_time(struct task_struct *p, cputime_t cputime, + account_group_system_time(p, cputime); + + /* Add system time to cpustat. */ +- task_group_account_field(p, index, (__force u64) cputime); ++ task_group_account_field(p, index, cputime_to_nsecs(cputime)); + + /* Account for system time used */ + acct_account_cputime(p); +@@ -234,7 +226,7 @@ void account_steal_time(cputime_t cputime) + { + u64 *cpustat = kcpustat_this_cpu->cpustat; + +- cpustat[CPUTIME_STEAL] += (__force u64) cputime; ++ cpustat[CPUTIME_STEAL] += cputime_to_nsecs(cputime); + } + + /* +@@ -247,9 +239,9 @@ void account_idle_time(cputime_t cputime) + struct rq *rq = this_rq(); + + if (atomic_read(&rq->nr_iowait) > 0) +- cpustat[CPUTIME_IOWAIT] += (__force u64) cputime; ++ cpustat[CPUTIME_IOWAIT] += cputime_to_nsecs(cputime); + else +- cpustat[CPUTIME_IDLE] += (__force u64) cputime; ++ cpustat[CPUTIME_IDLE] += cputime_to_nsecs(cputime); + } + + /* +@@ -290,10 +282,7 @@ static inline cputime_t account_other_time(cputime_t max) + accounted = steal_account_process_time(max); + + if (accounted < max) +- accounted += irqtime_account_hi_update(max - accounted); +- +- if (accounted < max) +- accounted += irqtime_account_si_update(max - accounted); ++ accounted += irqtime_tick_accounted(max - accounted); + + return accounted; + } +diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h +index f564a1d2c9d5..923cc35e8490 100644 +--- a/kernel/sched/sched.h ++++ b/kernel/sched/sched.h +@@ -4,6 +4,7 @@ + #include <linux/sched/rt.h> + #include <linux/u64_stats_sync.h> + #include <linux/sched/deadline.h> ++#include <linux/kernel_stat.h> + #include <linux/binfmts.h> + #include <linux/mutex.h> + #include <linux/spinlock.h> +@@ -1742,14 +1743,19 @@ static inline void nohz_balance_exit_idle(unsigned int cpu) { } + + #ifdef CONFIG_IRQ_TIME_ACCOUNTING + struct irqtime { +- u64 hardirq_time; +- u64 softirq_time; ++ u64 total; ++ u64 tick_delta; + u64 irq_start_time; + struct u64_stats_sync sync; + }; + + DECLARE_PER_CPU(struct irqtime, cpu_irqtime); + ++/* ++ * Returns the irqtime minus the softirq time computed by ksoftirqd. ++ * Otherwise ksoftirqd's sum_exec_runtime is substracted its own runtime ++ * and never move forward. ++ */ + static inline u64 irq_time_read(int cpu) + { + struct irqtime *irqtime = &per_cpu(cpu_irqtime, cpu); +@@ -1758,7 +1764,7 @@ static inline u64 irq_time_read(int cpu) + + do { + seq = __u64_stats_fetch_begin(&irqtime->sync); +- total = irqtime->softirq_time + irqtime->hardirq_time; ++ total = irqtime->total; + } while (__u64_stats_fetch_retry(&irqtime->sync, seq)); + + return total; +diff --git a/mm/huge_memory.c b/mm/huge_memory.c +index e4c6c3edaf6a..9f7bba700e4e 100644 +--- a/mm/huge_memory.c ++++ b/mm/huge_memory.c +@@ -1445,7 +1445,7 @@ int zap_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma, + + bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr, + unsigned long new_addr, unsigned long old_end, +- pmd_t *old_pmd, pmd_t *new_pmd, bool *need_flush) ++ pmd_t *old_pmd, pmd_t *new_pmd) + { + spinlock_t *old_ptl, *new_ptl; + pmd_t pmd; +@@ -1476,7 +1476,7 @@ bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr, + if (new_ptl != old_ptl) + spin_lock_nested(new_ptl, SINGLE_DEPTH_NESTING); + pmd = pmdp_huge_get_and_clear(mm, old_addr, old_pmd); +- if (pmd_present(pmd) && pmd_dirty(pmd)) ++ if (pmd_present(pmd)) + force_flush = true; + VM_BUG_ON(!pmd_none(*new_pmd)); + +@@ -1487,12 +1487,10 @@ bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr, + pgtable_trans_huge_deposit(mm, new_pmd, pgtable); + } + set_pmd_at(mm, new_addr, new_pmd, pmd_mksoft_dirty(pmd)); +- if (new_ptl != old_ptl) +- spin_unlock(new_ptl); + if (force_flush) + flush_tlb_range(vma, old_addr, old_addr + PMD_SIZE); +- else +- *need_flush = true; ++ if (new_ptl != old_ptl) ++ spin_unlock(new_ptl); + spin_unlock(old_ptl); + return true; + } +diff --git a/mm/mremap.c b/mm/mremap.c +index 15976716dd40..9e6035969d7b 100644 +--- a/mm/mremap.c ++++ b/mm/mremap.c +@@ -104,7 +104,7 @@ static pte_t move_soft_dirty_pte(pte_t pte) + static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, + unsigned long old_addr, unsigned long old_end, + struct vm_area_struct *new_vma, pmd_t *new_pmd, +- unsigned long new_addr, bool need_rmap_locks, bool *need_flush) ++ unsigned long new_addr, bool need_rmap_locks) + { + struct mm_struct *mm = vma->vm_mm; + pte_t *old_pte, *new_pte, pte; +@@ -152,15 +152,17 @@ static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, + + pte = ptep_get_and_clear(mm, old_addr, old_pte); + /* +- * If we are remapping a dirty PTE, make sure ++ * If we are remapping a valid PTE, make sure + * to flush TLB before we drop the PTL for the +- * old PTE or we may race with page_mkclean(). ++ * PTE. + * +- * This check has to be done after we removed the +- * old PTE from page tables or another thread may +- * dirty it after the check and before the removal. ++ * NOTE! Both old and new PTL matter: the old one ++ * for racing with page_mkclean(), the new one to ++ * make sure the physical page stays valid until ++ * the TLB entry for the old mapping has been ++ * flushed. + */ +- if (pte_present(pte) && pte_dirty(pte)) ++ if (pte_present(pte)) + force_flush = true; + pte = move_pte(pte, new_vma->vm_page_prot, old_addr, new_addr); + pte = move_soft_dirty_pte(pte); +@@ -168,13 +170,11 @@ static void move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, + } + + arch_leave_lazy_mmu_mode(); ++ if (force_flush) ++ flush_tlb_range(vma, old_end - len, old_end); + if (new_ptl != old_ptl) + spin_unlock(new_ptl); + pte_unmap(new_pte - 1); +- if (force_flush) +- flush_tlb_range(vma, old_end - len, old_end); +- else +- *need_flush = true; + pte_unmap_unlock(old_pte - 1, old_ptl); + if (need_rmap_locks) + drop_rmap_locks(vma); +@@ -189,7 +189,6 @@ unsigned long move_page_tables(struct vm_area_struct *vma, + { + unsigned long extent, next, old_end; + pmd_t *old_pmd, *new_pmd; +- bool need_flush = false; + unsigned long mmun_start; /* For mmu_notifiers */ + unsigned long mmun_end; /* For mmu_notifiers */ + +@@ -220,8 +219,7 @@ unsigned long move_page_tables(struct vm_area_struct *vma, + if (need_rmap_locks) + take_rmap_locks(vma); + moved = move_huge_pmd(vma, old_addr, new_addr, +- old_end, old_pmd, new_pmd, +- &need_flush); ++ old_end, old_pmd, new_pmd); + if (need_rmap_locks) + drop_rmap_locks(vma); + if (moved) +@@ -239,10 +237,8 @@ unsigned long move_page_tables(struct vm_area_struct *vma, + if (extent > LATENCY_LIMIT) + extent = LATENCY_LIMIT; + move_ptes(vma, old_pmd, old_addr, old_addr + extent, new_vma, +- new_pmd, new_addr, need_rmap_locks, &need_flush); ++ new_pmd, new_addr, need_rmap_locks); + } +- if (need_flush) +- flush_tlb_range(vma, old_end-len, old_addr); + + mmu_notifier_invalidate_range_end(vma->vm_mm, mmun_start, mmun_end); + +diff --git a/net/batman-adv/bat_v_elp.c b/net/batman-adv/bat_v_elp.c +index ee08540ce503..5d79004de25c 100644 +--- a/net/batman-adv/bat_v_elp.c ++++ b/net/batman-adv/bat_v_elp.c +@@ -243,6 +243,7 @@ static void batadv_v_elp_periodic_work(struct work_struct *work) + struct batadv_priv *bat_priv; + struct sk_buff *skb; + u32 elp_interval; ++ bool ret; + + bat_v = container_of(work, struct batadv_hard_iface_bat_v, elp_wq.work); + hard_iface = container_of(bat_v, struct batadv_hard_iface, bat_v); +@@ -304,8 +305,11 @@ static void batadv_v_elp_periodic_work(struct work_struct *work) + * may sleep and that is not allowed in an rcu protected + * context. Therefore schedule a task for that. + */ +- queue_work(batadv_event_workqueue, +- &hardif_neigh->bat_v.metric_work); ++ ret = queue_work(batadv_event_workqueue, ++ &hardif_neigh->bat_v.metric_work); ++ ++ if (!ret) ++ batadv_hardif_neigh_put(hardif_neigh); + } + rcu_read_unlock(); + +diff --git a/net/batman-adv/bridge_loop_avoidance.c b/net/batman-adv/bridge_loop_avoidance.c +index 582e27698bf0..8b6f654bc85d 100644 +--- a/net/batman-adv/bridge_loop_avoidance.c ++++ b/net/batman-adv/bridge_loop_avoidance.c +@@ -1767,6 +1767,7 @@ batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb, + { + struct batadv_bla_backbone_gw *backbone_gw; + struct ethhdr *ethhdr; ++ bool ret; + + ethhdr = eth_hdr(skb); + +@@ -1790,8 +1791,13 @@ batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb, + if (unlikely(!backbone_gw)) + return true; + +- queue_work(batadv_event_workqueue, &backbone_gw->report_work); +- /* backbone_gw is unreferenced in the report work function function */ ++ ret = queue_work(batadv_event_workqueue, &backbone_gw->report_work); ++ ++ /* backbone_gw is unreferenced in the report work function function ++ * if queue_work() call was successful ++ */ ++ if (!ret) ++ batadv_backbone_gw_put(backbone_gw); + + return true; + } +diff --git a/net/batman-adv/network-coding.c b/net/batman-adv/network-coding.c +index e3baf697a35c..a7b5cf08d363 100644 +--- a/net/batman-adv/network-coding.c ++++ b/net/batman-adv/network-coding.c +@@ -845,16 +845,27 @@ batadv_nc_get_nc_node(struct batadv_priv *bat_priv, + spinlock_t *lock; /* Used to lock list selected by "int in_coding" */ + struct list_head *list; + ++ /* Select ingoing or outgoing coding node */ ++ if (in_coding) { ++ lock = &orig_neigh_node->in_coding_list_lock; ++ list = &orig_neigh_node->in_coding_list; ++ } else { ++ lock = &orig_neigh_node->out_coding_list_lock; ++ list = &orig_neigh_node->out_coding_list; ++ } ++ ++ spin_lock_bh(lock); ++ + /* Check if nc_node is already added */ + nc_node = batadv_nc_find_nc_node(orig_node, orig_neigh_node, in_coding); + + /* Node found */ + if (nc_node) +- return nc_node; ++ goto unlock; + + nc_node = kzalloc(sizeof(*nc_node), GFP_ATOMIC); + if (!nc_node) +- return NULL; ++ goto unlock; + + /* Initialize nc_node */ + INIT_LIST_HEAD(&nc_node->list); +@@ -863,22 +874,14 @@ batadv_nc_get_nc_node(struct batadv_priv *bat_priv, + kref_get(&orig_neigh_node->refcount); + nc_node->orig_node = orig_neigh_node; + +- /* Select ingoing or outgoing coding node */ +- if (in_coding) { +- lock = &orig_neigh_node->in_coding_list_lock; +- list = &orig_neigh_node->in_coding_list; +- } else { +- lock = &orig_neigh_node->out_coding_list_lock; +- list = &orig_neigh_node->out_coding_list; +- } +- + batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_node %pM -> %pM\n", + nc_node->addr, nc_node->orig_node->orig); + + /* Add nc_node to orig_node */ +- spin_lock_bh(lock); + kref_get(&nc_node->refcount); + list_add_tail_rcu(&nc_node->list, list); ++ ++unlock: + spin_unlock_bh(lock); + + return nc_node; +diff --git a/net/batman-adv/soft-interface.c b/net/batman-adv/soft-interface.c +index 84c1b388d9ed..05bc176decf0 100644 +--- a/net/batman-adv/soft-interface.c ++++ b/net/batman-adv/soft-interface.c +@@ -565,15 +565,20 @@ int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid) + struct batadv_softif_vlan *vlan; + int err; + ++ spin_lock_bh(&bat_priv->softif_vlan_list_lock); ++ + vlan = batadv_softif_vlan_get(bat_priv, vid); + if (vlan) { + batadv_softif_vlan_put(vlan); ++ spin_unlock_bh(&bat_priv->softif_vlan_list_lock); + return -EEXIST; + } + + vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC); +- if (!vlan) ++ if (!vlan) { ++ spin_unlock_bh(&bat_priv->softif_vlan_list_lock); + return -ENOMEM; ++ } + + vlan->bat_priv = bat_priv; + vlan->vid = vid; +@@ -581,17 +586,23 @@ int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid) + + atomic_set(&vlan->ap_isolation, 0); + ++ kref_get(&vlan->refcount); ++ hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list); ++ spin_unlock_bh(&bat_priv->softif_vlan_list_lock); ++ ++ /* batadv_sysfs_add_vlan cannot be in the spinlock section due to the ++ * sleeping behavior of the sysfs functions and the fs_reclaim lock ++ */ + err = batadv_sysfs_add_vlan(bat_priv->soft_iface, vlan); + if (err) { +- kfree(vlan); ++ /* ref for the function */ ++ batadv_softif_vlan_put(vlan); ++ ++ /* ref for the list */ ++ batadv_softif_vlan_put(vlan); + return err; + } + +- spin_lock_bh(&bat_priv->softif_vlan_list_lock); +- kref_get(&vlan->refcount); +- hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list); +- spin_unlock_bh(&bat_priv->softif_vlan_list_lock); +- + /* add a new TT local entry. This one will be marked with the NOPURGE + * flag + */ +diff --git a/net/batman-adv/sysfs.c b/net/batman-adv/sysfs.c +index 02d96f224c60..31d7e239a1fd 100644 +--- a/net/batman-adv/sysfs.c ++++ b/net/batman-adv/sysfs.c +@@ -187,7 +187,8 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ + \ + return __batadv_store_uint_attr(buff, count, _min, _max, \ + _post_func, attr, \ +- &bat_priv->_var, net_dev); \ ++ &bat_priv->_var, net_dev, \ ++ NULL); \ + } + + #define BATADV_ATTR_SIF_SHOW_UINT(_name, _var) \ +@@ -261,7 +262,9 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ + \ + length = __batadv_store_uint_attr(buff, count, _min, _max, \ + _post_func, attr, \ +- &hard_iface->_var, net_dev); \ ++ &hard_iface->_var, \ ++ hard_iface->soft_iface, \ ++ net_dev); \ + \ + batadv_hardif_put(hard_iface); \ + return length; \ +@@ -355,10 +358,12 @@ __batadv_store_bool_attr(char *buff, size_t count, + + static int batadv_store_uint_attr(const char *buff, size_t count, + struct net_device *net_dev, ++ struct net_device *slave_dev, + const char *attr_name, + unsigned int min, unsigned int max, + atomic_t *attr) + { ++ char ifname[IFNAMSIZ + 3] = ""; + unsigned long uint_val; + int ret; + +@@ -384,8 +389,11 @@ static int batadv_store_uint_attr(const char *buff, size_t count, + if (atomic_read(attr) == uint_val) + return count; + +- batadv_info(net_dev, "%s: Changing from: %i to: %lu\n", +- attr_name, atomic_read(attr), uint_val); ++ if (slave_dev) ++ snprintf(ifname, sizeof(ifname), "%s: ", slave_dev->name); ++ ++ batadv_info(net_dev, "%s: %sChanging from: %i to: %lu\n", ++ attr_name, ifname, atomic_read(attr), uint_val); + + atomic_set(attr, uint_val); + return count; +@@ -396,12 +404,13 @@ static ssize_t __batadv_store_uint_attr(const char *buff, size_t count, + void (*post_func)(struct net_device *), + const struct attribute *attr, + atomic_t *attr_store, +- struct net_device *net_dev) ++ struct net_device *net_dev, ++ struct net_device *slave_dev) + { + int ret; + +- ret = batadv_store_uint_attr(buff, count, net_dev, attr->name, min, max, +- attr_store); ++ ret = batadv_store_uint_attr(buff, count, net_dev, slave_dev, ++ attr->name, min, max, attr_store); + if (post_func && ret) + post_func(net_dev); + +@@ -570,7 +579,7 @@ static ssize_t batadv_store_gw_sel_class(struct kobject *kobj, + return __batadv_store_uint_attr(buff, count, 1, BATADV_TQ_MAX_VALUE, + batadv_post_gw_reselect, attr, + &bat_priv->gw.sel_class, +- bat_priv->soft_iface); ++ bat_priv->soft_iface, NULL); + } + + static ssize_t batadv_show_gw_bwidth(struct kobject *kobj, +@@ -1084,8 +1093,9 @@ static ssize_t batadv_store_throughput_override(struct kobject *kobj, + if (old_tp_override == tp_override) + goto out; + +- batadv_info(net_dev, "%s: Changing from: %u.%u MBit to: %u.%u MBit\n", +- "throughput_override", ++ batadv_info(hard_iface->soft_iface, ++ "%s: %s: Changing from: %u.%u MBit to: %u.%u MBit\n", ++ "throughput_override", net_dev->name, + old_tp_override / 10, old_tp_override % 10, + tp_override / 10, tp_override % 10); + +diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c +index 0dc85eb1cb7a..b9f9a310eb78 100644 +--- a/net/batman-adv/translation-table.c ++++ b/net/batman-adv/translation-table.c +@@ -1550,6 +1550,8 @@ batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global, + { + struct batadv_tt_orig_list_entry *orig_entry; + ++ spin_lock_bh(&tt_global->list_lock); ++ + orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node); + if (orig_entry) { + /* refresh the ttvn: the current value could be a bogus one that +@@ -1570,16 +1572,16 @@ batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global, + orig_entry->ttvn = ttvn; + kref_init(&orig_entry->refcount); + +- spin_lock_bh(&tt_global->list_lock); + kref_get(&orig_entry->refcount); + hlist_add_head_rcu(&orig_entry->list, + &tt_global->orig_list); +- spin_unlock_bh(&tt_global->list_lock); + atomic_inc(&tt_global->orig_list_count); + + out: + if (orig_entry) + batadv_tt_orig_list_entry_put(orig_entry); ++ ++ spin_unlock_bh(&tt_global->list_lock); + } + + /** +diff --git a/net/batman-adv/tvlv.c b/net/batman-adv/tvlv.c +index 77654f055f24..8e91a26e9b00 100644 +--- a/net/batman-adv/tvlv.c ++++ b/net/batman-adv/tvlv.c +@@ -528,15 +528,20 @@ void batadv_tvlv_handler_register(struct batadv_priv *bat_priv, + { + struct batadv_tvlv_handler *tvlv_handler; + ++ spin_lock_bh(&bat_priv->tvlv.handler_list_lock); ++ + tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version); + if (tvlv_handler) { ++ spin_unlock_bh(&bat_priv->tvlv.handler_list_lock); + batadv_tvlv_handler_put(tvlv_handler); + return; + } + + tvlv_handler = kzalloc(sizeof(*tvlv_handler), GFP_ATOMIC); +- if (!tvlv_handler) ++ if (!tvlv_handler) { ++ spin_unlock_bh(&bat_priv->tvlv.handler_list_lock); + return; ++ } + + tvlv_handler->ogm_handler = optr; + tvlv_handler->unicast_handler = uptr; +@@ -546,7 +551,6 @@ void batadv_tvlv_handler_register(struct batadv_priv *bat_priv, + kref_init(&tvlv_handler->refcount); + INIT_HLIST_NODE(&tvlv_handler->list); + +- spin_lock_bh(&bat_priv->tvlv.handler_list_lock); + kref_get(&tvlv_handler->refcount); + hlist_add_head_rcu(&tvlv_handler->list, &bat_priv->tvlv.handler_list); + spin_unlock_bh(&bat_priv->tvlv.handler_list_lock); +diff --git a/net/netfilter/nf_nat_core.c b/net/netfilter/nf_nat_core.c +index 624d6e4dcd5c..51b0d832bd07 100644 +--- a/net/netfilter/nf_nat_core.c ++++ b/net/netfilter/nf_nat_core.c +@@ -421,7 +421,7 @@ nf_nat_setup_info(struct nf_conn *ct, + else + ct->status |= IPS_DST_NAT; + +- if (nfct_help(ct)) ++ if (nfct_help(ct) && !nfct_seqadj(ct)) + if (!nfct_seqadj_ext_add(ct)) + return NF_DROP; + }
