[gentoo-commits] proj/linux-patches:5.4 commit in: /

[Mike Pagano]

commit:     e670d9ccb903b2d03030936da7a9de29de88a247
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Fri Mar 17 10:45:47 2023 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Fri Mar 17 10:45:47 2023 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=e670d9cc

Linux patch 5.4.237

Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org>

 0000_README              |    4 +
 1236_linux-5.4.237.patch | 2763 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 2767 insertions(+)

diff --git a/0000_README b/0000_README
index 70998c7a..682673ff 100644
--- a/0000_README
+++ b/0000_README
@@ -987,6 +987,10 @@ Patch:  1235_linux-5.4.236.patch
 From:   https://www.kernel.org
 Desc:   Linux 5.4.236
 
+Patch:  1236_linux-5.4.237.patch
+From:   https://www.kernel.org
+Desc:   Linux 5.4.237
+
 Patch:  1500_XATTR_USER_PREFIX.patch
 From:   https://bugs.gentoo.org/show_bug.cgi?id=470644
 Desc:   Support for namespace user.pax.* on tmpfs.

diff --git a/1236_linux-5.4.237.patch b/1236_linux-5.4.237.patch
new file mode 100644
index 00000000..6f26d2d7
--- /dev/null
+++ b/1236_linux-5.4.237.patch
@@ -0,0 +1,2763 @@
+diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
+index 8f71a17ad5442..5e5704faae24a 100644
+--- a/Documentation/admin-guide/kernel-parameters.txt
++++ b/Documentation/admin-guide/kernel-parameters.txt
+@@ -1944,24 +1944,57 @@
+ 
+ 	ivrs_ioapic	[HW,X86_64]
+ 			Provide an override to the IOAPIC-ID<->DEVICE-ID
+-			mapping provided in the IVRS ACPI table. For
+-			example, to map IOAPIC-ID decimal 10 to
+-			PCI device 00:14.0 write the parameter as:
++			mapping provided in the IVRS ACPI table.
++			By default, PCI segment is 0, and can be omitted.
++
++			For example, to map IOAPIC-ID decimal 10 to
++			PCI segment 0x1 and PCI device 00:14.0,
++			write the parameter as:
++				ivrs_ioapic=10@0001:00:14.0
++
++			Deprecated formats:
++			* To map IOAPIC-ID decimal 10 to PCI device 00:14.0
++			  write the parameter as:
+ 				ivrs_ioapic[10]=00:14.0
++			* To map IOAPIC-ID decimal 10 to PCI segment 0x1 and
++			  PCI device 00:14.0 write the parameter as:
++				ivrs_ioapic[10]=0001:00:14.0
+ 
+ 	ivrs_hpet	[HW,X86_64]
+ 			Provide an override to the HPET-ID<->DEVICE-ID
+-			mapping provided in the IVRS ACPI table. For
+-			example, to map HPET-ID decimal 0 to
+-			PCI device 00:14.0 write the parameter as:
++			mapping provided in the IVRS ACPI table.
++			By default, PCI segment is 0, and can be omitted.
++
++			For example, to map HPET-ID decimal 10 to
++			PCI segment 0x1 and PCI device 00:14.0,
++			write the parameter as:
++				ivrs_hpet=10@0001:00:14.0
++
++			Deprecated formats:
++			* To map HPET-ID decimal 0 to PCI device 00:14.0
++			  write the parameter as:
+ 				ivrs_hpet[0]=00:14.0
++			* To map HPET-ID decimal 10 to PCI segment 0x1 and
++			  PCI device 00:14.0 write the parameter as:
++				ivrs_ioapic[10]=0001:00:14.0
+ 
+ 	ivrs_acpihid	[HW,X86_64]
+ 			Provide an override to the ACPI-HID:UID<->DEVICE-ID
+-			mapping provided in the IVRS ACPI table. For
+-			example, to map UART-HID:UID AMD0020:0 to
+-			PCI device 00:14.5 write the parameter as:
++			mapping provided in the IVRS ACPI table.
++			By default, PCI segment is 0, and can be omitted.
++
++			For example, to map UART-HID:UID AMD0020:0 to
++			PCI segment 0x1 and PCI device ID 00:14.5,
++			write the parameter as:
++				ivrs_acpihid=AMD0020:0@0001:00:14.5
++
++			Deprecated formats:
++			* To map UART-HID:UID AMD0020:0 to PCI segment is 0,
++			  PCI device ID 00:14.5, write the parameter as:
+ 				ivrs_acpihid[00:14.5]=AMD0020:0
++			* To map UART-HID:UID AMD0020:0 to PCI segment 0x1 and
++			  PCI device ID 00:14.5, write the parameter as:
++				ivrs_acpihid[0001:00:14.5]=AMD0020:0
+ 
+ 	js=		[HW,JOY] Analog joystick
+ 			See Documentation/input/joydev/joystick.rst.
+diff --git a/Makefile b/Makefile
+index e3b56259d50af..ccac1c82eb781 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 5
+ PATCHLEVEL = 4
+-SUBLEVEL = 236
++SUBLEVEL = 237
+ EXTRAVERSION =
+ NAME = Kleptomaniac Octopus
+ 
+diff --git a/arch/alpha/kernel/module.c b/arch/alpha/kernel/module.c
+index ac110ae8f9780..b19a8aae74e1f 100644
+--- a/arch/alpha/kernel/module.c
++++ b/arch/alpha/kernel/module.c
+@@ -146,10 +146,8 @@ apply_relocate_add(Elf64_Shdr *sechdrs, const char *strtab,
+ 	base = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr;
+ 	symtab = (Elf64_Sym *)sechdrs[symindex].sh_addr;
+ 
+-	/* The small sections were sorted to the end of the segment.
+-	   The following should definitely cover them.  */
+-	gp = (u64)me->core_layout.base + me->core_layout.size - 0x8000;
+ 	got = sechdrs[me->arch.gotsecindex].sh_addr;
++	gp = got + 0x8000;
+ 
+ 	for (i = 0; i < n; i++) {
+ 		unsigned long r_sym = ELF64_R_SYM (rela[i].r_info);
+diff --git a/arch/mips/include/asm/mach-rc32434/pci.h b/arch/mips/include/asm/mach-rc32434/pci.h
+index 6f40d1515580b..1ff8a987025c8 100644
+--- a/arch/mips/include/asm/mach-rc32434/pci.h
++++ b/arch/mips/include/asm/mach-rc32434/pci.h
+@@ -377,7 +377,7 @@ struct pci_msu {
+ 				 PCI_CFG04_STAT_SSE | \
+ 				 PCI_CFG04_STAT_PE)
+ 
+-#define KORINA_CNFG1		((KORINA_STAT<<16)|KORINA_CMD)
++#define KORINA_CNFG1		(KORINA_STAT | KORINA_CMD)
+ 
+ #define KORINA_REVID		0
+ #define KORINA_CLASS_CODE	0
+diff --git a/arch/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S
+index 3ea360cad337b..46dfb3701c6ea 100644
+--- a/arch/powerpc/kernel/vmlinux.lds.S
++++ b/arch/powerpc/kernel/vmlinux.lds.S
+@@ -6,6 +6,7 @@
+ #endif
+ 
+ #define BSS_FIRST_SECTIONS *(.bss.prominit)
++#define RUNTIME_DISCARD_EXIT
+ 
+ #include <asm/page.h>
+ #include <asm-generic/vmlinux.lds.h>
+@@ -394,9 +395,12 @@ SECTIONS
+ 	DISCARDS
+ 	/DISCARD/ : {
+ 		*(*.EMB.apuinfo)
+-		*(.glink .iplt .plt .rela* .comment)
++		*(.glink .iplt .plt .comment)
+ 		*(.gnu.version*)
+ 		*(.gnu.attributes)
+ 		*(.eh_frame)
++#ifndef CONFIG_RELOCATABLE
++		*(.rela*)
++#endif
+ 	}
+ }
+diff --git a/arch/riscv/kernel/stacktrace.c b/arch/riscv/kernel/stacktrace.c
+index 19e46f4160cc3..5ba4d23971fdb 100644
+--- a/arch/riscv/kernel/stacktrace.c
++++ b/arch/riscv/kernel/stacktrace.c
+@@ -89,7 +89,7 @@ void notrace walk_stackframe(struct task_struct *task,
+ 	while (!kstack_end(ksp)) {
+ 		if (__kernel_text_address(pc) && unlikely(fn(pc, arg)))
+ 			break;
+-		pc = (*ksp++) - 0x4;
++		pc = READ_ONCE_NOCHECK(*ksp++) - 0x4;
+ 	}
+ }
+ 
+diff --git a/arch/s390/kernel/vmlinux.lds.S b/arch/s390/kernel/vmlinux.lds.S
+index 99053c80388e4..f8cc4e8524bff 100644
+--- a/arch/s390/kernel/vmlinux.lds.S
++++ b/arch/s390/kernel/vmlinux.lds.S
+@@ -15,6 +15,8 @@
+ /* Handle ro_after_init data on our own. */
+ #define RO_AFTER_INIT_DATA
+ 
++#define RUNTIME_DISCARD_EXIT
++
+ #include <asm-generic/vmlinux.lds.h>
+ #include <asm/vmlinux.lds.h>
+ 
+diff --git a/arch/sh/kernel/vmlinux.lds.S b/arch/sh/kernel/vmlinux.lds.S
+index 77a59d8c6b4d4..ec3bae172b203 100644
+--- a/arch/sh/kernel/vmlinux.lds.S
++++ b/arch/sh/kernel/vmlinux.lds.S
+@@ -10,6 +10,7 @@ OUTPUT_ARCH(sh:sh5)
+ #define LOAD_OFFSET	0
+ OUTPUT_ARCH(sh)
+ #endif
++#define RUNTIME_DISCARD_EXIT
+ 
+ #include <asm/thread_info.h>
+ #include <asm/cache.h>
+diff --git a/arch/um/kernel/vmlinux.lds.S b/arch/um/kernel/vmlinux.lds.S
+index 16e49bfa2b426..53d719c04ba94 100644
+--- a/arch/um/kernel/vmlinux.lds.S
++++ b/arch/um/kernel/vmlinux.lds.S
+@@ -1,4 +1,4 @@
+-
++#define RUNTIME_DISCARD_EXIT
+ KERNEL_STACK_SIZE = 4096 * (1 << CONFIG_KERNEL_STACK_ORDER);
+ 
+ #ifdef CONFIG_LD_SCRIPT_STATIC
+diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c
+index bc6cd29ddf163..b212771df0226 100644
+--- a/arch/x86/kernel/cpu/amd.c
++++ b/arch/x86/kernel/cpu/amd.c
+@@ -205,6 +205,15 @@ static void init_amd_k6(struct cpuinfo_x86 *c)
+ 		return;
+ 	}
+ #endif
++	/*
++	 * Work around Erratum 1386.  The XSAVES instruction malfunctions in
++	 * certain circumstances on Zen1/2 uarch, and not all parts have had
++	 * updated microcode at the time of writing (March 2023).
++	 *
++	 * Affected parts all have no supervisor XSAVE states, meaning that
++	 * the XSAVEC instruction (which works fine) is equivalent.
++	 */
++	clear_cpu_cap(c, X86_FEATURE_XSAVES);
+ }
+ 
+ static void init_amd_k7(struct cpuinfo_x86 *c)
+diff --git a/arch/x86/kernel/vmlinux.lds.S b/arch/x86/kernel/vmlinux.lds.S
+index 1afe211d7a7ca..7e0e21082c93e 100644
+--- a/arch/x86/kernel/vmlinux.lds.S
++++ b/arch/x86/kernel/vmlinux.lds.S
+@@ -21,6 +21,8 @@
+ #define LOAD_OFFSET __START_KERNEL_map
+ #endif
+ 
++#define RUNTIME_DISCARD_EXIT
++
+ #include <asm-generic/vmlinux.lds.h>
+ #include <asm/asm-offsets.h>
+ #include <asm/thread_info.h>
+diff --git a/drivers/char/ipmi/ipmi_ssif.c b/drivers/char/ipmi/ipmi_ssif.c
+index d6b69e19f78a7..d5f068a10a5a0 100644
+--- a/drivers/char/ipmi/ipmi_ssif.c
++++ b/drivers/char/ipmi/ipmi_ssif.c
+@@ -79,7 +79,8 @@
+ /*
+  * Timer values
+  */
+-#define SSIF_MSG_USEC		20000	/* 20ms between message tries. */
++#define SSIF_MSG_USEC		60000	/* 60ms between message tries (T3). */
++#define SSIF_REQ_RETRY_USEC	60000	/* 60ms between send retries (T6). */
+ #define SSIF_MSG_PART_USEC	5000	/* 5ms for a message part */
+ 
+ /* How many times to we retry sending/receiving the message. */
+@@ -87,7 +88,9 @@
+ #define	SSIF_RECV_RETRIES	250
+ 
+ #define SSIF_MSG_MSEC		(SSIF_MSG_USEC / 1000)
++#define SSIF_REQ_RETRY_MSEC	(SSIF_REQ_RETRY_USEC / 1000)
+ #define SSIF_MSG_JIFFIES	((SSIF_MSG_USEC * 1000) / TICK_NSEC)
++#define SSIF_REQ_RETRY_JIFFIES	((SSIF_REQ_RETRY_USEC * 1000) / TICK_NSEC)
+ #define SSIF_MSG_PART_JIFFIES	((SSIF_MSG_PART_USEC * 1000) / TICK_NSEC)
+ 
+ /*
+@@ -236,6 +239,9 @@ struct ssif_info {
+ 	bool		    got_alert;
+ 	bool		    waiting_alert;
+ 
++	/* Used to inform the timeout that it should do a resend. */
++	bool		    do_resend;
++
+ 	/*
+ 	 * If set to true, this will request events the next time the
+ 	 * state machine is idle.
+@@ -248,12 +254,6 @@ struct ssif_info {
+ 	 */
+ 	bool                req_flags;
+ 
+-	/*
+-	 * Used to perform timer operations when run-to-completion
+-	 * mode is on.  This is a countdown timer.
+-	 */
+-	int                 rtc_us_timer;
+-
+ 	/* Used for sending/receiving data.  +1 for the length. */
+ 	unsigned char data[IPMI_MAX_MSG_LENGTH + 1];
+ 	unsigned int  data_len;
+@@ -515,7 +515,7 @@ static int ipmi_ssif_thread(void *data)
+ 	return 0;
+ }
+ 
+-static int ssif_i2c_send(struct ssif_info *ssif_info,
++static void ssif_i2c_send(struct ssif_info *ssif_info,
+ 			ssif_i2c_done handler,
+ 			int read_write, int command,
+ 			unsigned char *data, unsigned int size)
+@@ -527,7 +527,6 @@ static int ssif_i2c_send(struct ssif_info *ssif_info,
+ 	ssif_info->i2c_data = data;
+ 	ssif_info->i2c_size = size;
+ 	complete(&ssif_info->wake_thread);
+-	return 0;
+ }
+ 
+ 
+@@ -536,40 +535,35 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
+ 
+ static void start_get(struct ssif_info *ssif_info)
+ {
+-	int rv;
+-
+-	ssif_info->rtc_us_timer = 0;
+ 	ssif_info->multi_pos = 0;
+ 
+-	rv = ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ,
+-			  SSIF_IPMI_RESPONSE,
+-			  ssif_info->recv, I2C_SMBUS_BLOCK_DATA);
+-	if (rv < 0) {
+-		/* request failed, just return the error. */
+-		if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
+-			dev_dbg(&ssif_info->client->dev,
+-				"Error from i2c_non_blocking_op(5)\n");
+-
+-		msg_done_handler(ssif_info, -EIO, NULL, 0);
+-	}
++	ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ,
++		  SSIF_IPMI_RESPONSE,
++		  ssif_info->recv, I2C_SMBUS_BLOCK_DATA);
+ }
+ 
++static void start_resend(struct ssif_info *ssif_info);
++
+ static void retry_timeout(struct timer_list *t)
+ {
+ 	struct ssif_info *ssif_info = from_timer(ssif_info, t, retry_timer);
+ 	unsigned long oflags, *flags;
+-	bool waiting;
++	bool waiting, resend;
+ 
+ 	if (ssif_info->stopping)
+ 		return;
+ 
+ 	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
++	resend = ssif_info->do_resend;
++	ssif_info->do_resend = false;
+ 	waiting = ssif_info->waiting_alert;
+ 	ssif_info->waiting_alert = false;
+ 	ipmi_ssif_unlock_cond(ssif_info, flags);
+ 
+ 	if (waiting)
+ 		start_get(ssif_info);
++	if (resend)
++		start_resend(ssif_info);
+ }
+ 
+ static void watch_timeout(struct timer_list *t)
+@@ -618,14 +612,11 @@ static void ssif_alert(struct i2c_client *client, enum i2c_alert_protocol type,
+ 		start_get(ssif_info);
+ }
+ 
+-static int start_resend(struct ssif_info *ssif_info);
+-
+ static void msg_done_handler(struct ssif_info *ssif_info, int result,
+ 			     unsigned char *data, unsigned int len)
+ {
+ 	struct ipmi_smi_msg *msg;
+ 	unsigned long oflags, *flags;
+-	int rv;
+ 
+ 	/*
+ 	 * We are single-threaded here, so no need for a lock until we
+@@ -639,7 +630,6 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
+ 
+ 			flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
+ 			ssif_info->waiting_alert = true;
+-			ssif_info->rtc_us_timer = SSIF_MSG_USEC;
+ 			if (!ssif_info->stopping)
+ 				mod_timer(&ssif_info->retry_timer,
+ 					  jiffies + SSIF_MSG_JIFFIES);
+@@ -671,17 +661,10 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
+ 		ssif_info->multi_len = len;
+ 		ssif_info->multi_pos = 1;
+ 
+-		rv = ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ,
+-				  SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE,
+-				  ssif_info->recv, I2C_SMBUS_BLOCK_DATA);
+-		if (rv < 0) {
+-			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
+-				dev_dbg(&ssif_info->client->dev,
+-					"Error from i2c_non_blocking_op(1)\n");
+-
+-			result = -EIO;
+-		} else
+-			return;
++		ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ,
++			 SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE,
++			 ssif_info->recv, I2C_SMBUS_BLOCK_DATA);
++		return;
+ 	} else if (ssif_info->multi_pos) {
+ 		/* Middle of multi-part read.  Start the next transaction. */
+ 		int i;
+@@ -743,19 +726,12 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
+ 
+ 			ssif_info->multi_pos++;
+ 
+-			rv = ssif_i2c_send(ssif_info, msg_done_handler,
+-					   I2C_SMBUS_READ,
+-					   SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE,
+-					   ssif_info->recv,
+-					   I2C_SMBUS_BLOCK_DATA);
+-			if (rv < 0) {
+-				if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
+-					dev_dbg(&ssif_info->client->dev,
+-						"Error from ssif_i2c_send\n");
+-
+-				result = -EIO;
+-			} else
+-				return;
++			ssif_i2c_send(ssif_info, msg_done_handler,
++				  I2C_SMBUS_READ,
++				  SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE,
++				  ssif_info->recv,
++				  I2C_SMBUS_BLOCK_DATA);
++			return;
+ 		}
+ 	}
+ 
+@@ -936,37 +912,27 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
+ static void msg_written_handler(struct ssif_info *ssif_info, int result,
+ 				unsigned char *data, unsigned int len)
+ {
+-	int rv;
+-
+ 	/* We are single-threaded here, so no need for a lock. */
+ 	if (result < 0) {
+ 		ssif_info->retries_left--;
+ 		if (ssif_info->retries_left > 0) {
+-			if (!start_resend(ssif_info)) {
+-				ssif_inc_stat(ssif_info, send_retries);
+-				return;
+-			}
+-			/* request failed, just return the error. */
+-			ssif_inc_stat(ssif_info, send_errors);
+-
+-			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
+-				dev_dbg(&ssif_info->client->dev,
+-					"%s: Out of retries\n", __func__);
+-			msg_done_handler(ssif_info, -EIO, NULL, 0);
++			/*
++			 * Wait the retry timeout time per the spec,
++			 * then redo the send.
++			 */
++			ssif_info->do_resend = true;
++			mod_timer(&ssif_info->retry_timer,
++				  jiffies + SSIF_REQ_RETRY_JIFFIES);
+ 			return;
+ 		}
+ 
+ 		ssif_inc_stat(ssif_info, send_errors);
+ 
+-		/*
+-		 * Got an error on transmit, let the done routine
+-		 * handle it.
+-		 */
+ 		if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
+ 			dev_dbg(&ssif_info->client->dev,
+-				"%s: Error  %d\n", __func__, result);
++				"%s: Out of retries\n", __func__);
+ 
+-		msg_done_handler(ssif_info, result, NULL, 0);
++		msg_done_handler(ssif_info, -EIO, NULL, 0);
+ 		return;
+ 	}
+ 
+@@ -1000,18 +966,9 @@ static void msg_written_handler(struct ssif_info *ssif_info, int result,
+ 			ssif_info->multi_data = NULL;
+ 		}
+ 
+-		rv = ssif_i2c_send(ssif_info, msg_written_handler,
+-				   I2C_SMBUS_WRITE, cmd,
+-				   data_to_send, I2C_SMBUS_BLOCK_DATA);
+-		if (rv < 0) {
+-			/* request failed, just return the error. */
+-			ssif_inc_stat(ssif_info, send_errors);
+-
+-			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
+-				dev_dbg(&ssif_info->client->dev,
+-					"Error from i2c_non_blocking_op(3)\n");
+-			msg_done_handler(ssif_info, -EIO, NULL, 0);
+-		}
++		ssif_i2c_send(ssif_info, msg_written_handler,
++			  I2C_SMBUS_WRITE, cmd,
++			  data_to_send, I2C_SMBUS_BLOCK_DATA);
+ 	} else {
+ 		/* Ready to request the result. */
+ 		unsigned long oflags, *flags;
+@@ -1029,7 +986,6 @@ static void msg_written_handler(struct ssif_info *ssif_info, int result,
+ 			/* Wait a jiffie then request the next message */
+ 			ssif_info->waiting_alert = true;
+ 			ssif_info->retries_left = SSIF_RECV_RETRIES;
+-			ssif_info->rtc_us_timer = SSIF_MSG_PART_USEC;
+ 			if (!ssif_info->stopping)
+ 				mod_timer(&ssif_info->retry_timer,
+ 					  jiffies + SSIF_MSG_PART_JIFFIES);
+@@ -1038,9 +994,8 @@ static void msg_written_handler(struct ssif_info *ssif_info, int result,
+ 	}
+ }
+ 
+-static int start_resend(struct ssif_info *ssif_info)
++static void start_resend(struct ssif_info *ssif_info)
+ {
+-	int rv;
+ 	int command;
+ 
+ 	ssif_info->got_alert = false;
+@@ -1062,12 +1017,8 @@ static int start_resend(struct ssif_info *ssif_info)
+ 		ssif_info->data[0] = ssif_info->data_len;
+ 	}
+ 
+-	rv = ssif_i2c_send(ssif_info, msg_written_handler, I2C_SMBUS_WRITE,
+-			  command, ssif_info->data, I2C_SMBUS_BLOCK_DATA);
+-	if (rv && (ssif_info->ssif_debug & SSIF_DEBUG_MSG))
+-		dev_dbg(&ssif_info->client->dev,
+-			"Error from i2c_non_blocking_op(4)\n");
+-	return rv;
++	ssif_i2c_send(ssif_info, msg_written_handler, I2C_SMBUS_WRITE,
++		   command, ssif_info->data, I2C_SMBUS_BLOCK_DATA);
+ }
+ 
+ static int start_send(struct ssif_info *ssif_info,
+@@ -1082,7 +1033,8 @@ static int start_send(struct ssif_info *ssif_info,
+ 	ssif_info->retries_left = SSIF_SEND_RETRIES;
+ 	memcpy(ssif_info->data + 1, data, len);
+ 	ssif_info->data_len = len;
+-	return start_resend(ssif_info);
++	start_resend(ssif_info);
++	return 0;
+ }
+ 
+ /* Must be called with the message lock held. */
+@@ -1382,8 +1334,10 @@ static int do_cmd(struct i2c_client *client, int len, unsigned char *msg,
+ 	ret = i2c_smbus_write_block_data(client, SSIF_IPMI_REQUEST, len, msg);
+ 	if (ret) {
+ 		retry_cnt--;
+-		if (retry_cnt > 0)
++		if (retry_cnt > 0) {
++			msleep(SSIF_REQ_RETRY_MSEC);
+ 			goto retry1;
++		}
+ 		return -ENODEV;
+ 	}
+ 
+@@ -1523,8 +1477,10 @@ retry_write:
+ 					 32, msg);
+ 	if (ret) {
+ 		retry_cnt--;
+-		if (retry_cnt > 0)
++		if (retry_cnt > 0) {
++			msleep(SSIF_REQ_RETRY_MSEC);
+ 			goto retry_write;
++		}
+ 		dev_err(&client->dev, "Could not write multi-part start, though the BMC said it could handle it.  Just limit sends to one part.\n");
+ 		return ret;
+ 	}
+diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
+index 72ad7fff64a7a..ccb62c480bdd7 100644
+--- a/drivers/char/ipmi/ipmi_watchdog.c
++++ b/drivers/char/ipmi/ipmi_watchdog.c
+@@ -498,7 +498,7 @@ static void panic_halt_ipmi_heartbeat(void)
+ 	msg.cmd = IPMI_WDOG_RESET_TIMER;
+ 	msg.data = NULL;
+ 	msg.data_len = 0;
+-	atomic_add(1, &panic_done_count);
++	atomic_add(2, &panic_done_count);
+ 	rv = ipmi_request_supply_msgs(watchdog_user,
+ 				      (struct ipmi_addr *) &addr,
+ 				      0,
+@@ -508,7 +508,7 @@ static void panic_halt_ipmi_heartbeat(void)
+ 				      &panic_halt_heartbeat_recv_msg,
+ 				      1);
+ 	if (rv)
+-		atomic_sub(1, &panic_done_count);
++		atomic_sub(2, &panic_done_count);
+ }
+ 
+ static struct ipmi_smi_msg panic_halt_smi_msg = {
+@@ -532,12 +532,12 @@ static void panic_halt_ipmi_set_timeout(void)
+ 	/* Wait for the messages to be free. */
+ 	while (atomic_read(&panic_done_count) != 0)
+ 		ipmi_poll_interface(watchdog_user);
+-	atomic_add(1, &panic_done_count);
++	atomic_add(2, &panic_done_count);
+ 	rv = __ipmi_set_timeout(&panic_halt_smi_msg,
+ 				&panic_halt_recv_msg,
+ 				&send_heartbeat_now);
+ 	if (rv) {
+-		atomic_sub(1, &panic_done_count);
++		atomic_sub(2, &panic_done_count);
+ 		pr_warn("Unable to extend the watchdog timeout\n");
+ 	} else {
+ 		if (send_heartbeat_now)
+diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c
+index 14aeaf7363210..2fc0f221fb4e2 100644
+--- a/drivers/gpu/drm/drm_atomic.c
++++ b/drivers/gpu/drm/drm_atomic.c
+@@ -1006,6 +1006,7 @@ static void drm_atomic_connector_print_state(struct drm_printer *p,
+ 	drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name);
+ 	drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)");
+ 	drm_printf(p, "\tself_refresh_aware=%d\n", state->self_refresh_aware);
++	drm_printf(p, "\tmax_requested_bpc=%d\n", state->max_requested_bpc);
+ 
+ 	if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
+ 		if (state->writeback_job && state->writeback_job->fb)
+diff --git a/drivers/gpu/drm/i915/gt/intel_ringbuffer.c b/drivers/gpu/drm/i915/gt/intel_ringbuffer.c
+index eee9fcbe04344..808269b2108fb 100644
+--- a/drivers/gpu/drm/i915/gt/intel_ringbuffer.c
++++ b/drivers/gpu/drm/i915/gt/intel_ringbuffer.c
+@@ -1208,7 +1208,7 @@ int intel_ring_pin(struct intel_ring *ring)
+ 	if (unlikely(ret))
+ 		goto err_unpin;
+ 
+-	if (i915_vma_is_map_and_fenceable(vma))
++	if (i915_vma_is_map_and_fenceable(vma) && !HAS_LLC(vma->vm->i915))
+ 		addr = (void __force *)i915_vma_pin_iomap(vma);
+ 	else
+ 		addr = i915_gem_object_pin_map(vma->obj,
+@@ -1252,7 +1252,7 @@ void intel_ring_unpin(struct intel_ring *ring)
+ 	intel_ring_reset(ring, ring->emit);
+ 
+ 	i915_vma_unset_ggtt_write(vma);
+-	if (i915_vma_is_map_and_fenceable(vma))
++	if (i915_vma_is_map_and_fenceable(vma) && !HAS_LLC(vma->vm->i915))
+ 		i915_vma_unpin_iomap(vma);
+ 	else
+ 		i915_gem_object_unpin_map(vma->obj);
+diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c
+index e3579e5ffa146..593b8d83179c9 100644
+--- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c
++++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c
+@@ -135,8 +135,8 @@ static void a5xx_submit(struct msm_gpu *gpu, struct msm_gem_submit *submit,
+ 	OUT_RING(ring, 1);
+ 
+ 	/* Enable local preemption for finegrain preemption */
+-	OUT_PKT7(ring, CP_PREEMPT_ENABLE_GLOBAL, 1);
+-	OUT_RING(ring, 0x02);
++	OUT_PKT7(ring, CP_PREEMPT_ENABLE_LOCAL, 1);
++	OUT_RING(ring, 0x1);
+ 
+ 	/* Allow CP_CONTEXT_SWITCH_YIELD packets in the IB2 */
+ 	OUT_PKT7(ring, CP_YIELD_ENABLE, 1);
+diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c
+index 533b920ed7df2..4a9feff340da7 100644
+--- a/drivers/iommu/amd_iommu_init.c
++++ b/drivers/iommu/amd_iommu_init.c
+@@ -84,6 +84,10 @@
+ #define ACPI_DEVFLAG_ATSDIS             0x10000000
+ 
+ #define LOOP_TIMEOUT	2000000
++
++#define IVRS_GET_SBDF_ID(seg, bus, dev, fd)	(((seg & 0xffff) << 16) | ((bus & 0xff) << 8) \
++						 | ((dev & 0x1f) << 3) | (fn & 0x7))
++
+ /*
+  * ACPI table definitions
+  *
+@@ -2971,24 +2975,32 @@ static int __init parse_amd_iommu_options(char *str)
+ 
+ static int __init parse_ivrs_ioapic(char *str)
+ {
+-	unsigned int bus, dev, fn;
+-	int ret, id, i;
+-	u16 devid;
++	u32 seg = 0, bus, dev, fn;
++	int id, i;
++	u32 devid;
+ 
+-	ret = sscanf(str, "[%d]=%x:%x.%x", &id, &bus, &dev, &fn);
++	if (sscanf(str, "=%d@%x:%x.%x", &id, &bus, &dev, &fn) == 4 ||
++	    sscanf(str, "=%d@%x:%x:%x.%x", &id, &seg, &bus, &dev, &fn) == 5)
++		goto found;
+ 
+-	if (ret != 4) {
+-		pr_err("Invalid command line: ivrs_ioapic%s\n", str);
+-		return 1;
++	if (sscanf(str, "[%d]=%x:%x.%x", &id, &bus, &dev, &fn) == 4 ||
++	    sscanf(str, "[%d]=%x:%x:%x.%x", &id, &seg, &bus, &dev, &fn) == 5) {
++		pr_warn("ivrs_ioapic%s option format deprecated; use ivrs_ioapic=%d@%04x:%02x:%02x.%d instead\n",
++			str, id, seg, bus, dev, fn);
++		goto found;
+ 	}
+ 
++	pr_err("Invalid command line: ivrs_ioapic%s\n", str);
++	return 1;
++
++found:
+ 	if (early_ioapic_map_size == EARLY_MAP_SIZE) {
+ 		pr_err("Early IOAPIC map overflow - ignoring ivrs_ioapic%s\n",
+ 			str);
+ 		return 1;
+ 	}
+ 
+-	devid = ((bus & 0xff) << 8) | ((dev & 0x1f) << 3) | (fn & 0x7);
++	devid = IVRS_GET_SBDF_ID(seg, bus, dev, fn);
+ 
+ 	cmdline_maps			= true;
+ 	i				= early_ioapic_map_size++;
+@@ -3001,24 +3013,32 @@ static int __init parse_ivrs_ioapic(char *str)
+ 
+ static int __init parse_ivrs_hpet(char *str)
+ {
+-	unsigned int bus, dev, fn;
+-	int ret, id, i;
+-	u16 devid;
++	u32 seg = 0, bus, dev, fn;
++	int id, i;
++	u32 devid;
+ 
+-	ret = sscanf(str, "[%d]=%x:%x.%x", &id, &bus, &dev, &fn);
++	if (sscanf(str, "=%d@%x:%x.%x", &id, &bus, &dev, &fn) == 4 ||
++	    sscanf(str, "=%d@%x:%x:%x.%x", &id, &seg, &bus, &dev, &fn) == 5)
++		goto found;
+ 
+-	if (ret != 4) {
+-		pr_err("Invalid command line: ivrs_hpet%s\n", str);
+-		return 1;
++	if (sscanf(str, "[%d]=%x:%x.%x", &id, &bus, &dev, &fn) == 4 ||
++	    sscanf(str, "[%d]=%x:%x:%x.%x", &id, &seg, &bus, &dev, &fn) == 5) {
++		pr_warn("ivrs_hpet%s option format deprecated; use ivrs_hpet=%d@%04x:%02x:%02x.%d instead\n",
++			str, id, seg, bus, dev, fn);
++		goto found;
+ 	}
+ 
++	pr_err("Invalid command line: ivrs_hpet%s\n", str);
++	return 1;
++
++found:
+ 	if (early_hpet_map_size == EARLY_MAP_SIZE) {
+ 		pr_err("Early HPET map overflow - ignoring ivrs_hpet%s\n",
+ 			str);
+ 		return 1;
+ 	}
+ 
+-	devid = ((bus & 0xff) << 8) | ((dev & 0x1f) << 3) | (fn & 0x7);
++	devid = IVRS_GET_SBDF_ID(seg, bus, dev, fn);
+ 
+ 	cmdline_maps			= true;
+ 	i				= early_hpet_map_size++;
+@@ -3029,19 +3049,53 @@ static int __init parse_ivrs_hpet(char *str)
+ 	return 1;
+ }
+ 
++#define ACPIID_LEN (ACPIHID_UID_LEN + ACPIHID_HID_LEN)
++
+ static int __init parse_ivrs_acpihid(char *str)
+ {
+-	u32 bus, dev, fn;
+-	char *hid, *uid, *p;
+-	char acpiid[ACPIHID_UID_LEN + ACPIHID_HID_LEN] = {0};
+-	int ret, i;
++	u32 seg = 0, bus, dev, fn;
++	char *hid, *uid, *p, *addr;
++	char acpiid[ACPIID_LEN] = {0};
++	int i;
+ 
+-	ret = sscanf(str, "[%x:%x.%x]=%s", &bus, &dev, &fn, acpiid);
+-	if (ret != 4) {
+-		pr_err("Invalid command line: ivrs_acpihid(%s)\n", str);
+-		return 1;
++	addr = strchr(str, '@');
++	if (!addr) {
++		addr = strchr(str, '=');
++		if (!addr)
++			goto not_found;
++
++		++addr;
++
++		if (strlen(addr) > ACPIID_LEN)
++			goto not_found;
++
++		if (sscanf(str, "[%x:%x.%x]=%s", &bus, &dev, &fn, acpiid) == 4 ||
++		    sscanf(str, "[%x:%x:%x.%x]=%s", &seg, &bus, &dev, &fn, acpiid) == 5) {
++			pr_warn("ivrs_acpihid%s option format deprecated; use ivrs_acpihid=%s@%04x:%02x:%02x.%d instead\n",
++				str, acpiid, seg, bus, dev, fn);
++			goto found;
++		}
++		goto not_found;
+ 	}
+ 
++	/* We have the '@', make it the terminator to get just the acpiid */
++	*addr++ = 0;
++
++	if (strlen(str) > ACPIID_LEN + 1)
++		goto not_found;
++
++	if (sscanf(str, "=%s", acpiid) != 1)
++		goto not_found;
++
++	if (sscanf(addr, "%x:%x.%x", &bus, &dev, &fn) == 3 ||
++	    sscanf(addr, "%x:%x:%x.%x", &seg, &bus, &dev, &fn) == 4)
++		goto found;
++
++not_found:
++	pr_err("Invalid command line: ivrs_acpihid%s\n", str);
++	return 1;
++
++found:
+ 	p = acpiid;
+ 	hid = strsep(&p, ":");
+ 	uid = p;
+@@ -3061,8 +3115,7 @@ static int __init parse_ivrs_acpihid(char *str)
+ 	i = early_acpihid_map_size++;
+ 	memcpy(early_acpihid_map[i].hid, hid, strlen(hid));
+ 	memcpy(early_acpihid_map[i].uid, uid, strlen(uid));
+-	early_acpihid_map[i].devid =
+-		((bus & 0xff) << 8) | ((dev & 0x1f) << 3) | (fn & 0x7);
++	early_acpihid_map[i].devid = IVRS_GET_SBDF_ID(seg, bus, dev, fn);
+ 	early_acpihid_map[i].cmd_line	= true;
+ 
+ 	return 1;
+diff --git a/drivers/iommu/intel-pasid.c b/drivers/iommu/intel-pasid.c
+index e7cb0b8a73327..58f060006ba31 100644
+--- a/drivers/iommu/intel-pasid.c
++++ b/drivers/iommu/intel-pasid.c
+@@ -166,6 +166,9 @@ int intel_pasid_alloc_table(struct device *dev)
+ attach_out:
+ 	device_attach_pasid_table(info, pasid_table);
+ 
++	if (!ecap_coherent(info->iommu->ecap))
++		clflush_cache_range(pasid_table->table, size);
++
+ 	return 0;
+ }
+ 
+@@ -250,6 +253,10 @@ struct pasid_entry *intel_pasid_get_entry(struct device *dev, int pasid)
+ 
+ 		WRITE_ONCE(dir[dir_index].val,
+ 			   (u64)virt_to_phys(entries) | PASID_PTE_PRESENT);
++		if (!ecap_coherent(info->iommu->ecap)) {
++			clflush_cache_range(entries, VTD_PAGE_SIZE);
++			clflush_cache_range(&dir[dir_index].val, sizeof(*dir));
++		}
+ 	}
+ 	spin_unlock(&pasid_lock);
+ 
+diff --git a/drivers/macintosh/windfarm_lm75_sensor.c b/drivers/macintosh/windfarm_lm75_sensor.c
+index 1e5fa09845e77..8713e80201c07 100644
+--- a/drivers/macintosh/windfarm_lm75_sensor.c
++++ b/drivers/macintosh/windfarm_lm75_sensor.c
+@@ -34,8 +34,8 @@
+ #endif
+ 
+ struct wf_lm75_sensor {
+-	int			ds1775 : 1;
+-	int			inited : 1;
++	unsigned int		ds1775 : 1;
++	unsigned int		inited : 1;
+ 	struct i2c_client	*i2c;
+ 	struct wf_sensor	sens;
+ };
+diff --git a/drivers/macintosh/windfarm_smu_sensors.c b/drivers/macintosh/windfarm_smu_sensors.c
+index 3e6059eaa1380..90823b4280259 100644
+--- a/drivers/macintosh/windfarm_smu_sensors.c
++++ b/drivers/macintosh/windfarm_smu_sensors.c
+@@ -273,8 +273,8 @@ struct smu_cpu_power_sensor {
+ 	struct list_head	link;
+ 	struct wf_sensor	*volts;
+ 	struct wf_sensor	*amps;
+-	int			fake_volts : 1;
+-	int			quadratic : 1;
++	unsigned int		fake_volts : 1;
++	unsigned int		quadratic : 1;
+ 	struct wf_sensor	sens;
+ };
+ #define to_smu_cpu_power(c) container_of(c, struct smu_cpu_power_sensor, sens)
+diff --git a/drivers/media/i2c/ov5640.c b/drivers/media/i2c/ov5640.c
+index be6c882dd1d54..087fb464ffc12 100644
+--- a/drivers/media/i2c/ov5640.c
++++ b/drivers/media/i2c/ov5640.c
+@@ -2704,7 +2704,7 @@ static int ov5640_init_controls(struct ov5640_dev *sensor)
+ 	/* Auto/manual gain */
+ 	ctrls->auto_gain = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_AUTOGAIN,
+ 					     0, 1, 1, 1);
+-	ctrls->gain = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_GAIN,
++	ctrls->gain = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_ANALOGUE_GAIN,
+ 					0, 1023, 1, 0);
+ 
+ 	ctrls->saturation = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_SATURATION,
+diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+index ef8225b7445d3..9fb1da36e9eb8 100644
+--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
++++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+@@ -2747,7 +2747,7 @@ static int bnxt_alloc_ring(struct bnxt *bp, struct bnxt_ring_mem_info *rmem)
+ 
+ static void bnxt_free_tpa_info(struct bnxt *bp)
+ {
+-	int i;
++	int i, j;
+ 
+ 	for (i = 0; i < bp->rx_nr_rings; i++) {
+ 		struct bnxt_rx_ring_info *rxr = &bp->rx_ring[i];
+@@ -2755,8 +2755,10 @@ static void bnxt_free_tpa_info(struct bnxt *bp)
+ 		kfree(rxr->rx_tpa_idx_map);
+ 		rxr->rx_tpa_idx_map = NULL;
+ 		if (rxr->rx_tpa) {
+-			kfree(rxr->rx_tpa[0].agg_arr);
+-			rxr->rx_tpa[0].agg_arr = NULL;
++			for (j = 0; j < bp->max_tpa; j++) {
++				kfree(rxr->rx_tpa[j].agg_arr);
++				rxr->rx_tpa[j].agg_arr = NULL;
++			}
+ 		}
+ 		kfree(rxr->rx_tpa);
+ 		rxr->rx_tpa = NULL;
+@@ -2765,14 +2767,13 @@ static void bnxt_free_tpa_info(struct bnxt *bp)
+ 
+ static int bnxt_alloc_tpa_info(struct bnxt *bp)
+ {
+-	int i, j, total_aggs = 0;
++	int i, j;
+ 
+ 	bp->max_tpa = MAX_TPA;
+ 	if (bp->flags & BNXT_FLAG_CHIP_P5) {
+ 		if (!bp->max_tpa_v2)
+ 			return 0;
+ 		bp->max_tpa = max_t(u16, bp->max_tpa_v2, MAX_TPA_P5);
+-		total_aggs = bp->max_tpa * MAX_SKB_FRAGS;
+ 	}
+ 
+ 	for (i = 0; i < bp->rx_nr_rings; i++) {
+@@ -2786,12 +2787,12 @@ static int bnxt_alloc_tpa_info(struct bnxt *bp)
+ 
+ 		if (!(bp->flags & BNXT_FLAG_CHIP_P5))
+ 			continue;
+-		agg = kcalloc(total_aggs, sizeof(*agg), GFP_KERNEL);
+-		rxr->rx_tpa[0].agg_arr = agg;
+-		if (!agg)
+-			return -ENOMEM;
+-		for (j = 1; j < bp->max_tpa; j++)
+-			rxr->rx_tpa[j].agg_arr = agg + j * MAX_SKB_FRAGS;
++		for (j = 0; j < bp->max_tpa; j++) {
++			agg = kcalloc(MAX_SKB_FRAGS, sizeof(*agg), GFP_KERNEL);
++			if (!agg)
++				return -ENOMEM;
++			rxr->rx_tpa[j].agg_arr = agg;
++		}
+ 		rxr->rx_tpa_idx_map = kzalloc(sizeof(*rxr->rx_tpa_idx_map),
+ 					      GFP_KERNEL);
+ 		if (!rxr->rx_tpa_idx_map)
+diff --git a/drivers/net/phy/microchip.c b/drivers/net/phy/microchip.c
+index a644e8e5071c3..375bbd60b38af 100644
+--- a/drivers/net/phy/microchip.c
++++ b/drivers/net/phy/microchip.c
+@@ -326,6 +326,37 @@ static int lan88xx_config_aneg(struct phy_device *phydev)
+ 	return genphy_config_aneg(phydev);
+ }
+ 
++static void lan88xx_link_change_notify(struct phy_device *phydev)
++{
++	int temp;
++
++	/* At forced 100 F/H mode, chip may fail to set mode correctly
++	 * when cable is switched between long(~50+m) and short one.
++	 * As workaround, set to 10 before setting to 100
++	 * at forced 100 F/H mode.
++	 */
++	if (!phydev->autoneg && phydev->speed == 100) {
++		/* disable phy interrupt */
++		temp = phy_read(phydev, LAN88XX_INT_MASK);
++		temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
++		phy_write(phydev, LAN88XX_INT_MASK, temp);
++
++		temp = phy_read(phydev, MII_BMCR);
++		temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
++		phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
++		temp |= BMCR_SPEED100;
++		phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
++
++		/* clear pending interrupt generated while workaround */
++		temp = phy_read(phydev, LAN88XX_INT_STS);
++
++		/* enable phy interrupt back */
++		temp = phy_read(phydev, LAN88XX_INT_MASK);
++		temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
++		phy_write(phydev, LAN88XX_INT_MASK, temp);
++	}
++}
++
+ static struct phy_driver microchip_phy_driver[] = {
+ {
+ 	.phy_id		= 0x0007c130,
+@@ -339,6 +370,7 @@ static struct phy_driver microchip_phy_driver[] = {
+ 
+ 	.config_init	= lan88xx_config_init,
+ 	.config_aneg	= lan88xx_config_aneg,
++	.link_change_notify = lan88xx_link_change_notify,
+ 
+ 	.ack_interrupt	= lan88xx_phy_ack_interrupt,
+ 	.config_intr	= lan88xx_phy_config_intr,
+diff --git a/drivers/net/usb/lan78xx.c b/drivers/net/usb/lan78xx.c
+index ce3c8f476d75c..b51017966bb37 100644
+--- a/drivers/net/usb/lan78xx.c
++++ b/drivers/net/usb/lan78xx.c
+@@ -824,20 +824,19 @@ static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
+ 				u32 length, u8 *data)
+ {
+ 	int i;
+-	int ret;
+ 	u32 buf;
+ 	unsigned long timeout;
+ 
+-	ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
++	lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
+ 
+ 	if (buf & OTP_PWR_DN_PWRDN_N_) {
+ 		/* clear it and wait to be cleared */
+-		ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
++		lan78xx_write_reg(dev, OTP_PWR_DN, 0);
+ 
+ 		timeout = jiffies + HZ;
+ 		do {
+ 			usleep_range(1, 10);
+-			ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
++			lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
+ 			if (time_after(jiffies, timeout)) {
+ 				netdev_warn(dev->net,
+ 					    "timeout on OTP_PWR_DN");
+@@ -847,18 +846,18 @@ static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
+ 	}
+ 
+ 	for (i = 0; i < length; i++) {
+-		ret = lan78xx_write_reg(dev, OTP_ADDR1,
++		lan78xx_write_reg(dev, OTP_ADDR1,
+ 					((offset + i) >> 8) & OTP_ADDR1_15_11);
+-		ret = lan78xx_write_reg(dev, OTP_ADDR2,
++		lan78xx_write_reg(dev, OTP_ADDR2,
+ 					((offset + i) & OTP_ADDR2_10_3));
+ 
+-		ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
+-		ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
++		lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
++		lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
+ 
+ 		timeout = jiffies + HZ;
+ 		do {
+ 			udelay(1);
+-			ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
++			lan78xx_read_reg(dev, OTP_STATUS, &buf);
+ 			if (time_after(jiffies, timeout)) {
+ 				netdev_warn(dev->net,
+ 					    "timeout on OTP_STATUS");
+@@ -866,7 +865,7 @@ static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
+ 			}
+ 		} while (buf & OTP_STATUS_BUSY_);
+ 
+-		ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
++		lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
+ 
+ 		data[i] = (u8)(buf & 0xFF);
+ 	}
+@@ -878,20 +877,19 @@ static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
+ 				 u32 length, u8 *data)
+ {
+ 	int i;
+-	int ret;
+ 	u32 buf;
+ 	unsigned long timeout;
+ 
+-	ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
++	lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
+ 
+ 	if (buf & OTP_PWR_DN_PWRDN_N_) {
+ 		/* clear it and wait to be cleared */
+-		ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
++		lan78xx_write_reg(dev, OTP_PWR_DN, 0);
+ 
+ 		timeout = jiffies + HZ;
+ 		do {
+ 			udelay(1);
+-			ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
++			lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
+ 			if (time_after(jiffies, timeout)) {
+ 				netdev_warn(dev->net,
+ 					    "timeout on OTP_PWR_DN completion");
+@@ -901,21 +899,21 @@ static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
+ 	}
+ 
+ 	/* set to BYTE program mode */
+-	ret = lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
++	lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
+ 
+ 	for (i = 0; i < length; i++) {
+-		ret = lan78xx_write_reg(dev, OTP_ADDR1,
++		lan78xx_write_reg(dev, OTP_ADDR1,
+ 					((offset + i) >> 8) & OTP_ADDR1_15_11);
+-		ret = lan78xx_write_reg(dev, OTP_ADDR2,
++		lan78xx_write_reg(dev, OTP_ADDR2,
+ 					((offset + i) & OTP_ADDR2_10_3));
+-		ret = lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
+-		ret = lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
+-		ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
++		lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
++		lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
++		lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
+ 
+ 		timeout = jiffies + HZ;
+ 		do {
+ 			udelay(1);
+-			ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
++			lan78xx_read_reg(dev, OTP_STATUS, &buf);
+ 			if (time_after(jiffies, timeout)) {
+ 				netdev_warn(dev->net,
+ 					    "Timeout on OTP_STATUS completion");
+@@ -1040,7 +1038,6 @@ static void lan78xx_deferred_multicast_write(struct work_struct *param)
+ 			container_of(param, struct lan78xx_priv, set_multicast);
+ 	struct lan78xx_net *dev = pdata->dev;
+ 	int i;
+-	int ret;
+ 
+ 	netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
+ 		  pdata->rfe_ctl);
+@@ -1049,14 +1046,14 @@ static void lan78xx_deferred_multicast_write(struct work_struct *param)
+ 			       DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
+ 
+ 	for (i = 1; i < NUM_OF_MAF; i++) {
+-		ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
+-		ret = lan78xx_write_reg(dev, MAF_LO(i),
++		lan78xx_write_reg(dev, MAF_HI(i), 0);
++		lan78xx_write_reg(dev, MAF_LO(i),
+ 					pdata->pfilter_table[i][1]);
+-		ret = lan78xx_write_reg(dev, MAF_HI(i),
++		lan78xx_write_reg(dev, MAF_HI(i),
+ 					pdata->pfilter_table[i][0]);
+ 	}
+ 
+-	ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
++	lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
+ }
+ 
+ static void lan78xx_set_multicast(struct net_device *netdev)
+@@ -1126,7 +1123,6 @@ static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
+ 				      u16 lcladv, u16 rmtadv)
+ {
+ 	u32 flow = 0, fct_flow = 0;
+-	int ret;
+ 	u8 cap;
+ 
+ 	if (dev->fc_autoneg)
+@@ -1149,10 +1145,10 @@ static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
+ 		  (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
+ 		  (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
+ 
+-	ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
++	lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
+ 
+ 	/* threshold value should be set before enabling flow */
+-	ret = lan78xx_write_reg(dev, FLOW, flow);
++	lan78xx_write_reg(dev, FLOW, flow);
+ 
+ 	return 0;
+ }
+@@ -1681,11 +1677,10 @@ static int lan78xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
+ static void lan78xx_init_mac_address(struct lan78xx_net *dev)
+ {
+ 	u32 addr_lo, addr_hi;
+-	int ret;
+ 	u8 addr[6];
+ 
+-	ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
+-	ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
++	lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
++	lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
+ 
+ 	addr[0] = addr_lo & 0xFF;
+ 	addr[1] = (addr_lo >> 8) & 0xFF;
+@@ -1718,12 +1713,12 @@ static void lan78xx_init_mac_address(struct lan78xx_net *dev)
+ 			  (addr[2] << 16) | (addr[3] << 24);
+ 		addr_hi = addr[4] | (addr[5] << 8);
+ 
+-		ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
+-		ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
++		lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
++		lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
+ 	}
+ 
+-	ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
+-	ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
++	lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
++	lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
+ 
+ 	ether_addr_copy(dev->net->dev_addr, addr);
+ }
+@@ -1856,33 +1851,8 @@ static void lan78xx_remove_mdio(struct lan78xx_net *dev)
+ static void lan78xx_link_status_change(struct net_device *net)
+ {
+ 	struct phy_device *phydev = net->phydev;
+-	int ret, temp;
+-
+-	/* At forced 100 F/H mode, chip may fail to set mode correctly
+-	 * when cable is switched between long(~50+m) and short one.
+-	 * As workaround, set to 10 before setting to 100
+-	 * at forced 100 F/H mode.
+-	 */
+-	if (!phydev->autoneg && (phydev->speed == 100)) {
+-		/* disable phy interrupt */
+-		temp = phy_read(phydev, LAN88XX_INT_MASK);
+-		temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
+-		ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
+ 
+-		temp = phy_read(phydev, MII_BMCR);
+-		temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
+-		phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
+-		temp |= BMCR_SPEED100;
+-		phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
+-
+-		/* clear pending interrupt generated while workaround */
+-		temp = phy_read(phydev, LAN88XX_INT_STS);
+-
+-		/* enable phy interrupt back */
+-		temp = phy_read(phydev, LAN88XX_INT_MASK);
+-		temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
+-		ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
+-	}
++	phy_print_status(phydev);
+ }
+ 
+ static int irq_map(struct irq_domain *d, unsigned int irq,
+@@ -1935,14 +1905,13 @@ static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
+ 	struct lan78xx_net *dev =
+ 			container_of(data, struct lan78xx_net, domain_data);
+ 	u32 buf;
+-	int ret;
+ 
+ 	/* call register access here because irq_bus_lock & irq_bus_sync_unlock
+ 	 * are only two callbacks executed in non-atomic contex.
+ 	 */
+-	ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
++	lan78xx_read_reg(dev, INT_EP_CTL, &buf);
+ 	if (buf != data->irqenable)
+-		ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
++		lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
+ 
+ 	mutex_unlock(&data->irq_lock);
+ }
+@@ -2009,7 +1978,6 @@ static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
+ static int lan8835_fixup(struct phy_device *phydev)
+ {
+ 	int buf;
+-	int ret;
+ 	struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
+ 
+ 	/* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
+@@ -2019,11 +1987,11 @@ static int lan8835_fixup(struct phy_device *phydev)
+ 	phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
+ 
+ 	/* RGMII MAC TXC Delay Enable */
+-	ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
++	lan78xx_write_reg(dev, MAC_RGMII_ID,
+ 				MAC_RGMII_ID_TXC_DELAY_EN_);
+ 
+ 	/* RGMII TX DLL Tune Adjust */
+-	ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
++	lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
+ 
+ 	dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
+ 
+@@ -2207,28 +2175,27 @@ static int lan78xx_phy_init(struct lan78xx_net *dev)
+ 
+ static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
+ {
+-	int ret = 0;
+ 	u32 buf;
+ 	bool rxenabled;
+ 
+-	ret = lan78xx_read_reg(dev, MAC_RX, &buf);
++	lan78xx_read_reg(dev, MAC_RX, &buf);
+ 
+ 	rxenabled = ((buf & MAC_RX_RXEN_) != 0);
+ 
+ 	if (rxenabled) {
+ 		buf &= ~MAC_RX_RXEN_;
+-		ret = lan78xx_write_reg(dev, MAC_RX, buf);
++		lan78xx_write_reg(dev, MAC_RX, buf);
+ 	}
+ 
+ 	/* add 4 to size for FCS */
+ 	buf &= ~MAC_RX_MAX_SIZE_MASK_;
+ 	buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
+ 
+-	ret = lan78xx_write_reg(dev, MAC_RX, buf);
++	lan78xx_write_reg(dev, MAC_RX, buf);
+ 
+ 	if (rxenabled) {
+ 		buf |= MAC_RX_RXEN_;
+-		ret = lan78xx_write_reg(dev, MAC_RX, buf);
++		lan78xx_write_reg(dev, MAC_RX, buf);
+ 	}
+ 
+ 	return 0;
+@@ -2285,13 +2252,12 @@ static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
+ 	int ll_mtu = new_mtu + netdev->hard_header_len;
+ 	int old_hard_mtu = dev->hard_mtu;
+ 	int old_rx_urb_size = dev->rx_urb_size;
+-	int ret;
+ 
+ 	/* no second zero-length packet read wanted after mtu-sized packets */
+ 	if ((ll_mtu % dev->maxpacket) == 0)
+ 		return -EDOM;
+ 
+-	ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN);
++	lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN);
+ 
+ 	netdev->mtu = new_mtu;
+ 
+@@ -2314,7 +2280,6 @@ static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
+ 	struct lan78xx_net *dev = netdev_priv(netdev);
+ 	struct sockaddr *addr = p;
+ 	u32 addr_lo, addr_hi;
+-	int ret;
+ 
+ 	if (netif_running(netdev))
+ 		return -EBUSY;
+@@ -2331,12 +2296,12 @@ static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
+ 	addr_hi = netdev->dev_addr[4] |
+ 		  netdev->dev_addr[5] << 8;
+ 
+-	ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
+-	ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
++	lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
++	lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
+ 
+ 	/* Added to support MAC address changes */
+-	ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
+-	ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
++	lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
++	lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
+ 
+ 	return 0;
+ }
+@@ -2348,7 +2313,6 @@ static int lan78xx_set_features(struct net_device *netdev,
+ 	struct lan78xx_net *dev = netdev_priv(netdev);
+ 	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
+ 	unsigned long flags;
+-	int ret;
+ 
+ 	spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
+ 
+@@ -2372,7 +2336,7 @@ static int lan78xx_set_features(struct net_device *netdev,
+ 
+ 	spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
+ 
+-	ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
++	lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
+ 
+ 	return 0;
+ }
+@@ -3828,7 +3792,6 @@ static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
+ static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
+ {
+ 	u32 buf;
+-	int ret;
+ 	int mask_index;
+ 	u16 crc;
+ 	u32 temp_wucsr;
+@@ -3837,26 +3800,26 @@ static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
+ 	const u8 ipv6_multicast[3] = { 0x33, 0x33 };
+ 	const u8 arp_type[2] = { 0x08, 0x06 };
+ 
+-	ret = lan78xx_read_reg(dev, MAC_TX, &buf);
++	lan78xx_read_reg(dev, MAC_TX, &buf);
+ 	buf &= ~MAC_TX_TXEN_;
+-	ret = lan78xx_write_reg(dev, MAC_TX, buf);
+-	ret = lan78xx_read_reg(dev, MAC_RX, &buf);
++	lan78xx_write_reg(dev, MAC_TX, buf);
++	lan78xx_read_reg(dev, MAC_RX, &buf);
+ 	buf &= ~MAC_RX_RXEN_;
+-	ret = lan78xx_write_reg(dev, MAC_RX, buf);
++	lan78xx_write_reg(dev, MAC_RX, buf);
+ 
+-	ret = lan78xx_write_reg(dev, WUCSR, 0);
+-	ret = lan78xx_write_reg(dev, WUCSR2, 0);
+-	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
++	lan78xx_write_reg(dev, WUCSR, 0);
++	lan78xx_write_reg(dev, WUCSR2, 0);
++	lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
+ 
+ 	temp_wucsr = 0;
+ 
+ 	temp_pmt_ctl = 0;
+-	ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
++	lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
+ 	temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
+ 	temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
+ 
+ 	for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
+-		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
+ 
+ 	mask_index = 0;
+ 	if (wol & WAKE_PHY) {
+@@ -3885,30 +3848,30 @@ static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
+ 
+ 		/* set WUF_CFG & WUF_MASK for IPv4 Multicast */
+ 		crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
+-		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
++		lan78xx_write_reg(dev, WUF_CFG(mask_index),
+ 					WUF_CFGX_EN_ |
+ 					WUF_CFGX_TYPE_MCAST_ |
+ 					(0 << WUF_CFGX_OFFSET_SHIFT_) |
+ 					(crc & WUF_CFGX_CRC16_MASK_));
+ 
+-		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
+-		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
+-		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
+-		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
++		lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
+ 		mask_index++;
+ 
+ 		/* for IPv6 Multicast */
+ 		crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
+-		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
++		lan78xx_write_reg(dev, WUF_CFG(mask_index),
+ 					WUF_CFGX_EN_ |
+ 					WUF_CFGX_TYPE_MCAST_ |
+ 					(0 << WUF_CFGX_OFFSET_SHIFT_) |
+ 					(crc & WUF_CFGX_CRC16_MASK_));
+ 
+-		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
+-		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
+-		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
+-		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
++		lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
+ 		mask_index++;
+ 
+ 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
+@@ -3929,16 +3892,16 @@ static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
+ 		 * for packettype (offset 12,13) = ARP (0x0806)
+ 		 */
+ 		crc = lan78xx_wakeframe_crc16(arp_type, 2);
+-		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
++		lan78xx_write_reg(dev, WUF_CFG(mask_index),
+ 					WUF_CFGX_EN_ |
+ 					WUF_CFGX_TYPE_ALL_ |
+ 					(0 << WUF_CFGX_OFFSET_SHIFT_) |
+ 					(crc & WUF_CFGX_CRC16_MASK_));
+ 
+-		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
+-		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
+-		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
+-		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
++		lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
++		lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
+ 		mask_index++;
+ 
+ 		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
+@@ -3946,7 +3909,7 @@ static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
+ 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
+ 	}
+ 
+-	ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
++	lan78xx_write_reg(dev, WUCSR, temp_wucsr);
+ 
+ 	/* when multiple WOL bits are set */
+ 	if (hweight_long((unsigned long)wol) > 1) {
+@@ -3954,16 +3917,16 @@ static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
+ 		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
+ 		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
+ 	}
+-	ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
++	lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
+ 
+ 	/* clear WUPS */
+-	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
++	lan78xx_read_reg(dev, PMT_CTL, &buf);
+ 	buf |= PMT_CTL_WUPS_MASK_;
+-	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
++	lan78xx_write_reg(dev, PMT_CTL, buf);
+ 
+-	ret = lan78xx_read_reg(dev, MAC_RX, &buf);
++	lan78xx_read_reg(dev, MAC_RX, &buf);
+ 	buf |= MAC_RX_RXEN_;
+-	ret = lan78xx_write_reg(dev, MAC_RX, buf);
++	lan78xx_write_reg(dev, MAC_RX, buf);
+ 
+ 	return 0;
+ }
+diff --git a/drivers/nfc/fdp/i2c.c b/drivers/nfc/fdp/i2c.c
+index ad0abb1f0bae9..7305f1a06e97c 100644
+--- a/drivers/nfc/fdp/i2c.c
++++ b/drivers/nfc/fdp/i2c.c
+@@ -255,6 +255,9 @@ static void fdp_nci_i2c_read_device_properties(struct device *dev,
+ 					   len, sizeof(**fw_vsc_cfg),
+ 					   GFP_KERNEL);
+ 
++		if (!*fw_vsc_cfg)
++			goto alloc_err;
++
+ 		r = device_property_read_u8_array(dev, FDP_DP_FW_VSC_CFG_NAME,
+ 						  *fw_vsc_cfg, len);
+ 
+@@ -268,6 +271,7 @@ vsc_read_err:
+ 		*fw_vsc_cfg = NULL;
+ 	}
+ 
++alloc_err:
+ 	dev_dbg(dev, "Clock type: %d, clock frequency: %d, VSC: %s",
+ 		*clock_type, *clock_freq, *fw_vsc_cfg != NULL ? "yes" : "no");
+ }
+diff --git a/drivers/s390/block/dasd_diag.c b/drivers/s390/block/dasd_diag.c
+index f7ae03fd36cb5..f029884eabd19 100644
+--- a/drivers/s390/block/dasd_diag.c
++++ b/drivers/s390/block/dasd_diag.c
+@@ -644,12 +644,17 @@ static void dasd_diag_setup_blk_queue(struct dasd_block *block)
+ 	blk_queue_segment_boundary(q, PAGE_SIZE - 1);
+ }
+ 
++static int dasd_diag_pe_handler(struct dasd_device *device, __u8 tbvpm)
++{
++	return dasd_generic_verify_path(device, tbvpm);
++}
++
+ static struct dasd_discipline dasd_diag_discipline = {
+ 	.owner = THIS_MODULE,
+ 	.name = "DIAG",
+ 	.ebcname = "DIAG",
+ 	.check_device = dasd_diag_check_device,
+-	.verify_path = dasd_generic_verify_path,
++	.pe_handler = dasd_diag_pe_handler,
+ 	.fill_geometry = dasd_diag_fill_geometry,
+ 	.setup_blk_queue = dasd_diag_setup_blk_queue,
+ 	.start_IO = dasd_start_diag,
+diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
+index 1a44e321b54e1..b159575a27608 100644
+--- a/drivers/s390/block/dasd_fba.c
++++ b/drivers/s390/block/dasd_fba.c
+@@ -803,13 +803,18 @@ static void dasd_fba_setup_blk_queue(struct dasd_block *block)
+ 	blk_queue_flag_set(QUEUE_FLAG_DISCARD, q);
+ }
+ 
++static int dasd_fba_pe_handler(struct dasd_device *device, __u8 tbvpm)
++{
++	return dasd_generic_verify_path(device, tbvpm);
++}
++
+ static struct dasd_discipline dasd_fba_discipline = {
+ 	.owner = THIS_MODULE,
+ 	.name = "FBA ",
+ 	.ebcname = "FBA ",
+ 	.check_device = dasd_fba_check_characteristics,
+ 	.do_analysis = dasd_fba_do_analysis,
+-	.verify_path = dasd_generic_verify_path,
++	.pe_handler = dasd_fba_pe_handler,
+ 	.setup_blk_queue = dasd_fba_setup_blk_queue,
+ 	.fill_geometry = dasd_fba_fill_geometry,
+ 	.start_IO = dasd_start_IO,
+diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
+index e8a06d85d6f72..5d7d35ca5eb48 100644
+--- a/drivers/s390/block/dasd_int.h
++++ b/drivers/s390/block/dasd_int.h
+@@ -298,7 +298,6 @@ struct dasd_discipline {
+ 	 * e.g. verify that new path is compatible with the current
+ 	 * configuration.
+ 	 */
+-	int (*verify_path)(struct dasd_device *, __u8);
+ 	int (*pe_handler)(struct dasd_device *, __u8);
+ 
+ 	/*
+diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
+index 45885e80992fb..b08d963013db6 100644
+--- a/drivers/scsi/hosts.c
++++ b/drivers/scsi/hosts.c
+@@ -179,6 +179,7 @@ void scsi_remove_host(struct Scsi_Host *shost)
+ 	scsi_forget_host(shost);
+ 	mutex_unlock(&shost->scan_mutex);
+ 	scsi_proc_host_rm(shost);
++	scsi_proc_hostdir_rm(shost->hostt);
+ 
+ 	spin_lock_irqsave(shost->host_lock, flags);
+ 	if (scsi_host_set_state(shost, SHOST_DEL))
+@@ -318,6 +319,7 @@ static void scsi_host_dev_release(struct device *dev)
+ 	struct Scsi_Host *shost = dev_to_shost(dev);
+ 	struct device *parent = dev->parent;
+ 
++	/* In case scsi_remove_host() has not been called. */
+ 	scsi_proc_hostdir_rm(shost->hostt);
+ 
+ 	/* Wait for functions invoked through call_rcu(&shost->rcu, ...) */
+diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
+index aa62cc8ffd0af..ce0c36fa26bf7 100644
+--- a/drivers/scsi/megaraid/megaraid_sas.h
++++ b/drivers/scsi/megaraid/megaraid_sas.h
+@@ -1515,6 +1515,8 @@ struct megasas_ctrl_info {
+ #define MEGASAS_MAX_LD_IDS			(MEGASAS_MAX_LD_CHANNELS * \
+ 						MEGASAS_MAX_DEV_PER_CHANNEL)
+ 
++#define MEGASAS_MAX_SUPPORTED_LD_IDS		240
++
+ #define MEGASAS_MAX_SECTORS                    (2*1024)
+ #define MEGASAS_MAX_SECTORS_IEEE		(2*128)
+ #define MEGASAS_DBG_LVL				1
+diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c
+index 8bfb46dbbed3a..ff20f47090810 100644
+--- a/drivers/scsi/megaraid/megaraid_sas_fp.c
++++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
+@@ -359,7 +359,7 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance, u64 map_id)
+ 		ld = MR_TargetIdToLdGet(i, drv_map);
+ 
+ 		/* For non existing VDs, iterate to next VD*/
+-		if (ld >= (MAX_LOGICAL_DRIVES_EXT - 1))
++		if (ld >= MEGASAS_MAX_SUPPORTED_LD_IDS)
+ 			continue;
+ 
+ 		raid = MR_LdRaidGet(ld, drv_map);
+diff --git a/fs/cifs/cifsacl.c b/fs/cifs/cifsacl.c
+index 1f55072aa3023..1766d6d077f26 100644
+--- a/fs/cifs/cifsacl.c
++++ b/fs/cifs/cifsacl.c
+@@ -1056,7 +1056,7 @@ static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb,
+ 	struct cifs_ntsd *pntsd = NULL;
+ 	int oplock = 0;
+ 	unsigned int xid;
+-	int rc, create_options = 0;
++	int rc;
+ 	struct cifs_tcon *tcon;
+ 	struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
+ 	struct cifs_fid fid;
+@@ -1068,13 +1068,10 @@ static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb,
+ 	tcon = tlink_tcon(tlink);
+ 	xid = get_xid();
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = READ_CONTROL;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = path;
+ 	oparms.fid = &fid;
+@@ -1119,7 +1116,7 @@ int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
+ {
+ 	int oplock = 0;
+ 	unsigned int xid;
+-	int rc, access_flags, create_options = 0;
++	int rc, access_flags;
+ 	struct cifs_tcon *tcon;
+ 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+ 	struct tcon_link *tlink = cifs_sb_tlink(cifs_sb);
+@@ -1132,9 +1129,6 @@ int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
+ 	tcon = tlink_tcon(tlink);
+ 	xid = get_xid();
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	if (aclflag == CIFS_ACL_OWNER || aclflag == CIFS_ACL_GROUP)
+ 		access_flags = WRITE_OWNER;
+ 	else
+@@ -1143,7 +1137,7 @@ int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = access_flags;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = path;
+ 	oparms.fid = &fid;
+diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
+index aa7827da7b178..871a7b044c1b8 100644
+--- a/fs/cifs/cifsfs.c
++++ b/fs/cifs/cifsfs.c
+@@ -275,7 +275,7 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
+ 	buf->f_ffree = 0;	/* unlimited */
+ 
+ 	if (server->ops->queryfs)
+-		rc = server->ops->queryfs(xid, tcon, buf);
++		rc = server->ops->queryfs(xid, tcon, cifs_sb, buf);
+ 
+ 	free_xid(xid);
+ 	return rc;
+diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
+index 7c0eb110e2630..253321adc2664 100644
+--- a/fs/cifs/cifsglob.h
++++ b/fs/cifs/cifsglob.h
+@@ -300,7 +300,8 @@ struct smb_version_operations {
+ 			     const char *, struct dfs_info3_param **,
+ 			     unsigned int *, const struct nls_table *, int);
+ 	/* informational QFS call */
+-	void (*qfs_tcon)(const unsigned int, struct cifs_tcon *);
++	void (*qfs_tcon)(const unsigned int, struct cifs_tcon *,
++			 struct cifs_sb_info *);
+ 	/* check if a path is accessible or not */
+ 	int (*is_path_accessible)(const unsigned int, struct cifs_tcon *,
+ 				  struct cifs_sb_info *, const char *);
+@@ -408,7 +409,7 @@ struct smb_version_operations {
+ 			       struct cifsInodeInfo *);
+ 	/* query remote filesystem */
+ 	int (*queryfs)(const unsigned int, struct cifs_tcon *,
+-		       struct kstatfs *);
++		       struct cifs_sb_info *, struct kstatfs *);
+ 	/* send mandatory brlock to the server */
+ 	int (*mand_lock)(const unsigned int, struct cifsFileInfo *, __u64,
+ 			 __u64, __u32, int, int, bool);
+@@ -489,6 +490,7 @@ struct smb_version_operations {
+ 	/* ioctl passthrough for query_info */
+ 	int (*ioctl_query_info)(const unsigned int xid,
+ 				struct cifs_tcon *tcon,
++				struct cifs_sb_info *cifs_sb,
+ 				__le16 *path, int is_dir,
+ 				unsigned long p);
+ 	/* make unix special files (block, char, fifo, socket) */
+diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
+index 56a4740ae93ab..a5fab9afd699f 100644
+--- a/fs/cifs/cifsproto.h
++++ b/fs/cifs/cifsproto.h
+@@ -600,4 +600,12 @@ static inline int get_dfs_path(const unsigned int xid, struct cifs_ses *ses,
+ }
+ #endif
+ 
++static inline int cifs_create_options(struct cifs_sb_info *cifs_sb, int options)
++{
++	if (backup_cred(cifs_sb))
++		return options | CREATE_OPEN_BACKUP_INTENT;
++	else
++		return options;
++}
++
+ #endif			/* _CIFSPROTO_H */
+diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
+index 25a2a98ebda8d..6c8dd7c0b83a2 100644
+--- a/fs/cifs/connect.c
++++ b/fs/cifs/connect.c
+@@ -4319,7 +4319,7 @@ static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
+ 
+ 	/* do not care if a following call succeed - informational */
+ 	if (!tcon->pipe && server->ops->qfs_tcon) {
+-		server->ops->qfs_tcon(*xid, tcon);
++		server->ops->qfs_tcon(*xid, tcon, cifs_sb);
+ 		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
+ 			if (tcon->fsDevInfo.DeviceCharacteristics &
+ 			    cpu_to_le32(FILE_READ_ONLY_DEVICE))
+diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
+index 9ae9a514676c3..548047a709bfc 100644
+--- a/fs/cifs/dir.c
++++ b/fs/cifs/dir.c
+@@ -357,13 +357,10 @@ cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,
+ 	if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
+ 		create_options |= CREATE_OPTION_READONLY;
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = desired_access;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, create_options);
+ 	oparms.disposition = disposition;
+ 	oparms.path = full_path;
+ 	oparms.fid = fid;
+diff --git a/fs/cifs/file.c b/fs/cifs/file.c
+index eb9b34442b1d3..86924831fd4ba 100644
+--- a/fs/cifs/file.c
++++ b/fs/cifs/file.c
+@@ -223,9 +223,6 @@ cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
+ 	if (!buf)
+ 		return -ENOMEM;
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
+ 	if (f_flags & O_SYNC)
+ 		create_options |= CREATE_WRITE_THROUGH;
+@@ -236,7 +233,7 @@ cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = desired_access;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, create_options);
+ 	oparms.disposition = disposition;
+ 	oparms.path = full_path;
+ 	oparms.fid = fid;
+@@ -751,9 +748,6 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
+ 
+ 	desired_access = cifs_convert_flags(cfile->f_flags);
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
+ 	if (cfile->f_flags & O_SYNC)
+ 		create_options |= CREATE_WRITE_THROUGH;
+@@ -767,7 +761,7 @@ cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = desired_access;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, create_options);
+ 	oparms.disposition = disposition;
+ 	oparms.path = full_path;
+ 	oparms.fid = &cfile->fid;
+diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
+index fd9e289f3e72a..af0980c720c78 100644
+--- a/fs/cifs/inode.c
++++ b/fs/cifs/inode.c
+@@ -472,9 +472,7 @@ cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = GENERIC_READ;
+-	oparms.create_options = CREATE_NOT_DIR;
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options |= CREATE_OPEN_BACKUP_INTENT;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = path;
+ 	oparms.fid = &fid;
+@@ -1225,7 +1223,7 @@ cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
+-	oparms.create_options = CREATE_NOT_DIR;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = full_path;
+ 	oparms.fid = &fid;
+@@ -1763,7 +1761,7 @@ cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
+ 	oparms.cifs_sb = cifs_sb;
+ 	/* open the file to be renamed -- we need DELETE perms */
+ 	oparms.desired_access = DELETE;
+-	oparms.create_options = CREATE_NOT_DIR;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = from_path;
+ 	oparms.fid = &fid;
+diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
+index 9266dddd4b1eb..bc08d856ee05f 100644
+--- a/fs/cifs/ioctl.c
++++ b/fs/cifs/ioctl.c
+@@ -65,7 +65,7 @@ static long cifs_ioctl_query_info(unsigned int xid, struct file *filep,
+ 
+ 	if (tcon->ses->server->ops->ioctl_query_info)
+ 		rc = tcon->ses->server->ops->ioctl_query_info(
+-				xid, tcon, utf16_path,
++				xid, tcon, cifs_sb, utf16_path,
+ 				filep->private_data ? 0 : 1, p);
+ 	else
+ 		rc = -EOPNOTSUPP;
+diff --git a/fs/cifs/link.c b/fs/cifs/link.c
+index b4b15d611deda..02949a2f28608 100644
+--- a/fs/cifs/link.c
++++ b/fs/cifs/link.c
+@@ -318,7 +318,7 @@ cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = GENERIC_READ;
+-	oparms.create_options = CREATE_NOT_DIR;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = path;
+ 	oparms.fid = &fid;
+@@ -356,15 +356,11 @@ cifs_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
+ 	struct cifs_fid fid;
+ 	struct cifs_open_parms oparms;
+ 	struct cifs_io_parms io_parms;
+-	int create_options = CREATE_NOT_DIR;
+-
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+ 
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = GENERIC_WRITE;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
+ 	oparms.disposition = FILE_CREATE;
+ 	oparms.path = path;
+ 	oparms.fid = &fid;
+@@ -405,9 +401,7 @@ smb3_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = GENERIC_READ;
+-	oparms.create_options = CREATE_NOT_DIR;
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options |= CREATE_OPEN_BACKUP_INTENT;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+@@ -460,14 +454,10 @@ smb3_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
+ 	struct cifs_fid fid;
+ 	struct cifs_open_parms oparms;
+ 	struct cifs_io_parms io_parms;
+-	int create_options = CREATE_NOT_DIR;
+ 	__le16 *utf16_path;
+ 	__u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
+ 	struct kvec iov[2];
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	cifs_dbg(FYI, "%s: path: %s\n", __func__, path);
+ 
+ 	utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
+@@ -477,7 +467,7 @@ smb3_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = GENERIC_WRITE;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
+ 	oparms.disposition = FILE_CREATE;
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+diff --git a/fs/cifs/smb1ops.c b/fs/cifs/smb1ops.c
+index e523c05a44876..b130efaf8feb2 100644
+--- a/fs/cifs/smb1ops.c
++++ b/fs/cifs/smb1ops.c
+@@ -504,7 +504,8 @@ cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
+ }
+ 
+ static void
+-cifs_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
++cifs_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon,
++	      struct cifs_sb_info *cifs_sb)
+ {
+ 	CIFSSMBQFSDeviceInfo(xid, tcon);
+ 	CIFSSMBQFSAttributeInfo(xid, tcon);
+@@ -565,7 +566,7 @@ cifs_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
+ 		oparms.tcon = tcon;
+ 		oparms.cifs_sb = cifs_sb;
+ 		oparms.desired_access = FILE_READ_ATTRIBUTES;
+-		oparms.create_options = 0;
++		oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 		oparms.disposition = FILE_OPEN;
+ 		oparms.path = full_path;
+ 		oparms.fid = &fid;
+@@ -793,7 +794,7 @@ smb_set_file_info(struct inode *inode, const char *full_path,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = SYNCHRONIZE | FILE_WRITE_ATTRIBUTES;
+-	oparms.create_options = CREATE_NOT_DIR;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = full_path;
+ 	oparms.fid = &fid;
+@@ -872,7 +873,7 @@ cifs_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
+ 
+ static int
+ cifs_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
+-	     struct kstatfs *buf)
++	     struct cifs_sb_info *cifs_sb, struct kstatfs *buf)
+ {
+ 	int rc = -EOPNOTSUPP;
+ 
+@@ -970,7 +971,8 @@ cifs_query_symlink(const unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = FILE_READ_ATTRIBUTES;
+-	oparms.create_options = OPEN_REPARSE_POINT;
++	oparms.create_options = cifs_create_options(cifs_sb,
++						    OPEN_REPARSE_POINT);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = full_path;
+ 	oparms.fid = &fid;
+@@ -1029,7 +1031,6 @@ cifs_make_node(unsigned int xid, struct inode *inode,
+ 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+ 	struct inode *newinode = NULL;
+ 	int rc = -EPERM;
+-	int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
+ 	FILE_ALL_INFO *buf = NULL;
+ 	struct cifs_io_parms io_parms;
+ 	__u32 oplock = 0;
+@@ -1090,13 +1091,11 @@ cifs_make_node(unsigned int xid, struct inode *inode,
+ 		goto out;
+ 	}
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = GENERIC_WRITE;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR |
++						    CREATE_OPTION_SPECIAL);
+ 	oparms.disposition = FILE_CREATE;
+ 	oparms.path = full_path;
+ 	oparms.fid = &fid;
+diff --git a/fs/cifs/smb2inode.c b/fs/cifs/smb2inode.c
+index f2a6f7f28340d..c9abda93d65b4 100644
+--- a/fs/cifs/smb2inode.c
++++ b/fs/cifs/smb2inode.c
+@@ -98,9 +98,7 @@ smb2_compound_op(const unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = desired_access;
+ 	oparms.disposition = create_disposition;
+-	oparms.create_options = create_options;
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options |= CREATE_OPEN_BACKUP_INTENT;
++	oparms.create_options = cifs_create_options(cifs_sb, create_options);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 	oparms.mode = mode;
+@@ -456,7 +454,7 @@ smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
+ 
+ 	/* If it is a root and its handle is cached then use it */
+ 	if (!strlen(full_path) && !no_cached_open) {
+-		rc = open_shroot(xid, tcon, &fid);
++		rc = open_shroot(xid, tcon, cifs_sb, &fid);
+ 		if (rc)
+ 			goto out;
+ 
+@@ -473,9 +471,6 @@ smb2_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
+ 		goto out;
+ 	}
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	cifs_get_readable_path(tcon, full_path, &cfile);
+ 	rc = smb2_compound_op(xid, tcon, cifs_sb, full_path,
+ 			      FILE_READ_ATTRIBUTES, FILE_OPEN, create_options,
+diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c
+index 944c575a4a705..4cb0ebe7330eb 100644
+--- a/fs/cifs/smb2ops.c
++++ b/fs/cifs/smb2ops.c
+@@ -644,7 +644,8 @@ smb2_cached_lease_break(struct work_struct *work)
+ /*
+  * Open the directory at the root of a share
+  */
+-int open_shroot(unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *pfid)
++int open_shroot(unsigned int xid, struct cifs_tcon *tcon,
++		struct cifs_sb_info *cifs_sb, struct cifs_fid *pfid)
+ {
+ 	struct cifs_ses *ses = tcon->ses;
+ 	struct TCP_Server_Info *server = ses->server;
+@@ -696,7 +697,7 @@ int open_shroot(unsigned int xid, struct cifs_tcon *tcon, struct cifs_fid *pfid)
+ 	rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE;
+ 
+ 	oparms.tcon = tcon;
+-	oparms.create_options = 0;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.desired_access = FILE_READ_ATTRIBUTES;
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.fid = pfid;
+@@ -812,7 +813,8 @@ oshr_free:
+ }
+ 
+ static void
+-smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
++smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon,
++	      struct cifs_sb_info *cifs_sb)
+ {
+ 	int rc;
+ 	__le16 srch_path = 0; /* Null - open root of share */
+@@ -821,18 +823,19 @@ smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
+ 	struct cifs_fid fid;
+ 	bool no_cached_open = tcon->nohandlecache;
+ 
+-	oparms.tcon = tcon;
+-	oparms.desired_access = FILE_READ_ATTRIBUTES;
+-	oparms.disposition = FILE_OPEN;
+-	oparms.create_options = 0;
+-	oparms.fid = &fid;
+-	oparms.reconnect = false;
++	oparms = (struct cifs_open_parms) {
++		.tcon = tcon,
++		.desired_access = FILE_READ_ATTRIBUTES,
++		.disposition = FILE_OPEN,
++		.create_options = cifs_create_options(cifs_sb, 0),
++		.fid = &fid,
++	};
+ 
+ 	if (no_cached_open)
+ 		rc = SMB2_open(xid, &oparms, &srch_path, &oplock, NULL, NULL,
+ 			       NULL);
+ 	else
+-		rc = open_shroot(xid, tcon, &fid);
++		rc = open_shroot(xid, tcon, cifs_sb, &fid);
+ 
+ 	if (rc)
+ 		return;
+@@ -854,7 +857,8 @@ smb3_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
+ }
+ 
+ static void
+-smb2_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
++smb2_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon,
++	      struct cifs_sb_info *cifs_sb)
+ {
+ 	int rc;
+ 	__le16 srch_path = 0; /* Null - open root of share */
+@@ -865,7 +869,7 @@ smb2_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = FILE_READ_ATTRIBUTES;
+ 	oparms.disposition = FILE_OPEN;
+-	oparms.create_options = 0;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 
+@@ -900,10 +904,7 @@ smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = FILE_READ_ATTRIBUTES;
+ 	oparms.disposition = FILE_OPEN;
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options = CREATE_OPEN_BACKUP_INTENT;
+-	else
+-		oparms.create_options = 0;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 
+@@ -1179,10 +1180,7 @@ smb2_set_ea(const unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = FILE_WRITE_EA;
+ 	oparms.disposition = FILE_OPEN;
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options = CREATE_OPEN_BACKUP_INTENT;
+-	else
+-		oparms.create_options = 0;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 
+@@ -1414,6 +1412,7 @@ req_res_key_exit:
+ static int
+ smb2_ioctl_query_info(const unsigned int xid,
+ 		      struct cifs_tcon *tcon,
++		      struct cifs_sb_info *cifs_sb,
+ 		      __le16 *path, int is_dir,
+ 		      unsigned long p)
+ {
+@@ -1439,6 +1438,7 @@ smb2_ioctl_query_info(const unsigned int xid,
+ 	struct kvec close_iov[1];
+ 	unsigned int size[2];
+ 	void *data[2];
++	int create_options = is_dir ? CREATE_NOT_FILE : CREATE_NOT_DIR;
+ 
+ 	memset(rqst, 0, sizeof(rqst));
+ 	resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER;
+@@ -1474,10 +1474,7 @@ smb2_ioctl_query_info(const unsigned int xid,
+ 	memset(&oparms, 0, sizeof(oparms));
+ 	oparms.tcon = tcon;
+ 	oparms.disposition = FILE_OPEN;
+-	if (is_dir)
+-		oparms.create_options = CREATE_NOT_FILE;
+-	else
+-		oparms.create_options = CREATE_NOT_DIR;
++	oparms.create_options = cifs_create_options(cifs_sb, create_options);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 
+@@ -2074,10 +2071,7 @@ smb2_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = FILE_READ_ATTRIBUTES | FILE_READ_DATA;
+ 	oparms.disposition = FILE_OPEN;
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options = CREATE_OPEN_BACKUP_INTENT;
+-	else
+-		oparms.create_options = 0;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.fid = fid;
+ 	oparms.reconnect = false;
+ 
+@@ -2278,10 +2272,7 @@ smb2_query_info_compound(const unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = desired_access;
+ 	oparms.disposition = FILE_OPEN;
+-	if (cifs_sb && backup_cred(cifs_sb))
+-		oparms.create_options = CREATE_OPEN_BACKUP_INTENT;
+-	else
+-		oparms.create_options = 0;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 
+@@ -2337,7 +2328,7 @@ smb2_query_info_compound(const unsigned int xid, struct cifs_tcon *tcon,
+ 
+ static int
+ smb2_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
+-	     struct kstatfs *buf)
++	     struct cifs_sb_info *cifs_sb, struct kstatfs *buf)
+ {
+ 	struct smb2_query_info_rsp *rsp;
+ 	struct smb2_fs_full_size_info *info = NULL;
+@@ -2374,7 +2365,7 @@ qfs_exit:
+ 
+ static int
+ smb311_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
+-	     struct kstatfs *buf)
++	       struct cifs_sb_info *cifs_sb, struct kstatfs *buf)
+ {
+ 	int rc;
+ 	__le16 srch_path = 0; /* Null - open root of share */
+@@ -2383,12 +2374,12 @@ smb311_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
+ 	struct cifs_fid fid;
+ 
+ 	if (!tcon->posix_extensions)
+-		return smb2_queryfs(xid, tcon, buf);
++		return smb2_queryfs(xid, tcon, cifs_sb, buf);
+ 
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = FILE_READ_ATTRIBUTES;
+ 	oparms.disposition = FILE_OPEN;
+-	oparms.create_options = 0;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 
+@@ -2657,6 +2648,7 @@ smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon,
+ 	struct smb2_create_rsp *create_rsp;
+ 	struct smb2_ioctl_rsp *ioctl_rsp;
+ 	struct reparse_data_buffer *reparse_buf;
++	int create_options = is_reparse_point ? OPEN_REPARSE_POINT : 0;
+ 	u32 plen;
+ 
+ 	cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path);
+@@ -2683,14 +2675,7 @@ smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon,
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = FILE_READ_ATTRIBUTES;
+ 	oparms.disposition = FILE_OPEN;
+-
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options = CREATE_OPEN_BACKUP_INTENT;
+-	else
+-		oparms.create_options = 0;
+-	if (is_reparse_point)
+-		oparms.create_options = OPEN_REPARSE_POINT;
+-
++	oparms.create_options = cifs_create_options(cifs_sb, create_options);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 
+@@ -2869,11 +2854,6 @@ get_smb2_acl_by_path(struct cifs_sb_info *cifs_sb,
+ 	tcon = tlink_tcon(tlink);
+ 	xid = get_xid();
+ 
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options = CREATE_OPEN_BACKUP_INTENT;
+-	else
+-		oparms.create_options = 0;
+-
+ 	utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
+ 	if (!utf16_path) {
+ 		rc = -ENOMEM;
+@@ -2884,6 +2864,7 @@ get_smb2_acl_by_path(struct cifs_sb_info *cifs_sb,
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = READ_CONTROL;
+ 	oparms.disposition = FILE_OPEN;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.fid = &fid;
+ 	oparms.reconnect = false;
+ 
+@@ -2925,11 +2906,6 @@ set_smb2_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
+ 	tcon = tlink_tcon(tlink);
+ 	xid = get_xid();
+ 
+-	if (backup_cred(cifs_sb))
+-		oparms.create_options = CREATE_OPEN_BACKUP_INTENT;
+-	else
+-		oparms.create_options = 0;
+-
+ 	if (aclflag == CIFS_ACL_OWNER || aclflag == CIFS_ACL_GROUP)
+ 		access_flags = WRITE_OWNER;
+ 	else
+@@ -2944,6 +2920,7 @@ set_smb2_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
+ 
+ 	oparms.tcon = tcon;
+ 	oparms.desired_access = access_flags;
++	oparms.create_options = cifs_create_options(cifs_sb, 0);
+ 	oparms.disposition = FILE_OPEN;
+ 	oparms.path = path;
+ 	oparms.fid = &fid;
+@@ -4481,7 +4458,6 @@ smb2_make_node(unsigned int xid, struct inode *inode,
+ {
+ 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+ 	int rc = -EPERM;
+-	int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
+ 	FILE_ALL_INFO *buf = NULL;
+ 	struct cifs_io_parms io_parms;
+ 	__u32 oplock = 0;
+@@ -4517,13 +4493,11 @@ smb2_make_node(unsigned int xid, struct inode *inode,
+ 		goto out;
+ 	}
+ 
+-	if (backup_cred(cifs_sb))
+-		create_options |= CREATE_OPEN_BACKUP_INTENT;
+-
+ 	oparms.tcon = tcon;
+ 	oparms.cifs_sb = cifs_sb;
+ 	oparms.desired_access = GENERIC_WRITE;
+-	oparms.create_options = create_options;
++	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR |
++						    CREATE_OPTION_SPECIAL);
+ 	oparms.disposition = FILE_CREATE;
+ 	oparms.path = full_path;
+ 	oparms.fid = &fid;
+diff --git a/fs/cifs/smb2proto.h b/fs/cifs/smb2proto.h
+index 57f7075a35871..4d4c0faa3d8a3 100644
+--- a/fs/cifs/smb2proto.h
++++ b/fs/cifs/smb2proto.h
+@@ -67,7 +67,7 @@ extern int smb3_handle_read_data(struct TCP_Server_Info *server,
+ 				 struct mid_q_entry *mid);
+ 
+ extern int open_shroot(unsigned int xid, struct cifs_tcon *tcon,
+-			struct cifs_fid *pfid);
++		       struct cifs_sb_info *cifs_sb, struct cifs_fid *pfid);
+ extern void close_shroot(struct cached_fid *cfid);
+ extern void move_smb2_info_to_cifs(FILE_ALL_INFO *dst,
+ 				   struct smb2_file_all_info *src);
+diff --git a/fs/ext4/fsmap.c b/fs/ext4/fsmap.c
+index 37347ba868b70..d1ef651948d7e 100644
+--- a/fs/ext4/fsmap.c
++++ b/fs/ext4/fsmap.c
+@@ -486,6 +486,8 @@ static int ext4_getfsmap_datadev(struct super_block *sb,
+ 		keys[0].fmr_physical = bofs;
+ 	if (keys[1].fmr_physical >= eofs)
+ 		keys[1].fmr_physical = eofs - 1;
++	if (keys[1].fmr_physical < keys[0].fmr_physical)
++		return 0;
+ 	start_fsb = keys[0].fmr_physical;
+ 	end_fsb = keys[1].fmr_physical;
+ 
+diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
+index 5ef13ede04457..4eb4c23b04b93 100644
+--- a/fs/ext4/inline.c
++++ b/fs/ext4/inline.c
+@@ -157,7 +157,6 @@ int ext4_find_inline_data_nolock(struct inode *inode)
+ 					(void *)ext4_raw_inode(&is.iloc));
+ 		EXT4_I(inode)->i_inline_size = EXT4_MIN_INLINE_DATA_SIZE +
+ 				le32_to_cpu(is.s.here->e_value_size);
+-		ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
+ 	}
+ out:
+ 	brelse(is.iloc.bh);
+diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
+index cafa06114a1d1..63b10ee986d4f 100644
+--- a/fs/ext4/inode.c
++++ b/fs/ext4/inode.c
+@@ -4862,8 +4862,13 @@ static inline int ext4_iget_extra_inode(struct inode *inode,
+ 
+ 	if (EXT4_INODE_HAS_XATTR_SPACE(inode)  &&
+ 	    *magic == cpu_to_le32(EXT4_XATTR_MAGIC)) {
++		int err;
++
+ 		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
+-		return ext4_find_inline_data_nolock(inode);
++		err = ext4_find_inline_data_nolock(inode);
++		if (!err && ext4_has_inline_data(inode))
++			ext4_set_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
++		return err;
+ 	} else
+ 		EXT4_I(inode)->i_inline_off = 0;
+ 	return 0;
+diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
+index 645186927c1f8..306ad7d0003bb 100644
+--- a/fs/ext4/ioctl.c
++++ b/fs/ext4/ioctl.c
+@@ -179,6 +179,7 @@ static long swap_inode_boot_loader(struct super_block *sb,
+ 		ei_bl->i_flags = 0;
+ 		inode_set_iversion(inode_bl, 1);
+ 		i_size_write(inode_bl, 0);
++		EXT4_I(inode_bl)->i_disksize = inode_bl->i_size;
+ 		inode_bl->i_mode = S_IFREG;
+ 		if (ext4_has_feature_extents(sb)) {
+ 			ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS);
+diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
+index ee9e931e2e925..b708b437b3e36 100644
+--- a/fs/ext4/namei.c
++++ b/fs/ext4/namei.c
+@@ -1502,11 +1502,10 @@ static struct buffer_head *__ext4_find_entry(struct inode *dir,
+ 		int has_inline_data = 1;
+ 		ret = ext4_find_inline_entry(dir, fname, res_dir,
+ 					     &has_inline_data);
+-		if (has_inline_data) {
+-			if (inlined)
+-				*inlined = 1;
++		if (inlined)
++			*inlined = has_inline_data;
++		if (has_inline_data)
+ 			goto cleanup_and_exit;
+-		}
+ 	}
+ 
+ 	if ((namelen <= 2) && (name[0] == '.') &&
+@@ -3630,7 +3629,8 @@ static void ext4_resetent(handle_t *handle, struct ext4_renament *ent,
+ 	 * so the old->de may no longer valid and need to find it again
+ 	 * before reset old inode info.
+ 	 */
+-	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
++	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
++				 &old.inlined);
+ 	if (IS_ERR(old.bh))
+ 		retval = PTR_ERR(old.bh);
+ 	if (!old.bh)
+@@ -3795,9 +3795,20 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
+ 			return retval;
+ 	}
+ 
+-	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
+-	if (IS_ERR(old.bh))
+-		return PTR_ERR(old.bh);
++	/*
++	 * We need to protect against old.inode directory getting converted
++	 * from inline directory format into a normal one.
++	 */
++	if (S_ISDIR(old.inode->i_mode))
++		inode_lock_nested(old.inode, I_MUTEX_NONDIR2);
++
++	old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
++				 &old.inlined);
++	if (IS_ERR(old.bh)) {
++		retval = PTR_ERR(old.bh);
++		goto unlock_moved_dir;
++	}
++
+ 	/*
+ 	 *  Check for inode number is _not_ due to possible IO errors.
+ 	 *  We might rmdir the source, keep it as pwd of some process
+@@ -3855,8 +3866,10 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
+ 				goto end_rename;
+ 		}
+ 		retval = ext4_rename_dir_prepare(handle, &old);
+-		if (retval)
++		if (retval) {
++			inode_unlock(old.inode);
+ 			goto end_rename;
++		}
+ 	}
+ 	/*
+ 	 * If we're renaming a file within an inline_data dir and adding or
+@@ -3956,6 +3969,11 @@ release_bh:
+ 	brelse(old.dir_bh);
+ 	brelse(old.bh);
+ 	brelse(new.bh);
++
++unlock_moved_dir:
++	if (S_ISDIR(old.inode->i_mode))
++		inode_unlock(old.inode);
++
+ 	return retval;
+ }
+ 
+diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
+index cf794afbd52fb..254bc6b26d698 100644
+--- a/fs/ext4/xattr.c
++++ b/fs/ext4/xattr.c
+@@ -2819,6 +2819,9 @@ shift:
+ 			(void *)header, total_ino);
+ 	EXT4_I(inode)->i_extra_isize = new_extra_isize;
+ 
++	if (ext4_has_inline_data(inode))
++		error = ext4_find_inline_data_nolock(inode);
++
+ cleanup:
+ 	if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) {
+ 		ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
+diff --git a/fs/file.c b/fs/file.c
+index 51f53a7dc2218..e56059fa1b309 100644
+--- a/fs/file.c
++++ b/fs/file.c
+@@ -654,6 +654,7 @@ int __close_fd_get_file(unsigned int fd, struct file **res)
+ 	fdt = files_fdtable(files);
+ 	if (fd >= fdt->max_fds)
+ 		goto out_unlock;
++	fd = array_index_nospec(fd, fdt->max_fds);
+ 	file = fdt->fd[fd];
+ 	if (!file)
+ 		goto out_unlock;
+diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
+index c3bcac22c3894..a68535f36d135 100644
+--- a/include/asm-generic/vmlinux.lds.h
++++ b/include/asm-generic/vmlinux.lds.h
+@@ -825,7 +825,12 @@
+ #define TRACEDATA
+ #endif
+ 
++/*
++ * Discard .note.GNU-stack, which is emitted as PROGBITS by the compiler.
++ * Otherwise, the type of .notes section would become PROGBITS instead of NOTES.
++ */
+ #define NOTES								\
++	/DISCARD/ : { *(.note.GNU-stack) }				\
+ 	.notes : AT(ADDR(.notes) - LOAD_OFFSET) {			\
+ 		__start_notes = .;					\
+ 		KEEP(*(.note.*))					\
+@@ -900,10 +905,17 @@
+  * section definitions so that such archs put those in earlier section
+  * definitions.
+  */
++#ifdef RUNTIME_DISCARD_EXIT
++#define EXIT_DISCARDS
++#else
++#define EXIT_DISCARDS							\
++	EXIT_TEXT							\
++	EXIT_DATA
++#endif
++
+ #define DISCARDS							\
+ 	/DISCARD/ : {							\
+-	EXIT_TEXT							\
+-	EXIT_DATA							\
++	EXIT_DISCARDS							\
+ 	EXIT_CALL							\
+ 	*(.discard)							\
+ 	*(.discard.*)							\
+diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
+index 824d7a19dd66e..2552f66a7a891 100644
+--- a/include/linux/irqdomain.h
++++ b/include/linux/irqdomain.h
+@@ -254,7 +254,7 @@ static inline struct fwnode_handle *irq_domain_alloc_fwnode(phys_addr_t *pa)
+ }
+ 
+ void irq_domain_free_fwnode(struct fwnode_handle *fwnode);
+-struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
++struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, unsigned int size,
+ 				    irq_hw_number_t hwirq_max, int direct_max,
+ 				    const struct irq_domain_ops *ops,
+ 				    void *host_data);
+diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
+index a31aa3ac4219f..d35000669db5a 100644
+--- a/include/linux/pci_ids.h
++++ b/include/linux/pci_ids.h
+@@ -3106,6 +3106,8 @@
+ 
+ #define PCI_VENDOR_ID_3COM_2		0xa727
+ 
++#define PCI_VENDOR_ID_SOLIDRUN		0xd063
++
+ #define PCI_VENDOR_ID_DIGIUM		0xd161
+ #define PCI_DEVICE_ID_DIGIUM_HFC4S	0xb410
+ 
+diff --git a/include/net/netfilter/nf_tproxy.h b/include/net/netfilter/nf_tproxy.h
+index 82d0e41b76f22..faa108b1ba675 100644
+--- a/include/net/netfilter/nf_tproxy.h
++++ b/include/net/netfilter/nf_tproxy.h
+@@ -17,6 +17,13 @@ static inline bool nf_tproxy_sk_is_transparent(struct sock *sk)
+ 	return false;
+ }
+ 
++static inline void nf_tproxy_twsk_deschedule_put(struct inet_timewait_sock *tw)
++{
++	local_bh_disable();
++	inet_twsk_deschedule_put(tw);
++	local_bh_enable();
++}
++
+ /* assign a socket to the skb -- consumes sk */
+ static inline void nf_tproxy_assign_sock(struct sk_buff *skb, struct sock *sk)
+ {
+diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
+index 8fd65a0eb7f3e..5189bc5ebd895 100644
+--- a/kernel/bpf/btf.c
++++ b/kernel/bpf/btf.c
+@@ -2719,6 +2719,7 @@ static int btf_datasec_resolve(struct btf_verifier_env *env,
+ 	struct btf *btf = env->btf;
+ 	u16 i;
+ 
++	env->resolve_mode = RESOLVE_TBD;
+ 	for_each_vsi_from(i, v->next_member, v->t, vsi) {
+ 		u32 var_type_id = vsi->type, type_id, type_size = 0;
+ 		const struct btf_type *var_type = btf_type_by_id(env->btf,
+diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c
+index 3d1b570a1dadd..d40ae18fe6617 100644
+--- a/kernel/irq/irqdomain.c
++++ b/kernel/irq/irqdomain.c
+@@ -114,23 +114,12 @@ void irq_domain_free_fwnode(struct fwnode_handle *fwnode)
+ }
+ EXPORT_SYMBOL_GPL(irq_domain_free_fwnode);
+ 
+-/**
+- * __irq_domain_add() - Allocate a new irq_domain data structure
+- * @fwnode: firmware node for the interrupt controller
+- * @size: Size of linear map; 0 for radix mapping only
+- * @hwirq_max: Maximum number of interrupts supported by controller
+- * @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
+- *              direct mapping
+- * @ops: domain callbacks
+- * @host_data: Controller private data pointer
+- *
+- * Allocates and initializes an irq_domain structure.
+- * Returns pointer to IRQ domain, or NULL on failure.
+- */
+-struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
+-				    irq_hw_number_t hwirq_max, int direct_max,
+-				    const struct irq_domain_ops *ops,
+-				    void *host_data)
++static struct irq_domain *__irq_domain_create(struct fwnode_handle *fwnode,
++					      unsigned int size,
++					      irq_hw_number_t hwirq_max,
++					      int direct_max,
++					      const struct irq_domain_ops *ops,
++					      void *host_data)
+ {
+ 	struct device_node *of_node = to_of_node(fwnode);
+ 	struct irqchip_fwid *fwid;
+@@ -222,12 +211,44 @@ struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
+ 	domain->revmap_direct_max_irq = direct_max;
+ 	irq_domain_check_hierarchy(domain);
+ 
++	return domain;
++}
++
++static void __irq_domain_publish(struct irq_domain *domain)
++{
+ 	mutex_lock(&irq_domain_mutex);
+ 	debugfs_add_domain_dir(domain);
+ 	list_add(&domain->link, &irq_domain_list);
+ 	mutex_unlock(&irq_domain_mutex);
+ 
+ 	pr_debug("Added domain %s\n", domain->name);
++}
++
++/**
++ * __irq_domain_add() - Allocate a new irq_domain data structure
++ * @fwnode: firmware node for the interrupt controller
++ * @size: Size of linear map; 0 for radix mapping only
++ * @hwirq_max: Maximum number of interrupts supported by controller
++ * @direct_max: Maximum value of direct maps; Use ~0 for no limit; 0 for no
++ *              direct mapping
++ * @ops: domain callbacks
++ * @host_data: Controller private data pointer
++ *
++ * Allocates and initializes an irq_domain structure.
++ * Returns pointer to IRQ domain, or NULL on failure.
++ */
++struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, unsigned int size,
++				    irq_hw_number_t hwirq_max, int direct_max,
++				    const struct irq_domain_ops *ops,
++				    void *host_data)
++{
++	struct irq_domain *domain;
++
++	domain = __irq_domain_create(fwnode, size, hwirq_max, direct_max,
++				     ops, host_data);
++	if (domain)
++		__irq_domain_publish(domain);
++
+ 	return domain;
+ }
+ EXPORT_SYMBOL_GPL(__irq_domain_add);
+@@ -1068,12 +1089,15 @@ struct irq_domain *irq_domain_create_hierarchy(struct irq_domain *parent,
+ 	struct irq_domain *domain;
+ 
+ 	if (size)
+-		domain = irq_domain_create_linear(fwnode, size, ops, host_data);
++		domain = __irq_domain_create(fwnode, size, size, 0, ops, host_data);
+ 	else
+-		domain = irq_domain_create_tree(fwnode, ops, host_data);
++		domain = __irq_domain_create(fwnode, 0, ~0, 0, ops, host_data);
++
+ 	if (domain) {
+ 		domain->parent = parent;
+ 		domain->flags |= flags;
++
++		__irq_domain_publish(domain);
+ 	}
+ 
+ 	return domain;
+diff --git a/net/caif/caif_usb.c b/net/caif/caif_usb.c
+index 46c62dd1479b8..862226be22868 100644
+--- a/net/caif/caif_usb.c
++++ b/net/caif/caif_usb.c
+@@ -134,6 +134,9 @@ static int cfusbl_device_notify(struct notifier_block *me, unsigned long what,
+ 	struct usb_device *usbdev;
+ 	int res;
+ 
++	if (what == NETDEV_UNREGISTER && dev->reg_state >= NETREG_UNREGISTERED)
++		return 0;
++
+ 	/* Check whether we have a NCM device, and find its VID/PID. */
+ 	if (!(dev->dev.parent && dev->dev.parent->driver &&
+ 	      strcmp(dev->dev.parent->driver->name, "cdc_ncm") == 0))
+diff --git a/net/ipv4/netfilter/nf_tproxy_ipv4.c b/net/ipv4/netfilter/nf_tproxy_ipv4.c
+index b2bae0b0e42a1..61cb2341f50fe 100644
+--- a/net/ipv4/netfilter/nf_tproxy_ipv4.c
++++ b/net/ipv4/netfilter/nf_tproxy_ipv4.c
+@@ -38,7 +38,7 @@ nf_tproxy_handle_time_wait4(struct net *net, struct sk_buff *skb,
+ 					    hp->source, lport ? lport : hp->dest,
+ 					    skb->dev, NF_TPROXY_LOOKUP_LISTENER);
+ 		if (sk2) {
+-			inet_twsk_deschedule_put(inet_twsk(sk));
++			nf_tproxy_twsk_deschedule_put(inet_twsk(sk));
+ 			sk = sk2;
+ 		}
+ 	}
+diff --git a/net/ipv6/ila/ila_xlat.c b/net/ipv6/ila/ila_xlat.c
+index 5fc1f4e0c0cf0..10f1367eb4ca0 100644
+--- a/net/ipv6/ila/ila_xlat.c
++++ b/net/ipv6/ila/ila_xlat.c
+@@ -477,6 +477,7 @@ int ila_xlat_nl_cmd_get_mapping(struct sk_buff *skb, struct genl_info *info)
+ 
+ 	rcu_read_lock();
+ 
++	ret = -ESRCH;
+ 	ila = ila_lookup_by_params(&xp, ilan);
+ 	if (ila) {
+ 		ret = ila_dump_info(ila,
+diff --git a/net/ipv6/netfilter/nf_tproxy_ipv6.c b/net/ipv6/netfilter/nf_tproxy_ipv6.c
+index 34d51cd426b0c..00761924f2766 100644
+--- a/net/ipv6/netfilter/nf_tproxy_ipv6.c
++++ b/net/ipv6/netfilter/nf_tproxy_ipv6.c
+@@ -63,7 +63,7 @@ nf_tproxy_handle_time_wait6(struct sk_buff *skb, int tproto, int thoff,
+ 					    lport ? lport : hp->dest,
+ 					    skb->dev, NF_TPROXY_LOOKUP_LISTENER);
+ 		if (sk2) {
+-			inet_twsk_deschedule_put(inet_twsk(sk));
++			nf_tproxy_twsk_deschedule_put(inet_twsk(sk));
+ 			sk = sk2;
+ 		}
+ 	}
+diff --git a/net/nfc/netlink.c b/net/nfc/netlink.c
+index c4c57830e9636..66ab97131fd24 100644
+--- a/net/nfc/netlink.c
++++ b/net/nfc/netlink.c
+@@ -1454,8 +1454,8 @@ static int nfc_se_io(struct nfc_dev *dev, u32 se_idx,
+ 	return rc;
+ 
+ error:
+-	kfree(cb_context);
+ 	device_unlock(&dev->dev);
++	kfree(cb_context);
+ 	return rc;
+ }
+ 
+diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c
+index 5d696b7fb47e1..b398d72a7bc39 100644
+--- a/net/smc/af_smc.c
++++ b/net/smc/af_smc.c
+@@ -1542,16 +1542,14 @@ static int smc_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
+ {
+ 	struct sock *sk = sock->sk;
+ 	struct smc_sock *smc;
+-	int rc = -EPIPE;
++	int rc;
+ 
+ 	smc = smc_sk(sk);
+ 	lock_sock(sk);
+-	if ((sk->sk_state != SMC_ACTIVE) &&
+-	    (sk->sk_state != SMC_APPCLOSEWAIT1) &&
+-	    (sk->sk_state != SMC_INIT))
+-		goto out;
+ 
++	/* SMC does not support connect with fastopen */
+ 	if (msg->msg_flags & MSG_FASTOPEN) {
++		/* not connected yet, fallback */
+ 		if (sk->sk_state == SMC_INIT && !smc->connect_nonblock) {
+ 			smc_switch_to_fallback(smc);
+ 			smc->fallback_rsn = SMC_CLC_DECL_OPTUNSUPP;
+@@ -1559,6 +1557,11 @@ static int smc_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
+ 			rc = -EINVAL;
+ 			goto out;
+ 		}
++	} else if ((sk->sk_state != SMC_ACTIVE) &&
++		   (sk->sk_state != SMC_APPCLOSEWAIT1) &&
++		   (sk->sk_state != SMC_INIT)) {
++		rc = -EPIPE;
++		goto out;
+ 	}
+ 
+ 	if (smc->use_fallback)
+diff --git a/tools/testing/selftests/netfilter/nft_nat.sh b/tools/testing/selftests/netfilter/nft_nat.sh
+index 4e15e81673104..67697d8ea59a5 100755
+--- a/tools/testing/selftests/netfilter/nft_nat.sh
++++ b/tools/testing/selftests/netfilter/nft_nat.sh
+@@ -404,6 +404,8 @@ EOF
+ 	echo SERVER-$family | ip netns exec "$ns1" timeout 5 socat -u STDIN TCP-LISTEN:2000 &
+ 	sc_s=$!
+ 
++	sleep 1
++
+ 	result=$(ip netns exec "$ns0" timeout 1 socat TCP:$daddr:2000 STDOUT)
+ 
+ 	if [ "$result" = "SERVER-inet" ];then